Merge branch 'develop' into merge/2025-03-24

# Conflicts:
#	packages/backend/src/core/activitypub/models/ApPersonService.ts

packages/backend/src/server/api/endpoints/i/notifications.ts

@@ -82,8 +82,8 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 			const includeTypes = ps.includeTypes && ps.includeTypes.filter(type => !(obsoleteNotificationTypes).includes(type as any)) as typeof notificationTypes[number][];
 			const excludeTypes = ps.excludeTypes && ps.excludeTypes.filter(type => !(obsoleteNotificationTypes).includes(type as any)) as typeof notificationTypes[number][];
 
-			let sinceTime = ps.sinceId ? this.idService.parse(ps.sinceId).date.getTime().toString() : null;
-			let untilTime = ps.untilId ? this.idService.parse(ps.untilId).date.getTime().toString() : null;
+			let sinceTime = ps.sinceId ? (this.idService.parse(ps.sinceId).date.getTime() + 1).toString() : null;
+			let untilTime = ps.untilId ? (this.idService.parse(ps.untilId).date.getTime() - 1).toString() : null;
 
 			let notifications: MiNotification[];
 			for (;;) {

packages/backend/src/server/api/mastodon/MastodonClientService.ts

@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: hazelnoot and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { Misskey } from 'megalodon';
+import { Injectable } from '@nestjs/common';
+import { MiLocalUser } from '@/models/User.js';
+import { AuthenticateService } from '@/server/api/AuthenticateService.js';
+import type { FastifyRequest } from 'fastify';
+
+@Injectable()
+export class MastodonClientService {
+	constructor(
+		private readonly authenticateService: AuthenticateService,
+	) {}
+
+	/**
+	 * Gets the authenticated user and API client for a request.
+	 */
+	public async getAuthClient(request: FastifyRequest, accessToken?: string | null): Promise<{ client: Misskey, me: MiLocalUser | null }> {
+		const authorization = request.headers.authorization;
+		accessToken = accessToken !== undefined ? accessToken : getAccessToken(authorization);
+
+		const me = await this.getAuth(request, accessToken);
+		const client = this.getClient(request, accessToken);
+
+		return { client, me };
+	}
+
+	/**
+	 * Gets the authenticated client user for a request.
+	 */
+	public async getAuth(request: FastifyRequest, accessToken?: string | null): Promise<MiLocalUser | null> {
+		const authorization = request.headers.authorization;
+		accessToken = accessToken !== undefined ? accessToken : getAccessToken(authorization);
+		const [me] = await this.authenticateService.authenticate(accessToken);
+		return me;
+	}
+
+	/**
+	 * Creates an authenticated API client for a request.
+	 */
+	public getClient(request: FastifyRequest, accessToken?: string | null): Misskey {
+		const authorization = request.headers.authorization;
+		accessToken = accessToken !== undefined ? accessToken : getAccessToken(authorization);
+
+		// TODO pass agent?
+		const baseUrl = this.getBaseUrl(request);
+		const userAgent = request.headers['user-agent'];
+		return new Misskey(baseUrl, accessToken, userAgent);
+	}
+
+	readonly getBaseUrl = getBaseUrl;
+}
+
+/**
+ * Gets the base URL (origin) of the incoming request
+ */
+export function getBaseUrl(request: FastifyRequest): string {
+	return `${request.protocol}://${request.host}`;
+}
+
+/**
+ * Extracts the first access token from an authorization header
+ * Returns null if none were found.
+ */
+function getAccessToken(authorization: string | undefined): string | null {
+	const accessTokenArr = authorization?.split(' ') ?? [null];
+	return accessTokenArr[accessTokenArr.length - 1];
+}

packages/backend/src/server/api/mastodon/MastodonConverters.ts

@@ -6,6 +6,8 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { Entity } from 'megalodon';
 import mfm from '@transfem-org/sfm-js';
+import { MastodonNotificationType } from 'megalodon/lib/src/mastodon/notification.js';
+import { NotificationType } from 'megalodon/lib/src/notification.js';
 import { DI } from '@/di-symbols.js';
 import { MfmService } from '@/core/MfmService.js';
 import type { Config } from '@/config.js';
@@ -19,6 +21,8 @@ import { IdService } from '@/core/IdService.js';
 import type { Packed } from '@/misc/json-schema.js';
 import { MastodonDataService } from '@/server/api/mastodon/MastodonDataService.js';
 import { GetterService } from '@/server/api/GetterService.js';
+import { appendContentWarning } from '@/misc/append-content-warning.js';
+import { isRenote } from '@/misc/is-renote.js';
 
 // Missing from Megalodon apparently
 // https://docs.joinmastodon.org/entities/StatusEdit/
@@ -47,7 +51,7 @@ export const escapeMFM = (text: string): string => text
 	.replace(/\r?\n/g, '<br>');
 
 @Injectable()
-export class MastoConverters {
+export class MastodonConverters {
 	constructor(
 		@Inject(DI.config)
 		private readonly config: Config,
@@ -68,7 +72,6 @@ export class MastoConverters {
 
 	private encode(u: MiUser, m: IMentionedRemoteUsers): MastodonEntity.Mention {
 		let acct = u.username;
-		// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 		let acctUrl = `https://${u.host || this.config.host}/@${u.username}`;
 		let url: string | null = null;
 		if (u.host) {
@@ -136,10 +139,10 @@ export class MastoConverters {
 		});
 	}
 
-	private async encodeField(f: Entity.Field): Promise<MastodonEntity.Field> {
+	private encodeField(f: Entity.Field): MastodonEntity.Field {
 		return {
 			name: f.name,
-			value: await this.mfmService.toMastoApiHtml(mfm.parse(f.value), [], true) ?? escapeMFM(f.value),
+			value: this.mfmService.toMastoApiHtml(mfm.parse(f.value), [], true) ?? escapeMFM(f.value),
 			verified_at: null,
 		};
 	}
@@ -161,13 +164,15 @@ export class MastoConverters {
 		});
 		const fqn = `${user.username}@${user.host ?? this.config.hostname}`;
 		let acct = user.username;
-		// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 		let acctUrl = `https://${user.host || this.config.host}/@${user.username}`;
 		const acctUri = `https://${this.config.host}/users/${user.id}`;
 		if (user.host) {
 			acct = `${user.username}@${user.host}`;
 			acctUrl = `https://${user.host}/@${user.username}`;
 		}
+
+		const bioText = profile?.description && this.mfmService.toMastoApiHtml(mfm.parse(profile.description));
+
 		return awaitAll({
 			id: account.id,
 			username: user.username,
@@ -179,16 +184,16 @@ export class MastoConverters {
 			followers_count: profile?.followersVisibility === 'public' ? user.followersCount : 0,
 			following_count: profile?.followingVisibility === 'public' ? user.followingCount : 0,
 			statuses_count: user.notesCount,
-			note: profile?.description ?? '',
+			note: bioText ?? '',
 			url: user.uri ?? acctUrl,
 			uri: user.uri ?? acctUri,
-			avatar: user.avatarUrl ? user.avatarUrl : 'https://dev.joinsharkey.org/static-assets/avatar.png',
-			avatar_static: user.avatarUrl ? user.avatarUrl : 'https://dev.joinsharkey.org/static-assets/avatar.png',
-			header: user.bannerUrl ? user.bannerUrl : 'https://dev.joinsharkey.org/static-assets/transparent.png',
-			header_static: user.bannerUrl ? user.bannerUrl : 'https://dev.joinsharkey.org/static-assets/transparent.png',
+			avatar: user.avatarUrl ?? 'https://dev.joinsharkey.org/static-assets/avatar.png',
+			avatar_static: user.avatarUrl ?? 'https://dev.joinsharkey.org/static-assets/avatar.png',
+			header: user.bannerUrl ?? 'https://dev.joinsharkey.org/static-assets/transparent.png',
+			header_static: user.bannerUrl ?? 'https://dev.joinsharkey.org/static-assets/transparent.png',
 			emojis: emoji,
 			moved: null, //FIXME
-			fields: Promise.all(profile?.fields.map(async p => this.encodeField(p)) ?? []),
+			fields: profile?.fields.map(p => this.encodeField(p)) ?? [],
 			bot: user.isBot,
 			discoverable: user.isExplorable,
 			noindex: user.noindex,
@@ -198,41 +203,56 @@ export class MastoConverters {
 		});
 	}
 
-	public async getEdits(id: string, me?: MiLocalUser | null) {
+	public async getEdits(id: string, me: MiLocalUser | null): Promise<StatusEdit[]> {
 		const note = await this.mastodonDataService.getNote(id, me);
 		if (!note) {
 			return [];
 		}
-		const noteUser = await this.getUser(note.userId).then(async (p) => await this.convertAccount(p));
+
+		const noteUser = await this.getUser(note.userId);
+		const account = await this.convertAccount(noteUser);
 		const edits = await this.noteEditRepository.find({ where: { noteId: note.id }, order: { id: 'ASC' } });
-		const history: Promise<StatusEdit>[] = [];
+		const history: StatusEdit[] = [];
+
+		const mentionedRemoteUsers = JSON.parse(note.mentionedRemoteUsers);
+		const renote = isRenote(note) ? await this.mastodonDataService.requireNote(note.renoteId, me) : null;
 
 		// TODO this looks wrong, according to mastodon docs
 		let lastDate = this.idService.parse(note.id).date;
+
 		for (const edit of edits) {
-			const files = this.driveFileEntityService.packManyByIds(edit.fileIds);
+			// TODO avoid re-packing files for each edit
+			const files = await this.driveFileEntityService.packManyByIds(edit.fileIds);
+
+			const cw = appendContentWarning(edit.cw, noteUser.mandatoryCW) ?? '';
+
+			const isQuote = renote && (edit.cw || edit.newText || edit.fileIds.length > 0 || note.replyId);
+			const quoteUri = isQuote
+				? renote.url ?? renote.uri ?? `${this.config.url}/notes/${renote.id}`
+				: null;
+
 			const item = {
-				account: noteUser,
-				content: this.mfmService.toMastoApiHtml(mfm.parse(edit.newText ?? ''), JSON.parse(note.mentionedRemoteUsers)).then(p => p ?? ''),
+				account: account,
+				content: this.mfmService.toMastoApiHtml(mfm.parse(edit.newText ?? ''), mentionedRemoteUsers, false, quoteUri) ?? '',
 				created_at: lastDate.toISOString(),
-				emojis: [],
-				sensitive: edit.cw != null && edit.cw.length > 0,
-				spoiler_text: edit.cw ?? '',
-				media_attachments: files.then(files => files.length > 0 ? files.map((f) => this.encodeFile(f)) : []),
+				emojis: [], //FIXME
+				sensitive: !!cw,
+				spoiler_text: cw,
+				media_attachments: files.length > 0 ? files.map((f) => this.encodeFile(f)) : [],
 			};
 			lastDate = edit.updatedAt;
-			history.push(awaitAll(item));
+			history.push(item);
 		}
 
-		return await Promise.all(history);
+		return history;
 	}
 
-	private async convertReblog(status: Entity.Status | null, me?: MiLocalUser | null): Promise<MastodonEntity.Status | null> {
+	private async convertReblog(status: Entity.Status | null, me: MiLocalUser | null): Promise<MastodonEntity.Status | null> {
 		if (!status) return null;
 		return await this.convertStatus(status, me);
 	}
 
-	public async convertStatus(status: Entity.Status, me?: MiLocalUser | null): Promise<MastodonEntity.Status> {
+	public async convertStatus(status: Entity.Status, me: MiLocalUser | null): Promise<MastodonEntity.Status> {
 		const convertedAccount = this.convertAccount(status.account);
 		const note = await this.mastodonDataService.requireNote(status.id, me);
 		const noteUser = await this.getUser(status.account.id);
@@ -265,7 +285,6 @@ export class MastoConverters {
 		});
 
 		// This must mirror the usual isQuote / isPureRenote logic used elsewhere.
-		// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 		const isQuote = note.renoteId && (note.text || note.cw || note.fileIds.length > 0 || note.hasPoll || note.replyId);
 
 		const renote: Promise<MiNote> | null = note.renoteId ? this.mastodonDataService.requireNote(note.renoteId, me) : null;
@@ -277,11 +296,11 @@ export class MastoConverters {
 
 		const text = note.text;
 		const content = text !== null
-			? quoteUri
-				.then(quoteUri => this.mfmService.toMastoApiHtml(mfm.parse(text), mentionedRemoteUsers, false, quoteUri))
-				.then(p => p ?? escapeMFM(text))
+			? quoteUri.then(quote => this.mfmService.toMastoApiHtml(mfm.parse(text), mentionedRemoteUsers, false, quote) ?? escapeMFM(text))
 			: '';
 
+		const cw = appendContentWarning(note.cw, noteUser.mandatoryCW) ?? '';
+
 		const reblogged = await this.mastodonDataService.hasReblog(note.id, me);
 
 		// noinspection ES6MissingAwait
@@ -292,11 +311,12 @@ export class MastoConverters {
 			account: convertedAccount,
 			in_reply_to_id: note.replyId,
 			in_reply_to_account_id: note.replyUserId,
-			reblog: !isQuote ? await this.convertReblog(status.reblog, me) : null,
+			reblog: !isQuote ? this.convertReblog(status.reblog, me) : null,
 			content: content,
 			content_type: 'text/x.misskeymarkdown',
 			text: note.text,
 			created_at: status.created_at,
+			edited_at: note.updatedAt?.toISOString() ?? null,
 			emojis: emoji,
 			replies_count: note.repliesCount,
 			reblogs_count: note.renoteCount,
@@ -304,8 +324,8 @@ export class MastoConverters {
 			reblogged,
 			favourited: status.favourited,
 			muted: status.muted,
-			sensitive: status.sensitive,
-			spoiler_text: note.cw ?? '',
+			sensitive: status.sensitive || !!cw,
+			spoiler_text: cw,
 			visibility: status.visibility,
 			media_attachments: status.media_attachments.map(a => convertAttachment(a)),
 			mentions: mentions,
@@ -315,15 +335,14 @@ export class MastoConverters {
 			application: null, //FIXME
 			language: null, //FIXME
 			pinned: false, //FIXME
-			reactions: status.emoji_reactions,
-			emoji_reactions: status.emoji_reactions,
 			bookmarked: false, //FIXME
-			quote: isQuote ? await this.convertReblog(status.reblog, me) : null,
-			edited_at: note.updatedAt?.toISOString() ?? null,
+			quote_id: isQuote ? status.reblog?.id : undefined,
+			quote: isQuote ? this.convertReblog(status.reblog, me) : null,
+			reactions: status.emoji_reactions,
 		});
 	}
 
-	public async convertConversation(conversation: Entity.Conversation, me?: MiLocalUser | null): Promise<MastodonEntity.Conversation> {
+	public async convertConversation(conversation: Entity.Conversation, me: MiLocalUser | null): Promise<MastodonEntity.Conversation> {
 		return {
 			id: conversation.id,
 			accounts: await Promise.all(conversation.accounts.map(a => this.convertAccount(a))),
@@ -332,13 +351,22 @@ export class MastoConverters {
 		};
 	}
 
-	public async convertNotification(notification: Entity.Notification, me?: MiLocalUser | null): Promise<MastodonEntity.Notification> {
+	public async convertNotification(notification: Entity.Notification, me: MiLocalUser | null): Promise<MastodonEntity.Notification | null> {
+		const status = notification.status
+			? await this.convertStatus(notification.status, me).catch(() => null)
+			: null;
+
+		// We sometimes get notifications for inaccessible notes, these should be ignored.
+		if (!status) {
+			return null;
+		}
+
 		return {
 			account: await this.convertAccount(notification.account),
 			created_at: notification.created_at,
 			id: notification.id,
-			status: notification.status ? await this.convertStatus(notification.status, me) : undefined,
-			type: notification.type,
+			status,
+			type: convertNotificationType(notification.type as NotificationType),
 		};
 	}
 }
@@ -348,12 +376,26 @@ function simpleConvert<T>(data: T): T {
 	return Object.assign({}, data);
 }
 
-export function convertAccount(account: Entity.Account) {
-	return simpleConvert(account);
+function convertNotificationType(type: NotificationType): MastodonNotificationType {
+	switch (type) {
+		case 'emoji_reaction': return 'reaction';
+		case 'poll_vote':
+		case 'poll_expired':
+			return 'poll';
+		// Not supported by mastodon
+		case 'move':
+			return type as MastodonNotificationType;
+		default: return type;
+	}
 }
-export function convertAnnouncement(announcement: Entity.Announcement) {
-	return simpleConvert(announcement);
+
+export function convertAnnouncement(announcement: Entity.Announcement): MastodonEntity.Announcement {
+	return {
+		...announcement,
+		updated_at: announcement.updated_at ?? announcement.published_at,
+	};
 }
+
 export function convertAttachment(attachment: Entity.Attachment): MastodonEntity.Attachment {
 	const { width, height } = attachment.meta?.original ?? attachment.meta ?? {};
 	const size = (width && height) ? `${width}x${height}` : undefined;
@@ -379,28 +421,24 @@ export function convertAttachment(attachment: Entity.Attachment): MastodonEntity
 		} : null,
 	};
 }
-export function convertFilter(filter: Entity.Filter) {
+export function convertFilter(filter: Entity.Filter): MastodonEntity.Filter {
 	return simpleConvert(filter);
 }
-export function convertList(list: Entity.List) {
-	return simpleConvert(list);
+export function convertList(list: Entity.List): MastodonEntity.List {
+	return {
+		id: list.id,
+		title: list.title,
+		replies_policy: list.replies_policy ?? 'followed',
+	};
 }
-export function convertFeaturedTag(tag: Entity.FeaturedTag) {
+export function convertFeaturedTag(tag: Entity.FeaturedTag): MastodonEntity.FeaturedTag {
 	return simpleConvert(tag);
 }
 
-export function convertPoll(poll: Entity.Poll) {
+export function convertPoll(poll: Entity.Poll): MastodonEntity.Poll {
 	return simpleConvert(poll);
 }
 
-// noinspection JSUnusedGlobalSymbols
-export function convertReaction(reaction: Entity.Reaction) {
-	if (reaction.accounts) {
-		reaction.accounts = reaction.accounts.map(convertAccount);
-	}
-	return reaction;
-}
-
 // Megalodon sometimes returns broken / stubbed relationship data
 export function convertRelationship(relationship: Partial<Entity.Relationship> & { id: string }): MastodonEntity.Relationship {
 	return {
@@ -422,7 +460,3 @@ export function convertRelationship(relationship: Partial<Entity.Relationship> &
 	};
 }
 
-// noinspection JSUnusedGlobalSymbols
-export function convertStatusSource(status: Entity.StatusSource) {
-	return simpleConvert(status);
-}

packages/backend/src/server/api/mastodon/MastodonLogger.ts

@@ -3,37 +3,138 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { Injectable } from '@nestjs/common';
-import Logger, { Data } from '@/logger.js';
+import { Inject, Injectable } from '@nestjs/common';
+import { FastifyRequest } from 'fastify';
+import Logger from '@/logger.js';
 import { LoggerService } from '@/core/LoggerService.js';
+import { ApiError } from '@/server/api/error.js';
+import { EnvService } from '@/core/EnvService.js';
+import { getBaseUrl } from '@/server/api/mastodon/MastodonClientService.js';
 
 @Injectable()
 export class MastodonLogger {
 	public readonly logger: Logger;
 
-	constructor(loggerService: LoggerService) {
+	constructor(
+		@Inject(EnvService)
+		private readonly envService: EnvService,
+
+		loggerService: LoggerService,
+	) {
 		this.logger = loggerService.getLogger('masto-api');
 	}
 
-	public error(endpoint: string, error: Data): void {
-		this.logger.error(`Error in mastodon API endpoint ${endpoint}:`, error);
+	public error(request: FastifyRequest, error: MastodonError, status: number): void {
+		if ((status < 400 && status > 499) || this.envService.env.NODE_ENV === 'development') {
+			const path = new URL(request.url, getBaseUrl(request)).pathname;
+			this.logger.error(`Error in mastodon endpoint ${request.method} ${path}:`, error);
+		}
 	}
 }
 
-export function getErrorData(error: unknown): Data {
-	if (error == null) return {};
-	if (typeof(error) === 'string') return error;
-	if (typeof(error) === 'object') {
-		if ('response' in error) {
-			if (typeof(error.response) === 'object' && error.response) {
-				if ('data' in error.response) {
-					if (typeof(error.response.data) === 'object' && error.response.data) {
-						return error.response.data as Record<string, unknown>;
-					}
+// TODO move elsewhere
+export interface MastodonError {
+	error: string;
+	error_description?: string;
+}
+
+export function getErrorData(error: unknown): MastodonError {
+	// Axios wraps errors from the backend
+	error = unpackAxiosError(error);
+
+	if (!error || typeof(error) !== 'object') {
+		return {
+			error: 'UNKNOWN_ERROR',
+			error_description: String(error),
+		};
+	}
+
+	if (error instanceof ApiError) {
+		return convertApiError(error);
+	}
+
+	if ('code' in error && typeof (error.code) === 'string') {
+		if ('message' in error && typeof (error.message) === 'string') {
+			return convertApiError(error as ApiError);
+		}
+	}
+
+	if (error instanceof Error) {
+		return convertGenericError(error);
+	}
+
+	return convertUnknownError(error);
+}
+
+function unpackAxiosError(error: unknown): unknown {
+	if (error && typeof(error) === 'object') {
+		if ('response' in error && error.response && typeof (error.response) === 'object') {
+			if ('data' in error.response && error.response.data && typeof (error.response.data) === 'object') {
+				if ('error' in error.response.data && error.response.data.error && typeof(error.response.data.error) === 'object') {
+					return error.response.data.error;
 				}
+
+				return error.response.data;
+			}
+
+			// No data - this is a fallback to avoid leaking request/response details in the error
+			return undefined;
+		}
+	}
+
+	return error;
+}
+
+function convertApiError(apiError: ApiError): MastodonError {
+	const mastoError: MastodonError & Partial<ApiError> = {
+		error: apiError.code,
+		error_description: apiError.message,
+		...apiError,
+	};
+
+	delete mastoError.code;
+	delete mastoError.message;
+	delete mastoError.httpStatusCode;
+
+	return mastoError;
+}
+
+function convertUnknownError(data: object = {}): MastodonError {
+	return Object.assign({}, data, {
+		error: 'INTERNAL_ERROR',
+		error_description: 'Internal error occurred. Please contact us if the error persists.',
+		id: '5d37dbcb-891e-41ca-a3d6-e690c97775ac',
+		kind: 'server',
+	});
+}
+
+function convertGenericError(error: Error): MastodonError {
+	const mastoError: MastodonError & Partial<Error> = {
+		error: 'INTERNAL_ERROR',
+		error_description: String(error),
+		...error,
+	};
+
+	delete mastoError.name;
+	delete mastoError.message;
+	delete mastoError.stack;
+
+	return mastoError;
+}
+
+export function getErrorStatus(error: unknown): number {
+	if (error && typeof(error) === 'object') {
+		// Axios wraps errors from the backend
+		if ('response' in error && typeof (error.response) === 'object' && error.response) {
+			if ('status' in error.response && typeof(error.response.status) === 'number') {
+				return error.response.status;
 			}
 		}
-		return error as Record<string, unknown>;
+
+		if ('httpStatusCode' in error && typeof(error.httpStatusCode) === 'number') {
+			return error.httpStatusCode;
+		}
 	}
-	return { error };
+
+	return 500;
 }

packages/backend/src/server/api/mastodon/endpoints.ts

@@ -1,22 +0,0 @@
-/*
- * SPDX-FileCopyrightText: marie and other Sharkey contributors
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-import { ApiAuthMastodon } from './endpoints/auth.js';
-import { ApiAccountMastodon } from './endpoints/account.js';
-import { ApiSearchMastodon } from './endpoints/search.js';
-import { ApiNotifyMastodon } from './endpoints/notifications.js';
-import { ApiFilterMastodon } from './endpoints/filter.js';
-import { ApiTimelineMastodon } from './endpoints/timeline.js';
-import { ApiStatusMastodon } from './endpoints/status.js';
-
-export {
-	ApiAccountMastodon,
-	ApiAuthMastodon,
-	ApiSearchMastodon,
-	ApiNotifyMastodon,
-	ApiFilterMastodon,
-	ApiTimelineMastodon,
-	ApiStatusMastodon,
-};

packages/backend/src/server/api/mastodon/endpoints/account.ts

@@ -3,14 +3,18 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { Injectable } from '@nestjs/common';
-import { parseTimelineArgs, TimelineArgs } from '@/server/api/mastodon/timelineArgs.js';
-import { MiLocalUser } from '@/models/User.js';
-import { MastoConverters, convertRelationship } from '../converters.js';
-import type { MegalodonInterface } from 'megalodon';
-import type { FastifyRequest } from 'fastify';
+import { Inject, Injectable } from '@nestjs/common';
+import { parseTimelineArgs, TimelineArgs, toBoolean } from '@/server/api/mastodon/argsUtils.js';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import { DriveService } from '@/core/DriveService.js';
+import { DI } from '@/di-symbols.js';
+import type { AccessTokensRepository, UserProfilesRepository } from '@/models/_.js';
+import { attachMinMaxPagination } from '@/server/api/mastodon/pagination.js';
+import { MastodonConverters, convertRelationship, convertFeaturedTag, convertList } from '../MastodonConverters.js';
+import type multer from 'fastify-multer';
+import type { FastifyInstance } from 'fastify';
 
-export interface ApiAccountMastodonRoute {
+interface ApiAccountMastodonRoute {
 	Params: { id?: string },
 	Querystring: TimelineArgs & { acct?: string },
 	Body: { notifications?: boolean }
@@ -19,133 +23,280 @@ export interface ApiAccountMastodonRoute {
 @Injectable()
 export class ApiAccountMastodon {
 	constructor(
-		private readonly request: FastifyRequest<ApiAccountMastodonRoute>,
-		private readonly client: MegalodonInterface,
-		private readonly me: MiLocalUser | null,
-		private readonly mastoConverters: MastoConverters,
+		@Inject(DI.userProfilesRepository)
+		private readonly userProfilesRepository: UserProfilesRepository,
+
+		@Inject(DI.accessTokensRepository)
+		private readonly accessTokensRepository: AccessTokensRepository,
+
+		private readonly clientService: MastodonClientService,
+		private readonly mastoConverters: MastodonConverters,
+		private readonly driveService: DriveService,
 	) {}
 
-	public async verifyCredentials() {
-		const data = await this.client.verifyAccountCredentials();
-		const acct = await this.mastoConverters.convertAccount(data.data);
-		return Object.assign({}, acct, {
-			source: {
-				note: acct.note,
-				fields: acct.fields,
-				privacy: '',
-				sensitive: false,
-				language: '',
+	public register(fastify: FastifyInstance, upload: ReturnType<typeof multer>): void {
+		fastify.get<ApiAccountMastodonRoute>('/v1/accounts/verify_credentials', async (_request, reply) => {
+			const client = this.clientService.getClient(_request);
+			const data = await client.verifyAccountCredentials();
+			const acct = await this.mastoConverters.convertAccount(data.data);
+			const response = Object.assign({}, acct, {
+				source: {
+					note: acct.note,
+					fields: acct.fields,
+					privacy: 'public',
+					sensitive: false,
+					language: '',
+				},
+			});
+			reply.send(response);
+		});
+
+		fastify.patch<{
+			Body: {
+				discoverable?: string,
+				bot?: string,
+				display_name?: string,
+				note?: string,
+				avatar?: string,
+				header?: string,
+				locked?: string,
+				source?: {
+					privacy?: string,
+					sensitive?: string,
+					language?: string,
+				},
+				fields_attributes?: {
+					name: string,
+					value: string,
+				}[],
 			},
+		}>('/v1/accounts/update_credentials', { preHandler: upload.any() }, async (_request, reply) => {
+			const accessTokens = _request.headers.authorization;
+			const client = this.clientService.getClient(_request);
+			// Check if there is a Header or Avatar being uploaded, if there is proceed to upload it to the drive of the user and then set it.
+			if (_request.files.length > 0 && accessTokens) {
+				const tokeninfo = await this.accessTokensRepository.findOneBy({ token: accessTokens.replace('Bearer ', '') });
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				const avatar = (_request.files as any).find((obj: any) => {
+					return obj.fieldname === 'avatar';
+				});
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				const header = (_request.files as any).find((obj: any) => {
+					return obj.fieldname === 'header';
+				});
+
+				if (tokeninfo && avatar) {
+					const upload = await this.driveService.addFile({
+						user: { id: tokeninfo.userId, host: null },
+						path: avatar.path,
+						name: avatar.originalname !== null && avatar.originalname !== 'file' ? avatar.originalname : undefined,
+						sensitive: false,
+					});
+					if (upload.type.startsWith('image/')) {
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						(_request.body as any).avatar = upload.id;
+					}
+				} else if (tokeninfo && header) {
+					const upload = await this.driveService.addFile({
+						user: { id: tokeninfo.userId, host: null },
+						path: header.path,
+						name: header.originalname !== null && header.originalname !== 'file' ? header.originalname : undefined,
+						sensitive: false,
+					});
+					if (upload.type.startsWith('image/')) {
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						(_request.body as any).header = upload.id;
+					}
+				}
+			}
+
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			if ((_request.body as any).fields_attributes) {
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				const fields = (_request.body as any).fields_attributes.map((field: any) => {
+					if (!(field.name.trim() === '' && field.value.trim() === '')) {
+						if (field.name.trim() === '') return reply.code(400).send('Field name can not be empty');
+						if (field.value.trim() === '') return reply.code(400).send('Field value can not be empty');
+					}
+					return {
+						...field,
+					};
+				});
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				(_request.body as any).fields_attributes = fields.filter((field: any) => field.name.trim().length > 0 && field.value.length > 0);
+			}
+
+			const options = {
+				..._request.body,
+				discoverable: toBoolean(_request.body.discoverable),
+				bot: toBoolean(_request.body.bot),
+				locked: toBoolean(_request.body.locked),
+				source: _request.body.source ? {
+					..._request.body.source,
+					sensitive: toBoolean(_request.body.source.sensitive),
+				} : undefined,
+			};
+			const data = await client.updateCredentials(options);
+			const response = await this.mastoConverters.convertAccount(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.get<{ Querystring: { acct?: string }}>('/v1/accounts/lookup', async (_request, reply) => {
+			if (!_request.query.acct) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "acct"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.search(_request.query.acct, { type: 'accounts' });
+			const profile = await this.userProfilesRepository.findOneBy({ userId: data.data.accounts[0].id });
+			data.data.accounts[0].fields = profile?.fields.map(f => ({ ...f, verified_at: null })) ?? [];
+			const response = await this.mastoConverters.convertAccount(data.data.accounts[0]);
+
+			reply.send(response);
+		});
+
+		fastify.get<ApiAccountMastodonRoute & { Querystring: { id?: string | string[] }}>('/v1/accounts/relationships', async (_request, reply) => {
+			if (!_request.query.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getRelationships(_request.query.id);
+			const response = data.data.map(relationship => convertRelationship(relationship));
+
+			reply.send(response);
+		});
+
+		fastify.get<{ Params: { id?: string } }>('/v1/accounts/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getAccount(_request.params.id);
+			const account = await this.mastoConverters.convertAccount(data.data);
+
+			reply.send(account);
+		});
+
+		fastify.get<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/statuses', async (request, reply) => {
+			if (!request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const args = parseTimelineArgs(request.query);
+			const data = await client.getAccountStatuses(request.params.id, args);
+			const response = await Promise.all(data.data.map(async (status) => await this.mastoConverters.convertStatus(status, me)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
+		});
+
+		fastify.get<{ Params: { id?: string } }>('/v1/accounts/:id/featured_tags', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getFeaturedTags();
+			const response = data.data.map((tag) => convertFeaturedTag(tag));
+
+			reply.send(response);
+		});
+
+		fastify.get<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/followers', async (request, reply) => {
+			if (!request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(request);
+			const data = await client.getAccountFollowers(
+				request.params.id,
+				parseTimelineArgs(request.query),
+			);
+			const response = await Promise.all(data.data.map(async (account) => await this.mastoConverters.convertAccount(account)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
+		});
+
+		fastify.get<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/following', async (request, reply) => {
+			if (!request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(request);
+			const data = await client.getAccountFollowing(
+				request.params.id,
+				parseTimelineArgs(request.query),
+			);
+			const response = await Promise.all(data.data.map(async (account) => await this.mastoConverters.convertAccount(account)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
+		});
+
+		fastify.get<{ Params: { id?: string } }>('/v1/accounts/:id/lists', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getAccountLists(_request.params.id);
+			const response = data.data.map((list) => convertList(list));
+
+			reply.send(response);
+		});
+
+		fastify.post<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/follow', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.followAccount(_request.params.id);
+			const acct = convertRelationship(data.data);
+			acct.following = true; // TODO this is wrong, follow may not have processed immediately
+
+			reply.send(acct);
+		});
+
+		fastify.post<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/unfollow', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.unfollowAccount(_request.params.id);
+			const acct = convertRelationship(data.data);
+			acct.following = false;
+
+			reply.send(acct);
+		});
+
+		fastify.post<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/block', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.blockAccount(_request.params.id);
+			const response = convertRelationship(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.post<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/unblock', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.unblockAccount(_request.params.id);
+			const response = convertRelationship(data.data);
+
+			return reply.send(response);
+		});
+
+		fastify.post<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/mute', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.muteAccount(
+				_request.params.id,
+				_request.body.notifications ?? true,
+			);
+			const response = convertRelationship(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.post<ApiAccountMastodonRoute & { Params: { id?: string } }>('/v1/accounts/:id/unmute', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.unmuteAccount(_request.params.id);
+			const response = convertRelationship(data.data);
+
+			reply.send(response);
 		});
 	}
-
-	public async lookup() {
-		if (!this.request.query.acct) throw new Error('Missing required property "acct"');
-		const data = await this.client.search(this.request.query.acct, { type: 'accounts' });
-		return this.mastoConverters.convertAccount(data.data.accounts[0]);
-	}
-
-	public async getRelationships(reqIds: string[]) {
-		const data = await this.client.getRelationships(reqIds);
-		return data.data.map(relationship => convertRelationship(relationship));
-	}
-
-	public async getStatuses() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.getAccountStatuses(this.request.params.id, parseTimelineArgs(this.request.query));
-		return await Promise.all(data.data.map(async (status) => await this.mastoConverters.convertStatus(status, this.me)));
-	}
-
-	public async getFollowers() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.getAccountFollowers(
-			this.request.params.id,
-			parseTimelineArgs(this.request.query),
-		);
-		return await Promise.all(data.data.map(async (account) => await this.mastoConverters.convertAccount(account)));
-	}
-
-	public async getFollowing() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.getAccountFollowing(
-			this.request.params.id,
-			parseTimelineArgs(this.request.query),
-		);
-		return await Promise.all(data.data.map(async (account) => await this.mastoConverters.convertAccount(account)));
-	}
-
-	public async addFollow() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.followAccount(this.request.params.id);
-		const acct = convertRelationship(data.data);
-		acct.following = true;
-		return acct;
-	}
-
-	public async rmFollow() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.unfollowAccount(this.request.params.id);
-		const acct = convertRelationship(data.data);
-		acct.following = false;
-		return acct;
-	}
-
-	public async addBlock() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.blockAccount(this.request.params.id);
-		return convertRelationship(data.data);
-	}
-
-	public async rmBlock() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.unblockAccount(this.request.params.id);
-		return convertRelationship(data.data);
-	}
-
-	public async addMute() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.muteAccount(
-			this.request.params.id,
-			this.request.body.notifications ?? true,
-		);
-		return convertRelationship(data.data);
-	}
-
-	public async rmMute() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.unmuteAccount(this.request.params.id);
-		return convertRelationship(data.data);
-	}
-
-	public async getBookmarks() {
-		const data = await this.client.getBookmarks(parseTimelineArgs(this.request.query));
-		return Promise.all(data.data.map((status) => this.mastoConverters.convertStatus(status, this.me)));
-	}
-
-	public async getFavourites() {
-		const data = await this.client.getFavourites(parseTimelineArgs(this.request.query));
-		return Promise.all(data.data.map((status) => this.mastoConverters.convertStatus(status, this.me)));
-	}
-
-	public async getMutes() {
-		const data = await this.client.getMutes(parseTimelineArgs(this.request.query));
-		return Promise.all(data.data.map((account) => this.mastoConverters.convertAccount(account)));
-	}
-
-	public async getBlocks() {
-		const data = await this.client.getBlocks(parseTimelineArgs(this.request.query));
-		return Promise.all(data.data.map((account) => this.mastoConverters.convertAccount(account)));
-	}
-
-	public async acceptFollow() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.acceptFollowRequest(this.request.params.id);
-		return convertRelationship(data.data);
-	}
-
-	public async rejectFollow() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.rejectFollowRequest(this.request.params.id);
-		return convertRelationship(data.data);
-	}
 }

packages/backend/src/server/api/mastodon/endpoints/apps.ts

@@ -0,0 +1,113 @@
+/*
+ * SPDX-FileCopyrightText: marie and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { Injectable } from '@nestjs/common';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import type { FastifyInstance } from 'fastify';
+import type multer from 'fastify-multer';
+
+const readScope = [
+	'read:account',
+	'read:drive',
+	'read:blocks',
+	'read:favorites',
+	'read:following',
+	'read:messaging',
+	'read:mutes',
+	'read:notifications',
+	'read:reactions',
+	'read:pages',
+	'read:page-likes',
+	'read:user-groups',
+	'read:channels',
+	'read:gallery',
+	'read:gallery-likes',
+];
+
+const writeScope = [
+	'write:account',
+	'write:drive',
+	'write:blocks',
+	'write:favorites',
+	'write:following',
+	'write:messaging',
+	'write:mutes',
+	'write:notes',
+	'write:notifications',
+	'write:reactions',
+	'write:votes',
+	'write:pages',
+	'write:page-likes',
+	'write:user-groups',
+	'write:channels',
+	'write:gallery',
+	'write:gallery-likes',
+];
+
+export interface AuthPayload {
+	scopes?: string | string[],
+	redirect_uris?: string,
+	client_name?: string,
+	website?: string,
+}
+
+// Not entirely right, but it gets TypeScript to work so *shrug*
+type AuthMastodonRoute = { Body?: AuthPayload, Querystring: AuthPayload };
+
+@Injectable()
+export class ApiAppsMastodon {
+	constructor(
+		private readonly clientService: MastodonClientService,
+	) {}
+
+	public register(fastify: FastifyInstance, upload: ReturnType<typeof multer>): void {
+		fastify.post<AuthMastodonRoute>('/v1/apps', { preHandler: upload.single('none') }, async (_request, reply) => {
+			const body = _request.body ?? _request.query;
+			if (!body.scopes) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "scopes"' });
+			if (!body.redirect_uris) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "redirect_uris"' });
+			if (!body.client_name) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "client_name"' });
+
+			let scope = body.scopes;
+			if (typeof scope === 'string') {
+				scope = scope.split(/[ +]/g);
+			}
+
+			const pushScope = new Set<string>();
+			for (const s of scope) {
+				if (s.match(/^read/)) {
+					for (const r of readScope) {
+						pushScope.add(r);
+					}
+				}
+				if (s.match(/^write/)) {
+					for (const r of writeScope) {
+						pushScope.add(r);
+					}
+				}
+			}
+
+			const red = body.redirect_uris;
+
+			const client = this.clientService.getClient(_request);
+			const appData = await client.registerApp(body.client_name, {
+				scopes: Array.from(pushScope),
+				redirect_uris: red,
+				website: body.website,
+			});
+
+			const response = {
+				id: Math.floor(Math.random() * 100).toString(),
+				name: appData.name,
+				website: body.website,
+				redirect_uri: red,
+				client_id: Buffer.from(appData.url || '').toString('base64'),
+				client_secret: appData.clientSecret,
+			};
+
+			reply.send(response);
+		});
+	}
+}
+

packages/backend/src/server/api/mastodon/endpoints/auth.ts

@@ -1,97 +0,0 @@
-/*
- * SPDX-FileCopyrightText: marie and other Sharkey contributors
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-import type { MegalodonInterface } from 'megalodon';
-import type { FastifyRequest } from 'fastify';
-
-const readScope = [
-	'read:account',
-	'read:drive',
-	'read:blocks',
-	'read:favorites',
-	'read:following',
-	'read:messaging',
-	'read:mutes',
-	'read:notifications',
-	'read:reactions',
-	'read:pages',
-	'read:page-likes',
-	'read:user-groups',
-	'read:channels',
-	'read:gallery',
-	'read:gallery-likes',
-];
-
-const writeScope = [
-	'write:account',
-	'write:drive',
-	'write:blocks',
-	'write:favorites',
-	'write:following',
-	'write:messaging',
-	'write:mutes',
-	'write:notes',
-	'write:notifications',
-	'write:reactions',
-	'write:votes',
-	'write:pages',
-	'write:page-likes',
-	'write:user-groups',
-	'write:channels',
-	'write:gallery',
-	'write:gallery-likes',
-];
-
-export interface AuthPayload {
-	scopes?: string | string[],
-	redirect_uris?: string,
-	client_name?: string,
-	website?: string,
-}
-
-// Not entirely right, but it gets TypeScript to work so *shrug*
-export type AuthMastodonRoute = { Body?: AuthPayload, Querystring: AuthPayload };
-
-export async function ApiAuthMastodon(request: FastifyRequest<AuthMastodonRoute>, client: MegalodonInterface) {
-	const body = request.body ?? request.query;
-	if (!body.scopes) throw new Error('Missing required payload "scopes"');
-	if (!body.redirect_uris) throw new Error('Missing required payload "redirect_uris"');
-	if (!body.client_name) throw new Error('Missing required payload "client_name"');
-
-	let scope = body.scopes;
-	if (typeof scope === 'string') {
-		scope = scope.split(/[ +]/g);
-	}
-
-	const pushScope = new Set<string>();
-	for (const s of scope) {
-		if (s.match(/^read/)) {
-			for (const r of readScope) {
-				pushScope.add(r);
-			}
-		}
-		if (s.match(/^write/)) {
-			for (const r of writeScope) {
-				pushScope.add(r);
-			}
-		}
-	}
-
-	const red = body.redirect_uris;
-	const appData = await client.registerApp(body.client_name, {
-		scopes: Array.from(pushScope),
-		redirect_uris: red,
-		website: body.website,
-	});
-
-	return {
-		id: Math.floor(Math.random() * 100).toString(),
-		name: appData.name,
-		website: body.website,
-		redirect_uri: red,
-		client_id: Buffer.from(appData.url || '').toString('base64'), // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
-		client_secret: appData.clientSecret,
-	};
-}

packages/backend/src/server/api/mastodon/endpoints/filter.ts

@@ -3,12 +3,14 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { toBoolean } from '@/server/api/mastodon/timelineArgs.js';
-import { convertFilter } from '../converters.js';
-import type { MegalodonInterface } from 'megalodon';
-import type { FastifyRequest } from 'fastify';
+import { Injectable } from '@nestjs/common';
+import { toBoolean } from '@/server/api/mastodon/argsUtils.js';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import { convertFilter } from '../MastodonConverters.js';
+import type { FastifyInstance } from 'fastify';
+import type multer from 'fastify-multer';
 
-export interface ApiFilterMastodonRoute {
+interface ApiFilterMastodonRoute {
 	Params: {
 		id?: string,
 	},
@@ -21,55 +23,78 @@ export interface ApiFilterMastodonRoute {
 	}
 }
 
+@Injectable()
 export class ApiFilterMastodon {
 	constructor(
-		private readonly request: FastifyRequest<ApiFilterMastodonRoute>,
-		private readonly client: MegalodonInterface,
+		private readonly clientService: MastodonClientService,
 	) {}
 
-	public async getFilters() {
-		const data = await this.client.getFilters();
-		return data.data.map((filter) => convertFilter(filter));
-	}
+	public register(fastify: FastifyInstance, upload: ReturnType<typeof multer>): void {
+		fastify.get('/v1/filters', async (_request, reply) => {
+			const client = this.clientService.getClient(_request);
 
-	public async getFilter() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.getFilter(this.request.params.id);
-		return convertFilter(data.data);
-	}
+			const data = await client.getFilters();
+			const response = data.data.map((filter) => convertFilter(filter));
 
-	public async createFilter() {
-		if (!this.request.body.phrase) throw new Error('Missing required payload "phrase"');
-		if (!this.request.body.context) throw new Error('Missing required payload "context"');
-		const options = {
-			phrase: this.request.body.phrase,
-			context: this.request.body.context,
-			irreversible: toBoolean(this.request.body.irreversible),
-			whole_word: toBoolean(this.request.body.whole_word),
-			expires_in: this.request.body.expires_in,
-		};
-		const data = await this.client.createFilter(this.request.body.phrase, this.request.body.context, options);
-		return convertFilter(data.data);
-	}
+			reply.send(response);
+		});
 
-	public async updateFilter() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		if (!this.request.body.phrase) throw new Error('Missing required payload "phrase"');
-		if (!this.request.body.context) throw new Error('Missing required payload "context"');
-		const options = {
-			phrase: this.request.body.phrase,
-			context: this.request.body.context,
-			irreversible: toBoolean(this.request.body.irreversible),
-			whole_word: toBoolean(this.request.body.whole_word),
-			expires_in: this.request.body.expires_in,
-		};
-		const data = await this.client.updateFilter(this.request.params.id, this.request.body.phrase, this.request.body.context, options);
-		return convertFilter(data.data);
-	}
+		fastify.get<ApiFilterMastodonRoute & { Params: { id?: string } }>('/v1/filters/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
 
-	public async rmFilter() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.deleteFilter(this.request.params.id);
-		return data.data;
+			const client = this.clientService.getClient(_request);
+			const data = await client.getFilter(_request.params.id);
+			const response = convertFilter(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.post<ApiFilterMastodonRoute>('/v1/filters', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.body.phrase) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "phrase"' });
+			if (!_request.body.context) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "context"' });
+
+			const options = {
+				phrase: _request.body.phrase,
+				context: _request.body.context,
+				irreversible: toBoolean(_request.body.irreversible),
+				whole_word: toBoolean(_request.body.whole_word),
+				expires_in: _request.body.expires_in,
+			};
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.createFilter(_request.body.phrase, _request.body.context, options);
+			const response = convertFilter(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.post<ApiFilterMastodonRoute & { Params: { id?: string } }>('/v1/filters/:id', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.body.phrase) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "phrase"' });
+			if (!_request.body.context) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "context"' });
+
+			const options = {
+				phrase: _request.body.phrase,
+				context: _request.body.context,
+				irreversible: toBoolean(_request.body.irreversible),
+				whole_word: toBoolean(_request.body.whole_word),
+				expires_in: _request.body.expires_in,
+			};
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.updateFilter(_request.params.id, _request.body.phrase, _request.body.context, options);
+			const response = convertFilter(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.delete<ApiFilterMastodonRoute & { Params: { id?: string } }>('/v1/filters/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.deleteFilter(_request.params.id);
+
+			reply.send(data.data);
+		});
 	}
 }

packages/backend/src/server/api/mastodon/endpoints/instance.ts

@@ -0,0 +1,104 @@
+/*
+ * SPDX-FileCopyrightText: marie and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { IsNull } from 'typeorm';
+import { Inject, Injectable } from '@nestjs/common';
+import { FILE_TYPE_BROWSERSAFE } from '@/const.js';
+import type { Config } from '@/config.js';
+import { DI } from '@/di-symbols.js';
+import type { MiMeta, UsersRepository } from '@/models/_.js';
+import { MastodonConverters } from '@/server/api/mastodon/MastodonConverters.js';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import { RoleService } from '@/core/RoleService.js';
+import type { FastifyInstance } from 'fastify';
+import type { MastodonEntity } from 'megalodon';
+
+@Injectable()
+export class ApiInstanceMastodon {
+	constructor(
+		@Inject(DI.meta)
+		private readonly meta: MiMeta,
+
+		@Inject(DI.usersRepository)
+		private readonly usersRepository: UsersRepository,
+
+		@Inject(DI.config)
+		private readonly config: Config,
+
+		private readonly mastoConverters: MastodonConverters,
+		private readonly clientService: MastodonClientService,
+		private readonly roleService: RoleService,
+	) {}
+
+	public register(fastify: FastifyInstance): void {
+		fastify.get('/v1/instance', async (_request, reply) => {
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.getInstance();
+			const instance = data.data;
+			const admin = await this.usersRepository.findOne({
+				where: {
+					host: IsNull(),
+					isRoot: true,
+					isDeleted: false,
+					isSuspended: false,
+				},
+				order: { id: 'ASC' },
+			});
+			const contact = admin == null ? null : await this.mastoConverters.convertAccount((await client.getAccount(admin.id)).data);
+			const roles = await this.roleService.getUserPolicies(me?.id ?? null);
+
+			const response: MastodonEntity.Instance = {
+				uri: this.config.url,
+				title: this.meta.name || 'Sharkey',
+				description: this.meta.description || 'This is a vanilla Sharkey Instance. It doesn\'t seem to have a description.',
+				email: instance.email || '',
+				version: `3.0.0 (compatible; Sharkey ${this.config.version}; like Akkoma)`,
+				urls: instance.urls,
+				stats: {
+					user_count: instance.stats.user_count,
+					status_count: instance.stats.status_count,
+					domain_count: instance.stats.domain_count,
+				},
+				thumbnail: this.meta.backgroundImageUrl || '/static-assets/transparent.png',
+				languages: this.meta.langs,
+				registrations: !this.meta.disableRegistration || instance.registrations,
+				approval_required: this.meta.approvalRequiredForSignup,
+				invites_enabled: instance.registrations,
+				configuration: {
+					accounts: {
+						max_featured_tags: 20,
+						max_pinned_statuses: roles.pinLimit,
+					},
+					statuses: {
+						max_characters: this.config.maxNoteLength,
+						max_media_attachments: 16,
+						characters_reserved_per_url: instance.uri.length,
+					},
+					media_attachments: {
+						supported_mime_types: FILE_TYPE_BROWSERSAFE,
+						image_size_limit: 10485760,
+						image_matrix_limit: 16777216,
+						video_size_limit: 41943040,
+						video_frame_limit: 60,
+						video_matrix_limit: 2304000,
+					},
+					polls: {
+						max_options: 10,
+						max_characters_per_option: 150,
+						min_expiration: 50,
+						max_expiration: 2629746,
+					},
+					reactions: {
+						max_reactions: 1,
+					},
+				},
+				contact_account: contact,
+				rules: instance.rules ?? [],
+			};
+
+			reply.send(response);
+		});
+	}
+}

packages/backend/src/server/api/mastodon/endpoints/meta.ts

@@ -1,66 +0,0 @@
-/*
- * SPDX-FileCopyrightText: marie and other Sharkey contributors
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-import { Entity } from 'megalodon';
-import { FILE_TYPE_BROWSERSAFE } from '@/const.js';
-import type { Config } from '@/config.js';
-import type { MiMeta } from '@/models/Meta.js';
-
-/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
-export async function getInstance(
-	response: Entity.Instance,
-	contact: Entity.Account,
-	config: Config,
-	meta: MiMeta,
-) {
-	return {
-		uri: config.url,
-		title: meta.name || 'Sharkey',
-		short_description: meta.description || 'This is a vanilla Sharkey Instance. It doesn\'t seem to have a description.',
-		description: meta.description || 'This is a vanilla Sharkey Instance. It doesn\'t seem to have a description.',
-		email: response.email || '',
-		version: `3.0.0 (compatible; Sharkey ${config.version})`,
-		urls: response.urls,
-		stats: {
-			user_count: response.stats.user_count,
-			status_count: response.stats.status_count,
-			domain_count: response.stats.domain_count,
-		},
-		thumbnail: meta.backgroundImageUrl || '/static-assets/transparent.png',
-		languages: meta.langs,
-		registrations: !meta.disableRegistration || response.registrations,
-		approval_required: meta.approvalRequiredForSignup,
-		invites_enabled: response.registrations,
-		configuration: {
-			accounts: {
-				max_featured_tags: 20,
-			},
-			statuses: {
-				max_characters: config.maxNoteLength,
-				max_media_attachments: 16,
-				characters_reserved_per_url: response.uri.length,
-			},
-			media_attachments: {
-				supported_mime_types: FILE_TYPE_BROWSERSAFE,
-				image_size_limit: 10485760,
-				image_matrix_limit: 16777216,
-				video_size_limit: 41943040,
-				video_frame_rate_limit: 60,
-				video_matrix_limit: 2304000,
-			},
-			polls: {
-				max_options: 10,
-				max_characters_per_option: 150,
-				min_expiration: 50,
-				max_expiration: 2629746,
-			},
-			reactions: {
-				max_reactions: 1,
-			},
-		},
-		contact_account: contact,
-		rules: [],
-	};
-}

packages/backend/src/server/api/mastodon/endpoints/notifications.ts

@@ -3,56 +3,82 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { parseTimelineArgs, TimelineArgs } from '@/server/api/mastodon/timelineArgs.js';
-import { MiLocalUser } from '@/models/User.js';
-import { MastoConverters } from '@/server/api/mastodon/converters.js';
-import type { MegalodonInterface } from 'megalodon';
-import type { FastifyRequest } from 'fastify';
+import { Injectable } from '@nestjs/common';
+import { parseTimelineArgs, TimelineArgs } from '@/server/api/mastodon/argsUtils.js';
+import { MastodonConverters } from '@/server/api/mastodon/MastodonConverters.js';
+import { attachMinMaxPagination } from '@/server/api/mastodon/pagination.js';
+import { MastodonClientService } from '../MastodonClientService.js';
+import type { FastifyInstance } from 'fastify';
+import type multer from 'fastify-multer';
 
-export interface ApiNotifyMastodonRoute {
+interface ApiNotifyMastodonRoute {
 	Params: {
 		id?: string,
 	},
 	Querystring: TimelineArgs,
 }
 
-export class ApiNotifyMastodon {
+@Injectable()
+export class ApiNotificationsMastodon {
 	constructor(
-		private readonly request: FastifyRequest<ApiNotifyMastodonRoute>,
-		private readonly client: MegalodonInterface,
-		private readonly me: MiLocalUser | null,
-		private readonly mastoConverters: MastoConverters,
+		private readonly mastoConverters: MastodonConverters,
+		private readonly clientService: MastodonClientService,
 	) {}
 
-	public async getNotifications() {
-		const data = await this.client.getNotifications(parseTimelineArgs(this.request.query));
-		return Promise.all(data.data.map(async n => {
-			const converted = await this.mastoConverters.convertNotification(n, this.me);
-			if (converted.type === 'reaction') {
-				converted.type = 'favourite';
+	public register(fastify: FastifyInstance, upload: ReturnType<typeof multer>): void {
+		fastify.get<ApiNotifyMastodonRoute>('/v1/notifications', async (request, reply) => {
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const data = await client.getNotifications(parseTimelineArgs(request.query));
+			const notifications = await Promise.all(data.data.map(n => this.mastoConverters.convertNotification(n, me)));
+			const response: MastodonEntity.Notification[] = [];
+			for (const notification of notifications) {
+				// Notifications for inaccessible notes will be null and should be ignored
+				if (!notification) continue;
+
+				response.push(notification);
+				if (notification.type === 'reaction') {
+					response.push({
+						...notification,
+						type: 'favourite',
+					});
+				}
 			}
-			return converted;
-		}));
-	}
 
-	public async getNotification() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.getNotification(this.request.params.id);
-		const converted = await this.mastoConverters.convertNotification(data.data, this.me);
-		if (converted.type === 'reaction') {
-			converted.type = 'favourite';
-		}
-		return converted;
-	}
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
+		});
 
-	public async rmNotification() {
-		if (!this.request.params.id) throw new Error('Missing required parameter "id"');
-		const data = await this.client.dismissNotification(this.request.params.id);
-		return data.data;
-	}
+		fastify.get<ApiNotifyMastodonRoute & { Params: { id?: string } }>('/v1/notification/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
 
-	public async rmNotifications() {
-		const data = await this.client.dismissNotifications();
-		return data.data;
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.getNotification(_request.params.id);
+			const response = await this.mastoConverters.convertNotification(data.data, me);
+
+			// Notifications for inaccessible notes will be null and should be ignored
+			if (!response) {
+				return reply.code(404).send({
+					error: 'NOT_FOUND',
+				});
+			}
+
+			reply.send(response);
+		});
+
+		fastify.post<ApiNotifyMastodonRoute & { Params: { id?: string } }>('/v1/notification/:id/dismiss', { preHandler: upload.single('none') }, async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.dismissNotification(_request.params.id);
+
+			reply.send(data.data);
+		});
+
+		fastify.post<ApiNotifyMastodonRoute>('/v1/notifications/clear', { preHandler: upload.single('none') }, async (_request, reply) => {
+			const client = this.clientService.getClient(_request);
+			const data = await client.dismissNotifications();
+
+			reply.send(data.data);
+		});
 	}
 }

packages/backend/src/server/api/mastodon/endpoints/search.ts

@@ -3,92 +3,189 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { MiLocalUser } from '@/models/User.js';
-import { MastoConverters } from '../converters.js';
-import { parseTimelineArgs, TimelineArgs } from '../timelineArgs.js';
+import { Injectable } from '@nestjs/common';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import { attachMinMaxPagination, attachOffsetPagination } from '@/server/api/mastodon/pagination.js';
+import { MastodonConverters } from '../MastodonConverters.js';
+import { parseTimelineArgs, TimelineArgs, toBoolean, toInt } from '../argsUtils.js';
+import { ApiError } from '../../error.js';
 import Account = Entity.Account;
 import Status = Entity.Status;
-import type { MegalodonInterface } from 'megalodon';
-import type { FastifyRequest } from 'fastify';
+import type { FastifyInstance } from 'fastify';
 
-export interface ApiSearchMastodonRoute {
+interface ApiSearchMastodonRoute {
 	Querystring: TimelineArgs & {
-		type?: 'accounts' | 'hashtags' | 'statuses';
+		type?: string;
 		q?: string;
+		resolve?: string;
 	}
 }
 
+@Injectable()
 export class ApiSearchMastodon {
 	constructor(
-		private readonly request: FastifyRequest<ApiSearchMastodonRoute>,
-		private readonly client: MegalodonInterface,
-		private readonly me: MiLocalUser | null,
-		private readonly BASE_URL: string,
-		private readonly mastoConverters: MastoConverters,
+		private readonly mastoConverters: MastodonConverters,
+		private readonly clientService: MastodonClientService,
 	) {}
 
-	public async SearchV1() {
-		if (!this.request.query.q) throw new Error('Missing required property "q"');
-		const query = parseTimelineArgs(this.request.query);
-		const data = await this.client.search(this.request.query.q, { type: this.request.query.type, ...query });
-		return data.data;
-	}
+	public register(fastify: FastifyInstance): void {
+		fastify.get<ApiSearchMastodonRoute>('/v1/search', async (request, reply) => {
+			if (!request.query.q) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "q"' });
+			if (!request.query.type) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "type"' });
 
-	public async SearchV2() {
-		if (!this.request.query.q) throw new Error('Missing required property "q"');
-		const query = parseTimelineArgs(this.request.query);
-		const type = this.request.query.type;
-		const acct = !type || type === 'accounts' ? await this.client.search(this.request.query.q, { type: 'accounts', ...query }) : null;
-		const stat = !type || type === 'statuses' ? await this.client.search(this.request.query.q, { type: 'statuses', ...query }) : null;
-		const tags = !type || type === 'hashtags' ? await this.client.search(this.request.query.q, { type: 'hashtags', ...query }) : null;
-		return {
-			accounts: await Promise.all(acct?.data.accounts.map(async (account: Account) => await this.mastoConverters.convertAccount(account)) ?? []),
-			statuses: await Promise.all(stat?.data.statuses.map(async (status: Status) => await this.mastoConverters.convertStatus(status, this.me)) ?? []),
-			hashtags: tags?.data.hashtags ?? [],
-		};
-	}
+			const type = request.query.type;
+			if (type !== 'hashtags' && type !== 'statuses' && type !== 'accounts') {
+				return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Invalid type' });
+			}
 
-	public async getStatusTrends() {
-		const data = await fetch(`${this.BASE_URL}/api/notes/featured`,
-			{
-				method: 'POST',
-				headers: {
-					'Accept': 'application/json',
-					'Content-Type': 'application/json',
-				},
-				body: JSON.stringify({
-					i: this.request.headers.authorization?.replace('Bearer ', ''),
-				}),
-			})
-			.then(res => res.json() as Promise<Status[]>)
-			.then(data => data.map(status => this.mastoConverters.convertStatus(status, this.me)));
-		return Promise.all(data);
-	}
+			const { client, me } = await this.clientService.getAuthClient(request);
 
-	public async getSuggestions() {
-		const data = await fetch(`${this.BASE_URL}/api/users`,
-			{
-				method: 'POST',
-				headers: {
-					'Accept': 'application/json',
-					'Content-Type': 'application/json',
-				},
-				body: JSON.stringify({
-					i: this.request.headers.authorization?.replace('Bearer ', ''),
-					limit: parseTimelineArgs(this.request.query).limit ?? 20,
-					origin: 'local',
-					sort: '+follower',
-					state: 'alive',
-				}),
-			})
-			.then(res => res.json() as Promise<Account[]>)
-			.then(data => data.map((entry => ({
-				source: 'global',
-				account: entry,
-			}))));
-		return Promise.all(data.map(async suggestion => {
-			suggestion.account = await this.mastoConverters.convertAccount(suggestion.account);
-			return suggestion;
-		}));
+			if (toBoolean(request.query.resolve) && !me) {
+				return reply.code(401).send({ error: 'The access token is invalid', error_description: 'Authentication is required to use the "resolve" property' });
+			}
+			if (toInt(request.query.offset) && !me) {
+				return reply.code(401).send({ error: 'The access token is invalid', error_description: 'Authentication is required to use the "offset" property' });
+			}
+
+			// TODO implement resolve
+
+			const query = parseTimelineArgs(request.query);
+			const { data } = await client.search(request.query.q, { type, ...query });
+			const response = {
+				...data,
+				accounts: await Promise.all(data.accounts.map((account: Account) => this.mastoConverters.convertAccount(account))),
+				statuses: await Promise.all(data.statuses.map((status: Status) => this.mastoConverters.convertStatus(status, me))),
+			};
+
+			if (type === 'hashtags') {
+				attachOffsetPagination(request, reply, response.hashtags);
+			} else {
+				attachMinMaxPagination(request, reply, response[type]);
+			}
+
+			reply.send(response);
+		});
+
+		fastify.get<ApiSearchMastodonRoute>('/v2/search', async (request, reply) => {
+			if (!request.query.q) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "q"' });
+
+			const type = request.query.type;
+			if (type !== undefined && type !== 'hashtags' && type !== 'statuses' && type !== 'accounts') {
+				return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Invalid type' });
+			}
+
+			const { client, me } = await this.clientService.getAuthClient(request);
+
+			if (toBoolean(request.query.resolve) && !me) {
+				return reply.code(401).send({ error: 'The access token is invalid', error_description: 'Authentication is required to use the "resolve" property' });
+			}
+			if (toInt(request.query.offset) && !me) {
+				return reply.code(401).send({ error: 'The access token is invalid', error_description: 'Authentication is required to use the "offset" property' });
+			}
+
+			// TODO implement resolve
+
+			const query = parseTimelineArgs(request.query);
+			const acct = !type || type === 'accounts' ? await client.search(request.query.q, { type: 'accounts', ...query }) : null;
+			const stat = !type || type === 'statuses' ? await client.search(request.query.q, { type: 'statuses', ...query }) : null;
+			const tags = !type || type === 'hashtags' ? await client.search(request.query.q, { type: 'hashtags', ...query }) : null;
+			const response = {
+				accounts: await Promise.all(acct?.data.accounts.map((account: Account) => this.mastoConverters.convertAccount(account)) ?? []),
+				statuses: await Promise.all(stat?.data.statuses.map((status: Status) => this.mastoConverters.convertStatus(status, me)) ?? []),
+				hashtags: tags?.data.hashtags ?? [],
+			};
+
+			// Pagination hack, based on "best guess" expected behavior.
+			// Mastodon doesn't document this part at all!
+			const longestResult = [response.statuses, response.hashtags]
+				.reduce((longest: unknown[], current: unknown[]) => current.length > longest.length ? current : longest, response.accounts);
+
+			// Ignore min/max pagination because how TF would that work with multiple result sets??
+			// Offset pagination is the only possible option
+			attachOffsetPagination(request, reply, longestResult);
+
+			reply.send(response);
+		});
+
+		fastify.get<ApiSearchMastodonRoute>('/v1/trends/statuses', async (request, reply) => {
+			const baseUrl = this.clientService.getBaseUrl(request);
+			const res = await fetch(`${baseUrl}/api/notes/featured`,
+				{
+					method: 'POST',
+					headers: {
+						...request.headers as HeadersInit,
+						'Accept': 'application/json',
+						'Content-Type': 'application/json',
+					},
+					body: '{}',
+				});
+
+			await verifyResponse(res);
+
+			const data = await res.json() as Status[];
+			const me = await this.clientService.getAuth(request);
+			const response = await Promise.all(data.map(status => this.mastoConverters.convertStatus(status, me)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
+		});
+
+		fastify.get<ApiSearchMastodonRoute>('/v2/suggestions', async (request, reply) => {
+			const baseUrl = this.clientService.getBaseUrl(request);
+			const res = await fetch(`${baseUrl}/api/users`,
+				{
+					method: 'POST',
+					headers: {
+						...request.headers as HeadersInit,
+						'Accept': 'application/json',
+						'Content-Type': 'application/json',
+					},
+					body: JSON.stringify({
+						limit: parseTimelineArgs(request.query).limit ?? 20,
+						origin: 'local',
+						sort: '+follower',
+						state: 'alive',
+					}),
+				});
+
+			await verifyResponse(res);
+
+			const data = await res.json() as Account[];
+			const response = await Promise.all(data.map(async entry => {
+				return {
+					source: 'global',
+					account: await this.mastoConverters.convertAccount(entry),
+				};
+			}));
+
+			attachOffsetPagination(request, reply, response);
+			reply.send(response);
+		});
 	}
 }
+
+async function verifyResponse(res: Response): Promise<void> {
+	if (res.ok) return;
+
+	const text = await res.text();
+
+	if (res.headers.get('content-type') === 'application/json') {
+		try {
+			const json = JSON.parse(text);
+
+			if (json && typeof(json) === 'object') {
+				json.httpStatusCode = res.status;
+				return json;
+			}
+		} catch { /* ignore */ }
+	}
+
+	// Response is not a JSON object; treat as string
+	throw new ApiError({
+		code: 'INTERNAL_ERROR',
+		message: text || 'Internal error occurred. Please contact us if the error persists.',
+		id: '5d37dbcb-891e-41ca-a3d6-e690c97775ac',
+		kind: 'server',
+		httpStatusCode: res.status,
+	});
+}

packages/backend/src/server/api/mastodon/endpoints/status.ts

@@ -4,12 +4,11 @@
  */
 
 import querystring, { ParsedUrlQueryInput } from 'querystring';
+import { Injectable } from '@nestjs/common';
 import { emojiRegexAtStartToEnd } from '@/misc/emoji-regex.js';
-import { getErrorData, MastodonLogger } from '@/server/api/mastodon/MastodonLogger.js';
-import { parseTimelineArgs, TimelineArgs, toBoolean, toInt } from '@/server/api/mastodon/timelineArgs.js';
-import { AuthenticateService } from '@/server/api/AuthenticateService.js';
-import { convertAttachment, convertPoll, MastoConverters } from '../converters.js';
-import { getAccessToken, getClient, MastodonApiServerService } from '../MastodonApiServerService.js';
+import { parseTimelineArgs, TimelineArgs, toBoolean, toInt } from '@/server/api/mastodon/argsUtils.js';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import { convertAttachment, convertPoll, MastodonConverters } from '../MastodonConverters.js';
 import type { Entity } from 'megalodon';
 import type { FastifyInstance } from 'fastify';
 
@@ -18,167 +17,112 @@ function normalizeQuery(data: Record<string, unknown>) {
 	return querystring.parse(str);
 }
 
+@Injectable()
 export class ApiStatusMastodon {
 	constructor(
-		private readonly fastify: FastifyInstance,
-		private readonly mastoConverters: MastoConverters,
-		private readonly logger: MastodonLogger,
-		private readonly authenticateService: AuthenticateService,
-		private readonly mastodon: MastodonApiServerService,
+		private readonly mastoConverters: MastodonConverters,
+		private readonly clientService: MastodonClientService,
 	) {}
 
-	public getStatus() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id', async (_request, reply) => {
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.getStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}`, data);
-				reply.code(_request.is404 ? 404 : 401).send(data);
-			}
-		});
-	}
+	public register(fastify: FastifyInstance): void {
+		fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
 
-	public getStatusSource() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/source', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.getStatusSource(_request.params.id);
-				reply.send(data.data);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}/source`, data);
-				reply.code(_request.is404 ? 404 : 401).send(data);
-			}
-		});
-	}
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.getStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
 
-	public getContext() {
-		this.fastify.get<{ Params: { id?: string }, Querystring: TimelineArgs }>('/v1/statuses/:id/context', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const { data } = await client.getStatusContext(_request.params.id, parseTimelineArgs(_request.query));
-				const ancestors = await Promise.all(data.ancestors.map(async status => await this.mastoConverters.convertStatus(status, me)));
-				const descendants = await Promise.all(data.descendants.map(async status => await this.mastoConverters.convertStatus(status, me)));
-				reply.send({ ancestors, descendants });
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}/context`, data);
-				reply.code(_request.is404 ? 404 : 401).send(data);
+			// Fixup - Discord ignores CWs and renders the entire post.
+			if (response.sensitive && _request.headers['user-agent']?.match(/\bDiscordbot\//)) {
+				response.content = '(preview disabled for sensitive content)';
+				response.media_attachments = [];
 			}
-		});
-	}
 
-	public getHistory() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/history', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const [user] = await this.authenticateService.authenticate(getAccessToken(_request.headers.authorization));
-				const edits = await this.mastoConverters.getEdits(_request.params.id, user);
-				reply.send(edits);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}/history`, data);
-				reply.code(401).send(data);
-			}
+			reply.send(response);
 		});
-	}
 
-	public getReblogged() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/reblogged_by', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.getStatusRebloggedBy(_request.params.id);
-				reply.send(await Promise.all(data.data.map(async (account: Entity.Account) => await this.mastoConverters.convertAccount(account))));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}/reblogged_by`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/source', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getStatusSource(_request.params.id);
+
+			reply.send(data.data);
 		});
-	}
 
-	public getFavourites() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/favourited_by', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.getStatusFavouritedBy(_request.params.id);
-				reply.send(await Promise.all(data.data.map(async (account: Entity.Account) => await this.mastoConverters.convertAccount(account))));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}/favourited_by`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string }, Querystring: TimelineArgs }>('/v1/statuses/:id/context', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const { data } = await client.getStatusContext(_request.params.id, parseTimelineArgs(_request.query));
+			const ancestors = await Promise.all(data.ancestors.map(async status => await this.mastoConverters.convertStatus(status, me)));
+			const descendants = await Promise.all(data.descendants.map(async status => await this.mastoConverters.convertStatus(status, me)));
+			const response = { ancestors, descendants };
+
+			reply.send(response);
 		});
-	}
 
-	public getMedia() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/media/:id', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.getMedia(_request.params.id);
-				reply.send(convertAttachment(data.data));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/media/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/history', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const user = await this.clientService.getAuth(_request);
+			const edits = await this.mastoConverters.getEdits(_request.params.id, user);
+
+			reply.send(edits);
 		});
-	}
 
-	public getPoll() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/polls/:id', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.getPoll(_request.params.id);
-				reply.send(convertPoll(data.data));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/polls/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/reblogged_by', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getStatusRebloggedBy(_request.params.id);
+			const response = await Promise.all(data.data.map((account: Entity.Account) => this.mastoConverters.convertAccount(account)));
+
+			reply.send(response);
 		});
-	}
 
-	public votePoll() {
-		this.fastify.post<{ Params: { id?: string }, Body: { choices?: number[] } }>('/v1/polls/:id/votes', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				if (!_request.body.choices) return reply.code(400).send({ error: 'Missing required payload "choices"' });
-				const data = await client.votePoll(_request.params.id, _request.body.choices);
-				reply.send(convertPoll(data.data));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/polls/${_request.params.id}/votes`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string } }>('/v1/statuses/:id/favourited_by', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getStatusFavouritedBy(_request.params.id);
+			const response = await Promise.all(data.data.map((account: Entity.Account) => this.mastoConverters.convertAccount(account)));
+
+			reply.send(response);
 		});
-	}
 
-	public postStatus() {
-		this.fastify.post<{
+		fastify.get<{ Params: { id?: string } }>('/v1/media/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getMedia(_request.params.id);
+			const response = convertAttachment(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.get<{ Params: { id?: string } }>('/v1/polls/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getPoll(_request.params.id);
+			const response = convertPoll(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.post<{ Params: { id?: string }, Body: { choices?: number[] } }>('/v1/polls/:id/votes', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.body.choices) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "choices"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.votePoll(_request.params.id, _request.body.choices);
+			const response = convertPoll(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.post<{
 			Body: {
 				media_ids?: string[],
 				poll?: {
@@ -202,63 +146,58 @@ export class ApiStatusMastodon {
 			}
 		}>('/v1/statuses', async (_request, reply) => {
 			let body = _request.body;
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				if ((!body.poll && body['poll[options][]']) || (!body.media_ids && body['media_ids[]'])
-				) {
-					body = normalizeQuery(body);
-				}
-				const text = body.status ??= ' ';
-				const removed = text.replace(/@\S+/g, '').replace(/\s|/g, '');
-				const isDefaultEmoji = emojiRegexAtStartToEnd.test(removed);
-				const isCustomEmoji = /^:[a-zA-Z0-9@_]+:$/.test(removed);
-				if ((body.in_reply_to_id && isDefaultEmoji) || (body.in_reply_to_id && isCustomEmoji)) {
-					const a = await client.createEmojiReaction(
-						body.in_reply_to_id,
-						removed,
-					);
-					reply.send(a.data);
-				}
-				if (body.in_reply_to_id && removed === '/unreact') {
-					const id = body.in_reply_to_id;
-					const post = await client.getStatus(id);
-					const react = post.data.emoji_reactions.filter(e => e.me)[0].name;
-					const data = await client.deleteEmojiReaction(id, react);
-					reply.send(data.data);
-				}
-				if (!body.media_ids) body.media_ids = undefined;
-				if (body.media_ids && !body.media_ids.length) body.media_ids = undefined;
-
-				if (body.poll && !body.poll.options) {
-					return reply.code(400).send({ error: 'Missing required payload "poll.options"' });
-				}
-				if (body.poll && !body.poll.expires_in) {
-					return reply.code(400).send({ error: 'Missing required payload "poll.expires_in"' });
-				}
-
-				const options = {
-					...body,
-					sensitive: toBoolean(body.sensitive),
-					poll: body.poll ? {
-						options: body.poll.options!, // eslint-disable-line @typescript-eslint/no-non-null-assertion
-						expires_in: toInt(body.poll.expires_in)!, // eslint-disable-line @typescript-eslint/no-non-null-assertion
-						multiple: toBoolean(body.poll.multiple),
-						hide_totals: toBoolean(body.poll.hide_totals),
-					} : undefined,
-				};
-
-				const data = await client.postStatus(text, options);
-				reply.send(await this.mastoConverters.convertStatus(data.data as Entity.Status, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error('POST /v1/statuses', data);
-				reply.code(401).send(data);
+			if ((!body.poll && body['poll[options][]']) || (!body.media_ids && body['media_ids[]'])
+			) {
+				body = normalizeQuery(body);
 			}
-		});
-	}
+			const text = body.status ??= ' ';
+			const removed = text.replace(/@\S+/g, '').replace(/\s|/g, '');
+			const isDefaultEmoji = emojiRegexAtStartToEnd.test(removed);
+			const isCustomEmoji = /^:[a-zA-Z0-9@_]+:$/.test(removed);
 
-	public updateStatus() {
-		this.fastify.put<{
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			if ((body.in_reply_to_id && isDefaultEmoji) || (body.in_reply_to_id && isCustomEmoji)) {
+				const a = await client.createEmojiReaction(
+					body.in_reply_to_id,
+					removed,
+				);
+				reply.send(a.data);
+			}
+			if (body.in_reply_to_id && removed === '/unreact') {
+				const id = body.in_reply_to_id;
+				const post = await client.getStatus(id);
+				const react = post.data.emoji_reactions.filter(e => e.me)[0].name;
+				const data = await client.deleteEmojiReaction(id, react);
+				reply.send(data.data);
+			}
+			if (!body.media_ids) body.media_ids = undefined;
+			if (body.media_ids && !body.media_ids.length) body.media_ids = undefined;
+
+			if (body.poll && !body.poll.options) {
+				return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "poll.options"' });
+			}
+			if (body.poll && !body.poll.expires_in) {
+				return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "poll.expires_in"' });
+			}
+
+			const options = {
+				...body,
+				sensitive: toBoolean(body.sensitive),
+				poll: body.poll ? {
+					options: body.poll.options!, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+					expires_in: toInt(body.poll.expires_in)!, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+					multiple: toBoolean(body.poll.multiple),
+					hide_totals: toBoolean(body.poll.hide_totals),
+				} : undefined,
+			};
+
+			const data = await client.postStatus(text, options);
+			const response = await this.mastoConverters.convertStatus(data.data as Entity.Status, me);
+
+			reply.send(response);
+		});
+
+		fastify.put<{
 			Params: { id: string },
 			Body: {
 				status?: string,
@@ -273,201 +212,138 @@ export class ApiStatusMastodon {
 				},
 			}
 		}>('/v1/statuses/:id', async (_request, reply) => {
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const body = _request.body;
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const body = _request.body;
 
-				if (!body.media_ids || !body.media_ids.length) {
-					body.media_ids = undefined;
-				}
-
-				const options = {
-					...body,
-					sensitive: toBoolean(body.sensitive),
-					poll: body.poll ? {
-						options: body.poll.options,
-						expires_in: toInt(body.poll.expires_in),
-						multiple: toBoolean(body.poll.multiple),
-						hide_totals: toBoolean(body.poll.hide_totals),
-					} : undefined,
-				};
-
-				const data = await client.editStatus(_request.params.id, options);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}`, data);
-				reply.code(401).send(data);
+			if (!body.media_ids || !body.media_ids.length) {
+				body.media_ids = undefined;
 			}
+
+			const options = {
+				...body,
+				sensitive: toBoolean(body.sensitive),
+				poll: body.poll ? {
+					options: body.poll.options,
+					expires_in: toInt(body.poll.expires_in),
+					multiple: toBoolean(body.poll.multiple),
+					hide_totals: toBoolean(body.poll.hide_totals),
+				} : undefined,
+			};
+
+			const data = await client.editStatus(_request.params.id, options);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public addFavourite() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/favourite', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.createEmojiReaction(_request.params.id, '❤');
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/favorite`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/favourite', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.createEmojiReaction(_request.params.id, '❤');
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public rmFavourite() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unfavourite', async (_request, reply) => {
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.deleteEmojiReaction(_request.params.id, '❤');
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/statuses/${_request.params.id}/unfavorite`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unfavourite', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.deleteEmojiReaction(_request.params.id, '❤');
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public reblogStatus() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/reblog', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.reblogStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/reblog`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/reblog', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.reblogStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public unreblogStatus() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unreblog', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.unreblogStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/unreblog`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unreblog', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.unreblogStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public bookmarkStatus() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/bookmark', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.bookmarkStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/bookmark`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/bookmark', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.bookmarkStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public unbookmarkStatus() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unbookmark', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.unbookmarkStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/unbookmark`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unbookmark', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.unbookmarkStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/pin', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
 
-	public pinStatus() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/pin', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.pinStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/pin`, data);
-				reply.code(401).send(data);
-			}
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.pinStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public unpinStatus() {
-		this.fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unpin', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.unpinStatus(_request.params.id);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/unpin`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string } }>('/v1/statuses/:id/unpin', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.unpinStatus(_request.params.id);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public reactStatus() {
-		this.fastify.post<{ Params: { id?: string, name?: string } }>('/v1/statuses/:id/react/:name', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				if (!_request.params.name) return reply.code(400).send({ error: 'Missing required parameter "name"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.createEmojiReaction(_request.params.id, _request.params.name);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/react/${_request.params.name}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string, name?: string } }>('/v1/statuses/:id/react/:name', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.params.name) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "name"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.createEmojiReaction(_request.params.id, _request.params.name);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public unreactStatus() {
-		this.fastify.post<{ Params: { id?: string, name?: string } }>('/v1/statuses/:id/unreact/:name', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				if (!_request.params.name) return reply.code(400).send({ error: 'Missing required parameter "name"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.deleteEmojiReaction(_request.params.id, _request.params.name);
-				reply.send(await this.mastoConverters.convertStatus(data.data, me));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/statuses/${_request.params.id}/unreact/${_request.params.name}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string, name?: string } }>('/v1/statuses/:id/unreact/:name', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.params.name) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "name"' });
+
+			const { client, me } = await this.clientService.getAuthClient(_request);
+			const data = await client.deleteEmojiReaction(_request.params.id, _request.params.name);
+			const response = await this.mastoConverters.convertStatus(data.data, me);
+
+			reply.send(response);
 		});
-	}
 
-	public deleteStatus() {
-		this.fastify.delete<{ Params: { id?: string } }>('/v1/statuses/:id', async (_request, reply) => {
-			const BASE_URL = `${_request.protocol}://${_request.host}`;
-			const accessTokens = _request.headers.authorization;
-			const client = getClient(BASE_URL, accessTokens);
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const data = await client.deleteStatus(_request.params.id);
-				reply.send(data.data);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`DELETE /v1/statuses/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.delete<{ Params: { id?: string } }>('/v1/statuses/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.deleteStatus(_request.params.id);
+
+			reply.send(data.data);
 		});
 	}
 }

packages/backend/src/server/api/mastodon/endpoints/timeline.ts

@@ -3,232 +3,156 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { getErrorData, MastodonLogger } from '@/server/api/mastodon/MastodonLogger.js';
-import { convertList, MastoConverters } from '../converters.js';
-import { getClient, MastodonApiServerService } from '../MastodonApiServerService.js';
-import { parseTimelineArgs, TimelineArgs, toBoolean } from '../timelineArgs.js';
+import { Injectable } from '@nestjs/common';
+import { MastodonClientService } from '@/server/api/mastodon/MastodonClientService.js';
+import { attachMinMaxPagination } from '@/server/api/mastodon/pagination.js';
+import { convertList, MastodonConverters } from '../MastodonConverters.js';
+import { parseTimelineArgs, TimelineArgs, toBoolean } from '../argsUtils.js';
 import type { Entity } from 'megalodon';
 import type { FastifyInstance } from 'fastify';
 
+@Injectable()
 export class ApiTimelineMastodon {
 	constructor(
-		private readonly fastify: FastifyInstance,
-		private readonly mastoConverters: MastoConverters,
-		private readonly logger: MastodonLogger,
-		private readonly mastodon: MastodonApiServerService,
+		private readonly clientService: MastodonClientService,
+		private readonly mastoConverters: MastodonConverters,
 	) {}
 
-	public getTL() {
-		this.fastify.get<{ Querystring: TimelineArgs }>('/v1/timelines/public', async (_request, reply) => {
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = toBoolean(_request.query.local)
-					? await client.getLocalTimeline(parseTimelineArgs(_request.query))
-					: await client.getPublicTimeline(parseTimelineArgs(_request.query));
-				reply.send(await Promise.all(data.data.map(async (status: Entity.Status) => await this.mastoConverters.convertStatus(status, me))));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error('GET /v1/timelines/public', data);
-				reply.code(401).send(data);
-			}
-		});
-	}
+	public register(fastify: FastifyInstance): void {
+		fastify.get<{ Querystring: TimelineArgs }>('/v1/timelines/public', async (request, reply) => {
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const query = parseTimelineArgs(request.query);
+			const data = toBoolean(request.query.local)
+				? await client.getLocalTimeline(query)
+				: await client.getPublicTimeline(query);
+			const response = await Promise.all(data.data.map((status: Entity.Status) => this.mastoConverters.convertStatus(status, me)));
 
-	public getHomeTl() {
-		this.fastify.get<{ Querystring: TimelineArgs }>('/v1/timelines/home', async (_request, reply) => {
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.getHomeTimeline(parseTimelineArgs(_request.query));
-				reply.send(await Promise.all(data.data.map(async (status: Entity.Status) => await this.mastoConverters.convertStatus(status, me))));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error('GET /v1/timelines/home', data);
-				reply.code(401).send(data);
-			}
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public getTagTl() {
-		this.fastify.get<{ Params: { hashtag?: string }, Querystring: TimelineArgs }>('/v1/timelines/tag/:hashtag', async (_request, reply) => {
-			try {
-				if (!_request.params.hashtag) return reply.code(400).send({ error: 'Missing required parameter "hashtag"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.getTagTimeline(_request.params.hashtag, parseTimelineArgs(_request.query));
-				reply.send(await Promise.all(data.data.map(async (status: Entity.Status) => await this.mastoConverters.convertStatus(status, me))));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/timelines/tag/${_request.params.hashtag}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Querystring: TimelineArgs }>('/v1/timelines/home', async (request, reply) => {
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const query = parseTimelineArgs(request.query);
+			const data = await client.getHomeTimeline(query);
+			const response = await Promise.all(data.data.map((status: Entity.Status) => this.mastoConverters.convertStatus(status, me)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public getListTL() {
-		this.fastify.get<{ Params: { id?: string }, Querystring: TimelineArgs }>('/v1/timelines/list/:id', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.getListTimeline(_request.params.id, parseTimelineArgs(_request.query));
-				reply.send(await Promise.all(data.data.map(async (status: Entity.Status) => await this.mastoConverters.convertStatus(status, me))));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/timelines/list/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { hashtag?: string }, Querystring: TimelineArgs }>('/v1/timelines/tag/:hashtag', async (request, reply) => {
+			if (!request.params.hashtag) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "hashtag"' });
+
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const query = parseTimelineArgs(request.query);
+			const data = await client.getTagTimeline(request.params.hashtag, query);
+			const response = await Promise.all(data.data.map((status: Entity.Status) => this.mastoConverters.convertStatus(status, me)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public getConversations() {
-		this.fastify.get<{ Querystring: TimelineArgs }>('/v1/conversations', async (_request, reply) => {
-			try {
-				const { client, me } = await this.mastodon.getAuthClient(_request);
-				const data = await client.getConversationTimeline(parseTimelineArgs(_request.query));
-				const conversations = await Promise.all(data.data.map(async (conversation: Entity.Conversation) => await this.mastoConverters.convertConversation(conversation, me)));
-				reply.send(conversations);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error('GET /v1/conversations', data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string }, Querystring: TimelineArgs }>('/v1/timelines/list/:id', async (request, reply) => {
+			if (!request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const query = parseTimelineArgs(request.query);
+			const data = await client.getListTimeline(request.params.id, query);
+			const response = await Promise.all(data.data.map(async (status: Entity.Status) => await this.mastoConverters.convertStatus(status, me)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public getList() {
-		this.fastify.get<{ Params: { id?: string } }>('/v1/lists/:id', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.getList(_request.params.id);
-				reply.send(convertList(data.data));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/lists/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Querystring: TimelineArgs }>('/v1/conversations', async (request, reply) => {
+			const { client, me } = await this.clientService.getAuthClient(request);
+			const query = parseTimelineArgs(request.query);
+			const data = await client.getConversationTimeline(query);
+			const response = await Promise.all(data.data.map((conversation: Entity.Conversation) => this.mastoConverters.convertConversation(conversation, me)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public getLists() {
-		this.fastify.get('/v1/lists', async (_request, reply) => {
-			try {
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.getLists();
-				reply.send(data.data.map((list: Entity.List) => convertList(list)));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error('GET /v1/lists', data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string } }>('/v1/lists/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.getList(_request.params.id);
+			const response = convertList(data.data);
+
+			reply.send(response);
 		});
-	}
 
-	public getListAccounts() {
-		this.fastify.get<{ Params: { id?: string }, Querystring: { limit?: number, max_id?: string, since_id?: string } }>('/v1/lists/:id/accounts', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.getAccountsInList(_request.params.id, _request.query);
-				const accounts = await Promise.all(data.data.map((account: Entity.Account) => this.mastoConverters.convertAccount(account)));
-				reply.send(accounts);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`GET /v1/lists/${_request.params.id}/accounts`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get('/v1/lists', async (request, reply) => {
+			const client = this.clientService.getClient(request);
+			const data = await client.getLists();
+			const response = data.data.map((list: Entity.List) => convertList(list));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public addListAccount() {
-		this.fastify.post<{ Params: { id?: string }, Querystring: { accounts_id?: string[] } }>('/v1/lists/:id/accounts', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				if (!_request.query.accounts_id) return reply.code(400).send({ error: 'Missing required property "accounts_id"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.addAccountsToList(_request.params.id, _request.query.accounts_id);
-				reply.send(data.data);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`POST /v1/lists/${_request.params.id}/accounts`, data);
-				reply.code(401).send(data);
-			}
+		fastify.get<{ Params: { id?: string }, Querystring: TimelineArgs }>('/v1/lists/:id/accounts', async (request, reply) => {
+			if (!request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(request);
+			const data = await client.getAccountsInList(request.params.id, parseTimelineArgs(request.query));
+			const response = await Promise.all(data.data.map((account: Entity.Account) => this.mastoConverters.convertAccount(account)));
+
+			attachMinMaxPagination(request, reply, response);
+			reply.send(response);
 		});
-	}
 
-	public rmListAccount() {
-		this.fastify.delete<{ Params: { id?: string }, Querystring: { accounts_id?: string[] } }>('/v1/lists/:id/accounts', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				if (!_request.query.accounts_id) return reply.code(400).send({ error: 'Missing required property "accounts_id"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.deleteAccountsFromList(_request.params.id, _request.query.accounts_id);
-				reply.send(data.data);
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`DELETE /v1/lists/${_request.params.id}/accounts`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Params: { id?: string }, Querystring: { accounts_id?: string[] } }>('/v1/lists/:id/accounts', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.query.accounts_id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "accounts_id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.addAccountsToList(_request.params.id, _request.query.accounts_id);
+
+			reply.send(data.data);
 		});
-	}
 
-	public createList() {
-		this.fastify.post<{ Body: { title?: string } }>('/v1/lists', async (_request, reply) => {
-			try {
-				if (!_request.body.title) return reply.code(400).send({ error: 'Missing required payload "title"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.createList(_request.body.title);
-				reply.send(convertList(data.data));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error('POST /v1/lists', data);
-				reply.code(401).send(data);
-			}
+		fastify.delete<{ Params: { id?: string }, Querystring: { accounts_id?: string[] } }>('/v1/lists/:id/accounts', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.query.accounts_id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required property "accounts_id"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.deleteAccountsFromList(_request.params.id, _request.query.accounts_id);
+
+			reply.send(data.data);
 		});
-	}
 
-	public updateList() {
-		this.fastify.put<{ Params: { id?: string }, Body: { title?: string } }>('/v1/lists/:id', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				if (!_request.body.title) return reply.code(400).send({ error: 'Missing required payload "title"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				const data = await client.updateList(_request.params.id, _request.body.title);
-				reply.send(convertList(data.data));
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`PUT /v1/lists/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.post<{ Body: { title?: string } }>('/v1/lists', async (_request, reply) => {
+			if (!_request.body.title) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "title"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.createList(_request.body.title);
+			const response = convertList(data.data);
+
+			reply.send(response);
 		});
-	}
 
-	public deleteList() {
-		this.fastify.delete<{ Params: { id?: string } }>('/v1/lists/:id', async (_request, reply) => {
-			try {
-				if (!_request.params.id) return reply.code(400).send({ error: 'Missing required parameter "id"' });
-				const BASE_URL = `${_request.protocol}://${_request.host}`;
-				const accessTokens = _request.headers.authorization;
-				const client = getClient(BASE_URL, accessTokens);
-				await client.deleteList(_request.params.id);
-				reply.send({});
-			} catch (e) {
-				const data = getErrorData(e);
-				this.logger.error(`DELETE /v1/lists/${_request.params.id}`, data);
-				reply.code(401).send(data);
-			}
+		fastify.put<{ Params: { id?: string }, Body: { title?: string } }>('/v1/lists/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+			if (!_request.body.title) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required payload "title"' });
+
+			const client = this.clientService.getClient(_request);
+			const data = await client.updateList(_request.params.id, _request.body.title);
+			const response = convertList(data.data);
+
+			reply.send(response);
+		});
+
+		fastify.delete<{ Params: { id?: string } }>('/v1/lists/:id', async (_request, reply) => {
+			if (!_request.params.id) return reply.code(400).send({ error: 'BAD_REQUEST', error_description: 'Missing required parameter "id"' });
+
+			const client = this.clientService.getClient(_request);
+			await client.deleteList(_request.params.id);
+
+			reply.send({});
 		});
 	}
 }

packages/backend/src/server/api/mastodon/pagination.ts

@@ -0,0 +1,170 @@
+/*
+ * SPDX-FileCopyrightText: hazelnoot and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { getBaseUrl } from '@/server/api/mastodon/MastodonClientService.js';
+
+interface AnyEntity {
+	readonly id: string;
+}
+
+/**
+ * Attaches Mastodon's pagination headers to a response that is paginated by min_id / max_id parameters.
+ * Results must be sorted, but can be in ascending or descending order.
+ * Attached headers will always be in descending order.
+ *
+ * @param request Fastify request object
+ * @param reply Fastify reply object
+ * @param results Results array, ordered in ascending or descending order
+ */
+export function attachMinMaxPagination(request: FastifyRequest, reply: FastifyReply, results: AnyEntity[]): void {
+	// No results, nothing to do
+	if (!hasItems(results)) return;
+
+	// "next" link - older results
+	const oldest = findOldest(results);
+	const nextUrl = createPaginationUrl(request, { max_id: oldest }); // Next page (older) has IDs less than the oldest of this page
+	const next = `<${nextUrl}>; rel="next"`;
+
+	// "prev" link - newer results
+	const newest = findNewest(results);
+	const prevUrl = createPaginationUrl(request, { min_id: newest }); // Previous page (newer) has IDs greater than the newest of this page
+	const prev = `<${prevUrl}>; rel="prev"`;
+
+	// https://docs.joinmastodon.org/api/guidelines/#pagination
+	const link = `${next}, ${prev}`;
+	reply.header('link', link);
+}
+
+/**
+ * Attaches Mastodon's pagination headers to a response that is paginated by limit / offset parameters.
+ * Results must be sorted, but can be in ascending or descending order.
+ * Attached headers will always be in descending order.
+ *
+ * @param request Fastify request object
+ * @param reply Fastify reply object
+ * @param results Results array, ordered in ascending or descending order
+ */
+export function attachOffsetPagination(request: FastifyRequest, reply: FastifyReply, results: unknown[]): void {
+	const links: string[] = [];
+
+	// Find initial offset
+	const offset = findOffset(request);
+	const limit = findLimit(request);
+
+	// "next" link - older results
+	if (hasItems(results)) {
+		const oldest = offset + results.length;
+		const nextUrl = createPaginationUrl(request, { offset: oldest }); // Next page (older) has entries less than the oldest of this page
+		links.push(`<${nextUrl}>; rel="next"`);
+	}
+
+	// "prev" link - newer results
+	// We can only paginate backwards if a limit is specified
+	if (limit) {
+		// Make sure we don't cross below 0, as that will produce an API error
+		if (limit <= offset) {
+			const newest = offset - limit;
+			const prevUrl = createPaginationUrl(request, { offset: newest }); // Previous page (newer) has entries greater than the newest of this page
+			links.push(`<${prevUrl}>; rel="prev"`);
+		} else {
+			const prevUrl = createPaginationUrl(request, { offset: 0, limit: offset }); // Previous page (newer) has entries greater than the newest of this page
+			links.push(`<${prevUrl}>; rel="prev"`);
+		}
+	}
+
+	// https://docs.joinmastodon.org/api/guidelines/#pagination
+	if (links.length > 0) {
+		const link = links.join(', ');
+		reply.header('link', link);
+	}
+}
+
+function hasItems<T>(items: T[]): items is [T, ...T[]] {
+	return items.length > 0;
+}
+
+function findOffset(request: FastifyRequest): number {
+	if (typeof(request.query) !== 'object') return 0;
+
+	const query = request.query as Record<string, string | string[] | undefined>;
+	if (!query.offset) return 0;
+
+	if (Array.isArray(query.offset)) {
+		const offsets = query.offset
+			.map(o => parseInt(o))
+			.filter(o => !isNaN(o));
+		const offset = Math.max(...offsets);
+		return isNaN(offset) ? 0 : offset;
+	}
+
+	const offset = parseInt(query.offset);
+	return isNaN(offset) ? 0 : offset;
+}
+
+function findLimit(request: FastifyRequest): number | null {
+	if (typeof(request.query) !== 'object') return null;
+
+	const query = request.query as Record<string, string | string[] | undefined>;
+	if (!query.limit) return null;
+
+	if (Array.isArray(query.limit)) {
+		const limits = query.limit
+			.map(l => parseInt(l))
+			.filter(l => !isNaN(l));
+		const limit = Math.max(...limits);
+		return isNaN(limit) ? null : limit;
+	}
+
+	const limit = parseInt(query.limit);
+	return isNaN(limit) ? null : limit;
+}
+
+function findOldest(items: [AnyEntity, ...AnyEntity[]]): string {
+	const first = items[0].id;
+	const last = items[items.length - 1].id;
+
+	return isOlder(first, last) ? first : last;
+}
+
+function findNewest(items: [AnyEntity, ...AnyEntity[]]): string {
+	const first = items[0].id;
+	const last = items[items.length - 1].id;
+
+	return isOlder(first, last) ? last : first;
+}
+
+function isOlder(a: string, b: string): boolean {
+	if (a === b) return false;
+
+	if (a.length !== b.length) {
+		return a.length < b.length;
+	}
+
+	return a < b;
+}
+
+function createPaginationUrl(request: FastifyRequest, data: {
+	min_id?: string;
+	max_id?: string;
+	offset?: number;
+	limit?: number;
+}): string {
+	const baseUrl = getBaseUrl(request);
+	const requestUrl = new URL(request.url, baseUrl);
+
+	// Remove any existing pagination
+	requestUrl.searchParams.delete('min_id');
+	requestUrl.searchParams.delete('max_id');
+	requestUrl.searchParams.delete('since_id');
+	requestUrl.searchParams.delete('offset');
+
+	if (data.min_id) requestUrl.searchParams.set('min_id', data.min_id);
+	if (data.max_id) requestUrl.searchParams.set('max_id', data.max_id);
+	if (data.offset) requestUrl.searchParams.set('offset', String(data.offset));
+	if (data.limit) requestUrl.searchParams.set('limit', String(data.limit));
+
+	return requestUrl.href;
+}