paricafe/packages/backend/src/server/ActivityPubServerService.ts

776 lines
22 KiB
TypeScript
Raw Normal View History

/*
* SPDX-FileCopyrightText: syuilo and other misskey contributors
* SPDX-License-Identifier: AGPL-3.0-only
*/
import * as crypto from 'node:crypto';
2023-02-08 19:46:01 -06:00
import { IncomingMessage } from 'node:http';
2022-09-17 13:27:08 -05:00
import { Inject, Injectable } from '@nestjs/common';
import fastifyAccepts from '@fastify/accepts';
2022-09-17 13:27:08 -05:00
import httpSignature from '@peertube/http-signature';
import { Brackets, In, IsNull, LessThan, Not } from 'typeorm';
import accepts from 'accepts';
import vary from 'vary';
import secureJson from 'secure-json-parse';
2022-09-17 13:27:08 -05:00
import { DI } from '@/di-symbols.js';
import type { FollowingsRepository, NotesRepository, EmojisRepository, NoteReactionsRepository, UserProfilesRepository, UserNotePiningsRepository, UsersRepository, FollowRequestsRepository } from '@/models/_.js';
2022-09-17 13:27:08 -05:00
import * as url from '@/misc/prelude/url.js';
2022-09-20 15:33:11 -05:00
import type { Config } from '@/config.js';
2022-12-03 19:16:03 -06:00
import { ApRendererService } from '@/core/activitypub/ApRendererService.js';
2022-09-17 13:27:08 -05:00
import { QueueService } from '@/core/QueueService.js';
import type { MiLocalUser, MiRemoteUser, MiUser } from '@/models/User.js';
import { UserKeypairService } from '@/core/UserKeypairService.js';
import type { MiFollowing } from '@/models/Following.js';
2022-09-17 13:27:08 -05:00
import { countIf } from '@/misc/prelude/array.js';
import type { MiNote } from '@/models/Note.js';
2022-09-17 13:27:08 -05:00
import { QueryService } from '@/core/QueryService.js';
import { UtilityService } from '@/core/UtilityService.js';
import { UserEntityService } from '@/core/entities/UserEntityService.js';
import { bindThis } from '@/decorators.js';
2023-02-08 19:46:01 -06:00
import { IActivity } from '@/core/activitypub/type.js';
import { isPureRenote } from '@/misc/is-pure-renote.js';
import type { FastifyInstance, FastifyRequest, FastifyReply, FastifyPluginOptions, FastifyBodyParser } from 'fastify';
2022-09-17 13:27:08 -05:00
import type { FindOptionsWhere } from 'typeorm';
const ACTIVITY_JSON = 'application/activity+json; charset=utf-8';
const LD_JSON = 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"; charset=utf-8';
@Injectable()
export class ActivityPubServerService {
constructor(
@Inject(DI.config)
private config: Config,
@Inject(DI.usersRepository)
private usersRepository: UsersRepository,
@Inject(DI.userProfilesRepository)
private userProfilesRepository: UserProfilesRepository,
@Inject(DI.notesRepository)
private notesRepository: NotesRepository,
@Inject(DI.noteReactionsRepository)
private noteReactionsRepository: NoteReactionsRepository,
@Inject(DI.emojisRepository)
private emojisRepository: EmojisRepository,
@Inject(DI.userNotePiningsRepository)
private userNotePiningsRepository: UserNotePiningsRepository,
@Inject(DI.followingsRepository)
private followingsRepository: FollowingsRepository,
@Inject(DI.followRequestsRepository)
private followRequestsRepository: FollowRequestsRepository,
2022-09-17 13:27:08 -05:00
private utilityService: UtilityService,
private userEntityService: UserEntityService,
private apRendererService: ApRendererService,
private queueService: QueueService,
private userKeypairService: UserKeypairService,
2022-09-17 13:27:08 -05:00
private queryService: QueryService,
) {
//this.createServer = this.createServer.bind(this);
2022-09-17 13:27:08 -05:00
}
@bindThis
private setResponseType(request: FastifyRequest, reply: FastifyReply): void {
const accept = request.accepts().type([ACTIVITY_JSON, LD_JSON]);
2022-09-17 13:27:08 -05:00
if (accept === LD_JSON) {
reply.type(LD_JSON);
2022-09-17 13:27:08 -05:00
} else {
reply.type(ACTIVITY_JSON);
2022-09-17 13:27:08 -05:00
}
}
/**
* Pack Create<Note> or Announce Activity
* @param note Note
*/
@bindThis
private async packActivity(note: MiNote): Promise<any> {
if (isPureRenote(note)) {
2022-09-22 16:21:31 -05:00
const renote = await this.notesRepository.findOneByOrFail({ id: note.renoteId });
2022-09-17 13:27:08 -05:00
return this.apRendererService.renderAnnounce(renote.uri ? renote.uri : `${this.config.url}/notes/${renote.id}`, note);
}
return this.apRendererService.renderCreate(await this.apRendererService.renderNote(note, false), note);
}
@bindThis
private inbox(request: FastifyRequest, reply: FastifyReply) {
2022-12-24 23:53:50 -06:00
let signature;
2022-09-17 13:27:08 -05:00
try {
signature = httpSignature.parseRequest(request.raw, { 'headers': [] });
2022-09-17 13:27:08 -05:00
} catch (e) {
reply.code(401);
2022-09-17 13:27:08 -05:00
return;
}
if (signature.params.headers.indexOf('host') === -1
|| request.headers.host !== this.config.host) {
// Host not specified or not match.
reply.code(401);
return;
}
if (signature.params.headers.indexOf('digest') === -1) {
// Digest not found.
reply.code(401);
} else {
const digest = request.headers.digest;
if (typeof digest !== 'string') {
// Huh?
reply.code(401);
return;
}
const re = /^([a-zA-Z0-9\-]+)=(.+)$/;
const match = digest.match(re);
if (match == null) {
// Invalid digest
reply.code(401);
return;
}
const algo = match[1];
const digestValue = match[2];
if (algo !== 'SHA-256') {
// Unsupported digest algorithm
reply.code(401);
return;
}
if (request.rawBody == null) {
// Bad request
reply.code(400);
return;
}
const hash = crypto.createHash('sha256').update(request.rawBody).digest('base64');
if (hash !== digestValue) {
// Invalid digest
reply.code(401);
return;
}
}
2023-02-08 19:46:01 -06:00
this.queueService.inbox(request.body as IActivity, signature);
2022-09-17 13:27:08 -05:00
reply.code(202);
2022-09-17 13:27:08 -05:00
}
@bindThis
private async followers(
request: FastifyRequest<{ Params: { user: string; }; Querystring: { cursor?: string; page?: string; }; }>,
reply: FastifyReply,
) {
const userId = request.params.user;
2022-09-17 13:27:08 -05:00
const cursor = request.query.cursor;
2022-09-17 13:27:08 -05:00
if (cursor != null && typeof cursor !== 'string') {
reply.code(400);
2022-09-17 13:27:08 -05:00
return;
}
const page = request.query.page === 'true';
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
id: userId,
host: IsNull(),
});
if (user == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
//#region Check ff visibility
const profile = await this.userProfilesRepository.findOneByOrFail({ userId: user.id });
if (profile.ffVisibility === 'private') {
reply.code(403);
reply.header('Cache-Control', 'public, max-age=30');
2022-09-17 13:27:08 -05:00
return;
} else if (profile.ffVisibility === 'followers') {
reply.code(403);
reply.header('Cache-Control', 'public, max-age=30');
2022-09-17 13:27:08 -05:00
return;
}
//#endregion
const limit = 10;
const partOf = `${this.config.url}/users/${userId}/followers`;
if (page) {
const query = {
followeeId: user.id,
} as FindOptionsWhere<MiFollowing>;
2022-09-17 13:27:08 -05:00
// カーソルが指定されている場合
if (cursor) {
query.id = LessThan(cursor);
}
// Get followers
const followings = await this.followingsRepository.find({
where: query,
take: limit + 1,
order: { id: -1 },
});
// 「次のページ」があるかどうか
const inStock = followings.length === limit + 1;
if (inStock) followings.pop();
const renderedFollowers = await Promise.all(followings.map(following => this.apRendererService.renderFollowUser(following.followerId)));
const rendered = this.apRendererService.renderOrderedCollectionPage(
`${partOf}?${url.query({
page: 'true',
cursor,
})}`,
user.followersCount, renderedFollowers, partOf,
undefined,
inStock ? `${partOf}?${url.query({
page: 'true',
cursor: followings.at(-1)!.id,
2022-09-17 13:27:08 -05:00
})}` : undefined,
);
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
} else {
// index page
refactor(backend): `core/activitypub` (#11247) * eslint: `explicit-function-return-type` * eslint: `no-unnecessary-condition` * eslint: `eslint-disable-next-line` * eslint: `no-unused-vars` * eslint: `comma-dangle` * eslint: `import/order` * cleanup: unnecessary non-null assertion * cleanup: `IActivity`に`actor`は常に存在するようなので * cleanup: unnecessary `as` * cleanup: unnecessary `Promise.resolve` * cleanup * refactor: `String.prototype.match()`である必要がない部分をよりシンプルな書き方に変更 * refactor: よりよい型定義 * refactor: よりよい型定義 - `LdSignature`の`normalize`メソッドでの使われ方から、 - `data`引数の型定義を`any`から`JsonLdDocument`へ修正 - `getLoader`メソッドの返り値の型定義の一部を`any`から`RemoteDocument`へ修正 - `contextUrl`が不正な値(`null`)となっていたことが判明したため`undefined`へ修正 - `document`の型と合わせるために`CONTEXTS`の型定義の一部を`unknown`から`JsonLd`へ修正 - とりあえず`satisfies`を使用 - `document`の型と合わせるために`fetchDocument`メソッドの返り値の型定義の一部を`unknown`から`JsonLd`へ修正 - どうしようもなく`as`を使用 * refactor: 型ガードを使うことでnon-null assertionをやめた * refactor: non-null assertionをやめた `.filter()`で行っている型ガードなどの文脈から、より適しているだろうと思われる書き方に変更した。 * refactor: 型ガードを使うことで`as`をやめた * refactor: `as`をやめた * refactor: よりよい型定義 - `id`は`null`とのunionになっていたが、`null`を渡している場面はなかった - またおそらくこのメソッドは`IOrderedCollection`を返すため、そちらに合わせて`null`とのunionをやめた - `IOrderedCollection`とはまだ型に相違がある - `totalItems`をコメントや使われ方を元に`number`へ推論 * refactor: `for-of` -> `Array.prototype.map` * refactor: `delete`演算子を使わない形に
2023-07-12 22:48:34 -05:00
const rendered = this.apRendererService.renderOrderedCollection(
partOf,
user.followersCount,
`${partOf}?page=true`,
);
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
}
}
@bindThis
private async following(
request: FastifyRequest<{ Params: { user: string; }; Querystring: { cursor?: string; page?: string; }; }>,
reply: FastifyReply,
) {
const userId = request.params.user;
2022-09-17 13:27:08 -05:00
const cursor = request.query.cursor;
2022-09-17 13:27:08 -05:00
if (cursor != null && typeof cursor !== 'string') {
reply.code(400);
2022-09-17 13:27:08 -05:00
return;
}
const page = request.query.page === 'true';
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
id: userId,
host: IsNull(),
});
2022-09-17 13:27:08 -05:00
if (user == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
2022-09-17 13:27:08 -05:00
//#region Check ff visibility
const profile = await this.userProfilesRepository.findOneByOrFail({ userId: user.id });
2022-09-17 13:27:08 -05:00
if (profile.ffVisibility === 'private') {
reply.code(403);
reply.header('Cache-Control', 'public, max-age=30');
2022-09-17 13:27:08 -05:00
return;
} else if (profile.ffVisibility === 'followers') {
reply.code(403);
reply.header('Cache-Control', 'public, max-age=30');
2022-09-17 13:27:08 -05:00
return;
}
//#endregion
2022-09-17 13:27:08 -05:00
const limit = 10;
const partOf = `${this.config.url}/users/${userId}/following`;
2022-09-17 13:27:08 -05:00
if (page) {
const query = {
followerId: user.id,
} as FindOptionsWhere<MiFollowing>;
2022-09-17 13:27:08 -05:00
// カーソルが指定されている場合
if (cursor) {
query.id = LessThan(cursor);
}
2022-09-17 13:27:08 -05:00
// Get followings
const followings = await this.followingsRepository.find({
where: query,
take: limit + 1,
order: { id: -1 },
});
2022-09-17 13:27:08 -05:00
// 「次のページ」があるかどうか
const inStock = followings.length === limit + 1;
if (inStock) followings.pop();
2022-09-17 13:27:08 -05:00
const renderedFollowees = await Promise.all(followings.map(following => this.apRendererService.renderFollowUser(following.followeeId)));
const rendered = this.apRendererService.renderOrderedCollectionPage(
`${partOf}?${url.query({
page: 'true',
cursor,
})}`,
user.followingCount, renderedFollowees, partOf,
undefined,
inStock ? `${partOf}?${url.query({
page: 'true',
cursor: followings.at(-1)!.id,
2022-09-17 13:27:08 -05:00
})}` : undefined,
);
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
} else {
// index page
refactor(backend): `core/activitypub` (#11247) * eslint: `explicit-function-return-type` * eslint: `no-unnecessary-condition` * eslint: `eslint-disable-next-line` * eslint: `no-unused-vars` * eslint: `comma-dangle` * eslint: `import/order` * cleanup: unnecessary non-null assertion * cleanup: `IActivity`に`actor`は常に存在するようなので * cleanup: unnecessary `as` * cleanup: unnecessary `Promise.resolve` * cleanup * refactor: `String.prototype.match()`である必要がない部分をよりシンプルな書き方に変更 * refactor: よりよい型定義 * refactor: よりよい型定義 - `LdSignature`の`normalize`メソッドでの使われ方から、 - `data`引数の型定義を`any`から`JsonLdDocument`へ修正 - `getLoader`メソッドの返り値の型定義の一部を`any`から`RemoteDocument`へ修正 - `contextUrl`が不正な値(`null`)となっていたことが判明したため`undefined`へ修正 - `document`の型と合わせるために`CONTEXTS`の型定義の一部を`unknown`から`JsonLd`へ修正 - とりあえず`satisfies`を使用 - `document`の型と合わせるために`fetchDocument`メソッドの返り値の型定義の一部を`unknown`から`JsonLd`へ修正 - どうしようもなく`as`を使用 * refactor: 型ガードを使うことでnon-null assertionをやめた * refactor: non-null assertionをやめた `.filter()`で行っている型ガードなどの文脈から、より適しているだろうと思われる書き方に変更した。 * refactor: 型ガードを使うことで`as`をやめた * refactor: `as`をやめた * refactor: よりよい型定義 - `id`は`null`とのunionになっていたが、`null`を渡している場面はなかった - またおそらくこのメソッドは`IOrderedCollection`を返すため、そちらに合わせて`null`とのunionをやめた - `IOrderedCollection`とはまだ型に相違がある - `totalItems`をコメントや使われ方を元に`number`へ推論 * refactor: `for-of` -> `Array.prototype.map` * refactor: `delete`演算子を使わない形に
2023-07-12 22:48:34 -05:00
const rendered = this.apRendererService.renderOrderedCollection(
partOf,
user.followingCount,
`${partOf}?page=true`,
);
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
}
}
@bindThis
private async featured(request: FastifyRequest<{ Params: { user: string; }; }>, reply: FastifyReply) {
const userId = request.params.user;
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
id: userId,
host: IsNull(),
});
if (user == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
const pinings = await this.userNotePiningsRepository.find({
where: { userId: user.id },
order: { id: 'DESC' },
});
const pinnedNotes = (await Promise.all(pinings.map(pining =>
this.notesRepository.findOneByOrFail({ id: pining.noteId }))))
.filter(note => !note.localOnly && ['public', 'home'].includes(note.visibility));
2022-09-17 13:27:08 -05:00
const renderedNotes = await Promise.all(pinnedNotes.map(note => this.apRendererService.renderNote(note)));
const rendered = this.apRendererService.renderOrderedCollection(
`${this.config.url}/users/${userId}/collections/featured`,
refactor(backend): `core/activitypub` (#11247) * eslint: `explicit-function-return-type` * eslint: `no-unnecessary-condition` * eslint: `eslint-disable-next-line` * eslint: `no-unused-vars` * eslint: `comma-dangle` * eslint: `import/order` * cleanup: unnecessary non-null assertion * cleanup: `IActivity`に`actor`は常に存在するようなので * cleanup: unnecessary `as` * cleanup: unnecessary `Promise.resolve` * cleanup * refactor: `String.prototype.match()`である必要がない部分をよりシンプルな書き方に変更 * refactor: よりよい型定義 * refactor: よりよい型定義 - `LdSignature`の`normalize`メソッドでの使われ方から、 - `data`引数の型定義を`any`から`JsonLdDocument`へ修正 - `getLoader`メソッドの返り値の型定義の一部を`any`から`RemoteDocument`へ修正 - `contextUrl`が不正な値(`null`)となっていたことが判明したため`undefined`へ修正 - `document`の型と合わせるために`CONTEXTS`の型定義の一部を`unknown`から`JsonLd`へ修正 - とりあえず`satisfies`を使用 - `document`の型と合わせるために`fetchDocument`メソッドの返り値の型定義の一部を`unknown`から`JsonLd`へ修正 - どうしようもなく`as`を使用 * refactor: 型ガードを使うことでnon-null assertionをやめた * refactor: non-null assertionをやめた `.filter()`で行っている型ガードなどの文脈から、より適しているだろうと思われる書き方に変更した。 * refactor: 型ガードを使うことで`as`をやめた * refactor: `as`をやめた * refactor: よりよい型定義 - `id`は`null`とのunionになっていたが、`null`を渡している場面はなかった - またおそらくこのメソッドは`IOrderedCollection`を返すため、そちらに合わせて`null`とのunionをやめた - `IOrderedCollection`とはまだ型に相違がある - `totalItems`をコメントや使われ方を元に`number`へ推論 * refactor: `for-of` -> `Array.prototype.map` * refactor: `delete`演算子を使わない形に
2023-07-12 22:48:34 -05:00
renderedNotes.length,
undefined,
undefined,
renderedNotes,
2022-09-17 13:27:08 -05:00
);
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
}
@bindThis
private async outbox(
request: FastifyRequest<{
Params: { user: string; };
Querystring: { since_id?: string; until_id?: string; page?: string; };
}>,
reply: FastifyReply,
) {
const userId = request.params.user;
2022-09-17 13:27:08 -05:00
const sinceId = request.query.since_id;
2022-09-17 13:27:08 -05:00
if (sinceId != null && typeof sinceId !== 'string') {
reply.code(400);
2022-09-17 13:27:08 -05:00
return;
}
const untilId = request.query.until_id;
2022-09-17 13:27:08 -05:00
if (untilId != null && typeof untilId !== 'string') {
reply.code(400);
2022-09-17 13:27:08 -05:00
return;
}
const page = request.query.page === 'true';
2022-09-17 13:27:08 -05:00
if (countIf(x => x != null, [sinceId, untilId]) > 1) {
reply.code(400);
2022-09-17 13:27:08 -05:00
return;
}
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
id: userId,
host: IsNull(),
});
2022-09-17 13:27:08 -05:00
if (user == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
2022-09-17 13:27:08 -05:00
const limit = 20;
const partOf = `${this.config.url}/users/${userId}/outbox`;
2022-09-17 13:27:08 -05:00
if (page) {
const query = this.queryService.makePaginationQuery(this.notesRepository.createQueryBuilder('note'), sinceId, untilId)
.andWhere('note.userId = :userId', { userId: user.id })
2023-10-08 23:32:41 -05:00
.andWhere(new Brackets(qb => {
qb
.where('note.visibility = \'public\'')
.orWhere('note.visibility = \'home\'');
2022-09-17 13:27:08 -05:00
}))
.andWhere('note.localOnly = FALSE');
const notes = await query.limit(limit).getMany();
2022-09-17 13:27:08 -05:00
if (sinceId) notes.reverse();
2022-09-18 13:11:50 -05:00
const activities = await Promise.all(notes.map(note => this.packActivity(note)));
2022-09-17 13:27:08 -05:00
const rendered = this.apRendererService.renderOrderedCollectionPage(
`${partOf}?${url.query({
page: 'true',
since_id: sinceId,
until_id: untilId,
})}`,
user.notesCount, activities, partOf,
notes.length ? `${partOf}?${url.query({
page: 'true',
since_id: notes[0].id,
})}` : undefined,
notes.length ? `${partOf}?${url.query({
page: 'true',
until_id: notes.at(-1)!.id,
2022-09-17 13:27:08 -05:00
})}` : undefined,
);
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
} else {
// index page
refactor(backend): `core/activitypub` (#11247) * eslint: `explicit-function-return-type` * eslint: `no-unnecessary-condition` * eslint: `eslint-disable-next-line` * eslint: `no-unused-vars` * eslint: `comma-dangle` * eslint: `import/order` * cleanup: unnecessary non-null assertion * cleanup: `IActivity`に`actor`は常に存在するようなので * cleanup: unnecessary `as` * cleanup: unnecessary `Promise.resolve` * cleanup * refactor: `String.prototype.match()`である必要がない部分をよりシンプルな書き方に変更 * refactor: よりよい型定義 * refactor: よりよい型定義 - `LdSignature`の`normalize`メソッドでの使われ方から、 - `data`引数の型定義を`any`から`JsonLdDocument`へ修正 - `getLoader`メソッドの返り値の型定義の一部を`any`から`RemoteDocument`へ修正 - `contextUrl`が不正な値(`null`)となっていたことが判明したため`undefined`へ修正 - `document`の型と合わせるために`CONTEXTS`の型定義の一部を`unknown`から`JsonLd`へ修正 - とりあえず`satisfies`を使用 - `document`の型と合わせるために`fetchDocument`メソッドの返り値の型定義の一部を`unknown`から`JsonLd`へ修正 - どうしようもなく`as`を使用 * refactor: 型ガードを使うことでnon-null assertionをやめた * refactor: non-null assertionをやめた `.filter()`で行っている型ガードなどの文脈から、より適しているだろうと思われる書き方に変更した。 * refactor: 型ガードを使うことで`as`をやめた * refactor: `as`をやめた * refactor: よりよい型定義 - `id`は`null`とのunionになっていたが、`null`を渡している場面はなかった - またおそらくこのメソッドは`IOrderedCollection`を返すため、そちらに合わせて`null`とのunionをやめた - `IOrderedCollection`とはまだ型に相違がある - `totalItems`をコメントや使われ方を元に`number`へ推論 * refactor: `for-of` -> `Array.prototype.map` * refactor: `delete`演算子を使わない形に
2023-07-12 22:48:34 -05:00
const rendered = this.apRendererService.renderOrderedCollection(
partOf,
user.notesCount,
2022-09-17 13:27:08 -05:00
`${partOf}?page=true`,
`${partOf}?page=true&since_id=000000000000000000000000`,
);
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(rendered));
2022-09-17 13:27:08 -05:00
}
}
@bindThis
private async userInfo(request: FastifyRequest, reply: FastifyReply, user: MiUser | null) {
2022-09-17 13:27:08 -05:00
if (user == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
return (this.apRendererService.addContext(await this.apRendererService.renderPerson(user as MiLocalUser)));
2022-09-17 13:27:08 -05:00
}
@bindThis
public createServer(fastify: FastifyInstance, options: FastifyPluginOptions, done: (err?: Error) => void) {
2023-02-08 19:46:01 -06:00
// addConstraintStrategy の型定義がおかしいため
(fastify.addConstraintStrategy as any)({
name: 'apOrHtml',
storage() {
2023-02-08 19:46:01 -06:00
const store = {} as any;
return {
2023-02-08 19:46:01 -06:00
get(key: string) {
return store[key] ?? null;
},
2023-02-08 19:46:01 -06:00
set(key: string, value: any) {
store[key] = value;
},
};
},
2023-02-08 19:46:01 -06:00
deriveConstraint(request: IncomingMessage) {
const accepted = accepts(request).type(['html', ACTIVITY_JSON, LD_JSON]);
const isAp = typeof accepted === 'string' && !accepted.match(/html/);
return isAp ? 'ap' : 'html';
},
});
2022-09-17 13:27:08 -05:00
const almostDefaultJsonParser: FastifyBodyParser<Buffer> = function (request, rawBody, done) {
if (rawBody.length === 0) {
const err = new Error('Body cannot be empty!') as any;
err.statusCode = 400;
return done(err);
}
try {
const json = secureJson.parse(rawBody.toString('utf8'), null, {
protoAction: 'ignore',
constructorAction: 'ignore',
});
done(null, json);
} catch (err: any) {
err.statusCode = 400;
return done(err);
}
};
fastify.register(fastifyAccepts);
fastify.addContentTypeParser('application/activity+json', { parseAs: 'buffer' }, almostDefaultJsonParser);
fastify.addContentTypeParser('application/ld+json', { parseAs: 'buffer' }, almostDefaultJsonParser);
2022-09-17 13:27:08 -05:00
fastify.addHook('onRequest', (request, reply, done) => {
reply.header('Access-Control-Allow-Headers', 'Accept');
reply.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
reply.header('Access-Control-Allow-Origin', '*');
reply.header('Access-Control-Expose-Headers', 'Vary');
done();
});
//#region Routing
2022-12-24 23:56:59 -06:00
// inbox (limit: 64kb)
fastify.post('/inbox', { config: { rawBody: true }, bodyLimit: 1024 * 64 }, async (request, reply) => await this.inbox(request, reply));
fastify.post('/users/:user/inbox', { config: { rawBody: true }, bodyLimit: 1024 * 64 }, async (request, reply) => await this.inbox(request, reply));
2022-09-17 13:27:08 -05:00
// note
fastify.get<{ Params: { note: string; } }>('/notes/:note', { constraints: { apOrHtml: 'ap' } }, async (request, reply) => {
vary(reply.raw, 'Accept');
2022-09-17 13:27:08 -05:00
const note = await this.notesRepository.findOneBy({
id: request.params.note,
visibility: In(['public', 'home']),
2022-09-17 13:27:08 -05:00
localOnly: false,
});
if (note == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
// リモートだったらリダイレクト
if (note.userHost != null) {
if (note.uri == null || this.utilityService.isSelfHost(note.userHost)) {
reply.code(500);
2022-09-17 13:27:08 -05:00
return;
}
reply.redirect(note.uri);
2022-09-17 13:27:08 -05:00
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return this.apRendererService.addContext(await this.apRendererService.renderNote(note, false));
2022-09-17 13:27:08 -05:00
});
// note activity
fastify.get<{ Params: { note: string; } }>('/notes/:note/activity', async (request, reply) => {
vary(reply.raw, 'Accept');
2022-09-17 13:27:08 -05:00
const note = await this.notesRepository.findOneBy({
id: request.params.note,
2022-09-17 13:27:08 -05:00
userHost: IsNull(),
visibility: In(['public', 'home']),
2022-09-17 13:27:08 -05:00
localOnly: false,
});
if (note == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(await this.packActivity(note)));
2022-09-17 13:27:08 -05:00
});
// outbox
fastify.get<{
Params: { user: string; };
Querystring: { since_id?: string; until_id?: string; page?: string; };
}>('/users/:user/outbox', async (request, reply) => await this.outbox(request, reply));
2022-09-17 13:27:08 -05:00
// followers
fastify.get<{
Params: { user: string; };
Querystring: { cursor?: string; page?: string; };
}>('/users/:user/followers', async (request, reply) => await this.followers(request, reply));
2022-09-17 13:27:08 -05:00
// following
fastify.get<{
Params: { user: string; };
Querystring: { cursor?: string; page?: string; };
}>('/users/:user/following', async (request, reply) => await this.following(request, reply));
2022-09-17 13:27:08 -05:00
// featured
fastify.get<{ Params: { user: string; }; }>('/users/:user/collections/featured', async (request, reply) => await this.featured(request, reply));
2022-09-17 13:27:08 -05:00
// publickey
fastify.get<{ Params: { user: string; } }>('/users/:user/publickey', async (request, reply) => {
const userId = request.params.user;
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
id: userId,
host: IsNull(),
});
if (user == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
const keypair = await this.userKeypairService.getUserKeypair(user.id);
2022-09-17 13:27:08 -05:00
if (this.userEntityService.isLocalUser(user)) {
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(this.apRendererService.renderKey(user, keypair)));
2022-09-17 13:27:08 -05:00
} else {
reply.code(400);
2023-02-08 20:02:37 -06:00
return;
2022-09-17 13:27:08 -05:00
}
});
fastify.get<{ Params: { user: string; } }>('/users/:user', { constraints: { apOrHtml: 'ap' } }, async (request, reply) => {
const userId = request.params.user;
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
id: userId,
host: IsNull(),
isSuspended: false,
});
return await this.userInfo(request, reply, user);
2022-09-17 13:27:08 -05:00
});
fastify.get<{ Params: { user: string; } }>('/@:user', { constraints: { apOrHtml: 'ap' } }, async (request, reply) => {
2022-09-17 13:27:08 -05:00
const user = await this.usersRepository.findOneBy({
usernameLower: request.params.user.toLowerCase(),
2022-09-17 13:27:08 -05:00
host: IsNull(),
isSuspended: false,
});
return await this.userInfo(request, reply, user);
2022-09-17 13:27:08 -05:00
});
//#endregion
// emoji
fastify.get<{ Params: { emoji: string; } }>('/emojis/:emoji', async (request, reply) => {
2022-09-17 13:27:08 -05:00
const emoji = await this.emojisRepository.findOneBy({
host: IsNull(),
name: request.params.emoji,
2022-09-17 13:27:08 -05:00
});
if (emoji == null || emoji.localOnly) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(await this.apRendererService.renderEmoji(emoji)));
2022-09-17 13:27:08 -05:00
});
// like
fastify.get<{ Params: { like: string; } }>('/likes/:like', async (request, reply) => {
const reaction = await this.noteReactionsRepository.findOneBy({ id: request.params.like });
2022-09-17 13:27:08 -05:00
if (reaction == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
const note = await this.notesRepository.findOneBy({ id: reaction.noteId });
if (note == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(await this.apRendererService.renderLike(reaction, note)));
2022-09-17 13:27:08 -05:00
});
// follow
fastify.get<{ Params: { follower: string; followee: string; } }>('/follows/:follower/:followee', async (request, reply) => {
2022-09-17 13:27:08 -05:00
// This may be used before the follow is completed, so we do not
// check if the following exists.
const [follower, followee] = await Promise.all([
this.usersRepository.findOneBy({
id: request.params.follower,
2022-09-17 13:27:08 -05:00
host: IsNull(),
}),
this.usersRepository.findOneBy({
id: request.params.followee,
2022-09-17 13:27:08 -05:00
host: Not(IsNull()),
}),
]) as [MiLocalUser | MiRemoteUser | null, MiLocalUser | MiRemoteUser | null];
2022-09-17 13:27:08 -05:00
if (follower == null || followee == null) {
reply.code(404);
2022-09-17 13:27:08 -05:00
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
2023-02-12 03:47:30 -06:00
return (this.apRendererService.addContext(this.apRendererService.renderFollow(follower, followee)));
2022-09-17 13:27:08 -05:00
});
// follow
fastify.get<{ Params: { followRequestId: string ; } }>('/follows/:followRequestId', async (request, reply) => {
// This may be used before the follow is completed, so we do not
// check if the following exists and only check if the follow request exists.
const followRequest = await this.followRequestsRepository.findOneBy({
id: request.params.followRequestId,
});
if (followRequest == null) {
reply.code(404);
return;
}
const [follower, followee] = await Promise.all([
this.usersRepository.findOneBy({
id: followRequest.followerId,
host: IsNull(),
}),
this.usersRepository.findOneBy({
id: followRequest.followeeId,
host: Not(IsNull()),
}),
]) as [MiLocalUser | MiRemoteUser | null, MiLocalUser | MiRemoteUser | null];
if (follower == null || followee == null) {
reply.code(404);
return;
}
reply.header('Cache-Control', 'public, max-age=180');
this.setResponseType(request, reply);
return (this.apRendererService.addContext(this.apRendererService.renderFollow(follower, followee)));
});
done();
2022-09-17 13:27:08 -05:00
}
}