refactoring

Resolve #7779

packages/backend/src/models/repositories/abuse-user-report.ts

@@ -0,0 +1,38 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Users } from '../index';
+import { AbuseUserReport } from '@/models/entities/abuse-user-report';
+import { awaitAll } from '@/prelude/await-all';
+
+@EntityRepository(AbuseUserReport)
+export class AbuseUserReportRepository extends Repository<AbuseUserReport> {
+	public async pack(
+		src: AbuseUserReport['id'] | AbuseUserReport,
+	) {
+		const report = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: report.id,
+			createdAt: report.createdAt,
+			comment: report.comment,
+			resolved: report.resolved,
+			reporterId: report.reporterId,
+			targetUserId: report.targetUserId,
+			assigneeId: report.assigneeId,
+			reporter: Users.pack(report.reporter || report.reporterId, null, {
+				detail: true
+			}),
+			targetUser: Users.pack(report.targetUser || report.targetUserId, null, {
+				detail: true
+			}),
+			assignee: report.assigneeId ? Users.pack(report.assignee || report.assigneeId, null, {
+				detail: true
+			}) : null,
+		});
+	}
+
+	public packMany(
+		reports: any[],
+	) {
+		return Promise.all(reports.map(x => this.pack(x)));
+	}
+}

packages/backend/src/models/repositories/antenna.ts

@@ -0,0 +1,124 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Antenna } from '@/models/entities/antenna';
+import { Packed } from '@/misc/schema';
+import { AntennaNotes, UserGroupJoinings } from '../index';
+
+@EntityRepository(Antenna)
+export class AntennaRepository extends Repository<Antenna> {
+	public async pack(
+		src: Antenna['id'] | Antenna,
+	): Promise<Packed<'Antenna'>> {
+		const antenna = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		const hasUnreadNote = (await AntennaNotes.findOne({ antennaId: antenna.id, read: false })) != null;
+		const userGroupJoining = antenna.userGroupJoiningId ? await UserGroupJoinings.findOne(antenna.userGroupJoiningId) : null;
+
+		return {
+			id: antenna.id,
+			createdAt: antenna.createdAt.toISOString(),
+			name: antenna.name,
+			keywords: antenna.keywords,
+			excludeKeywords: antenna.excludeKeywords,
+			src: antenna.src,
+			userListId: antenna.userListId,
+			userGroupId: userGroupJoining ? userGroupJoining.userGroupId : null,
+			users: antenna.users,
+			caseSensitive: antenna.caseSensitive,
+			notify: antenna.notify,
+			withReplies: antenna.withReplies,
+			withFile: antenna.withFile,
+			hasUnreadNote
+		};
+	}
+}
+
+export const packedAntennaSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id'
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time'
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const
+		},
+		keywords: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+			items: {
+				type: 'array' as const,
+				optional: false as const, nullable: false as const,
+				items: {
+					type: 'string' as const,
+					optional: false as const, nullable: false as const
+				}
+			}
+		},
+		excludeKeywords: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+			items: {
+				type: 'array' as const,
+				optional: false as const, nullable: false as const,
+				items: {
+					type: 'string' as const,
+					optional: false as const, nullable: false as const
+				}
+			}
+		},
+		src: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			enum: ['home', 'all', 'users', 'list', 'group']
+		},
+		userListId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id'
+		},
+		userGroupId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id'
+		},
+		users: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const
+			}
+		},
+		caseSensitive: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+			default: false
+		},
+		notify: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const
+		},
+		withReplies: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+			default: false
+		},
+		withFile: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const
+		},
+		hasUnreadNote: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+			default: false
+		}
+	},
+};

packages/backend/src/models/repositories/app.ts

@@ -0,0 +1,75 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { App } from '@/models/entities/app';
+import { AccessTokens } from '../index';
+import { Packed } from '@/misc/schema';
+import { User } from '../entities/user';
+
+@EntityRepository(App)
+export class AppRepository extends Repository<App> {
+	public async pack(
+		src: App['id'] | App,
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			detail?: boolean,
+			includeSecret?: boolean,
+			includeProfileImageIds?: boolean
+		}
+	): Promise<Packed<'App'>> {
+		const opts = Object.assign({
+			detail: false,
+			includeSecret: false,
+			includeProfileImageIds: false
+		}, options);
+
+		const app = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: app.id,
+			name: app.name,
+			callbackUrl: app.callbackUrl,
+			permission: app.permission,
+			...(opts.includeSecret ? { secret: app.secret } : {}),
+			...(me ? {
+				isAuthorized: await AccessTokens.count({
+					appId: app.id,
+					userId: me,
+				}).then(count => count > 0)
+			} : {})
+		};
+	}
+}
+
+export const packedAppSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const
+		},
+		callbackUrl: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		permission: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const
+			}
+		},
+		secret: {
+			type: 'string' as const,
+			optional: true as const, nullable: false as const
+		},
+		isAuthorized: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		}
+	}
+};

packages/backend/src/models/repositories/auth-session.ts

@@ -0,0 +1,21 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Apps } from '../index';
+import { AuthSession } from '@/models/entities/auth-session';
+import { awaitAll } from '@/prelude/await-all';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(AuthSession)
+export class AuthSessionRepository extends Repository<AuthSession> {
+	public async pack(
+		src: AuthSession['id'] | AuthSession,
+		me?: { id: User['id'] } | null | undefined
+	) {
+		const session = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: session.id,
+			app: Apps.pack(session.appId, me),
+			token: session.token
+		});
+	}
+}

packages/backend/src/models/repositories/blocking.ts

@@ -0,0 +1,60 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Users } from '../index';
+import { Blocking } from '@/models/entities/blocking';
+import { awaitAll } from '@/prelude/await-all';
+import { Packed } from '@/misc/schema';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(Blocking)
+export class BlockingRepository extends Repository<Blocking> {
+	public async pack(
+		src: Blocking['id'] | Blocking,
+		me?: { id: User['id'] } | null | undefined
+	): Promise<Packed<'Blocking'>> {
+		const blocking = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: blocking.id,
+			createdAt: blocking.createdAt.toISOString(),
+			blockeeId: blocking.blockeeId,
+			blockee: Users.pack(blocking.blockeeId, me, {
+				detail: true
+			})
+		});
+	}
+
+	public packMany(
+		blockings: any[],
+		me: { id: User['id'] }
+	) {
+		return Promise.all(blockings.map(x => this.pack(x, me)));
+	}
+}
+
+export const packedBlockingSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		blockeeId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		blockee: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+	}
+};

packages/backend/src/models/repositories/channel.ts

@@ -0,0 +1,95 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Channel } from '@/models/entities/channel';
+import { Packed } from '@/misc/schema';
+import { DriveFiles, ChannelFollowings, NoteUnreads } from '../index';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(Channel)
+export class ChannelRepository extends Repository<Channel> {
+	public async pack(
+		src: Channel['id'] | Channel,
+		me?: { id: User['id'] } | null | undefined,
+	): Promise<Packed<'Channel'>> {
+		const channel = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const meId = me ? me.id : null;
+
+		const banner = channel.bannerId ? await DriveFiles.findOne(channel.bannerId) : null;
+
+		const hasUnreadNote = meId ? (await NoteUnreads.findOne({ noteChannelId: channel.id, userId: meId })) != null : undefined;
+
+		const following = meId ? await ChannelFollowings.findOne({
+			followerId: meId,
+			followeeId: channel.id,
+		}) : null;
+
+		return {
+			id: channel.id,
+			createdAt: channel.createdAt.toISOString(),
+			lastNotedAt: channel.lastNotedAt ? channel.lastNotedAt.toISOString() : null,
+			name: channel.name,
+			description: channel.description,
+			userId: channel.userId,
+			bannerUrl: banner ? DriveFiles.getPublicUrl(banner, false) : null,
+			usersCount: channel.usersCount,
+			notesCount: channel.notesCount,
+
+			...(me ? {
+				isFollowing: following != null,
+				hasUnreadNote,
+			} : {})
+		};
+	}
+}
+
+export const packedChannelSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		lastNotedAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'date-time',
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		description: {
+			type: 'string' as const,
+			nullable: true as const, optional: false as const,
+		},
+		bannerUrl: {
+			type: 'string' as const,
+			format: 'url',
+			nullable: true as const, optional: false as const,
+		},
+		notesCount: {
+			type: 'number' as const,
+			nullable: false as const, optional: false as const,
+		},
+		usersCount: {
+			type: 'number' as const,
+			nullable: false as const, optional: false as const,
+		},
+		isFollowing: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const,
+		},
+		userId: {
+			type: 'string' as const,
+			nullable: true as const, optional: false as const,
+			format: 'id',
+		},
+	},
+};

packages/backend/src/models/repositories/clip.ts

@@ -0,0 +1,70 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Clip } from '@/models/entities/clip';
+import { Packed } from '@/misc/schema';
+import { Users } from '../index';
+import { awaitAll } from '@/prelude/await-all';
+
+@EntityRepository(Clip)
+export class ClipRepository extends Repository<Clip> {
+	public async pack(
+		src: Clip['id'] | Clip,
+	): Promise<Packed<'Clip'>> {
+		const clip = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: clip.id,
+			createdAt: clip.createdAt.toISOString(),
+			userId: clip.userId,
+			user: Users.pack(clip.user || clip.userId),
+			name: clip.name,
+			description: clip.description,
+			isPublic: clip.isPublic,
+		});
+	}
+
+	public packMany(
+		clips: Clip[],
+	) {
+		return Promise.all(clips.map(x => this.pack(x)));
+	}
+}
+
+export const packedClipSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		userId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		user: {
+			type: 'object' as const,
+			ref: 'User' as const,
+			optional: false as const, nullable: false as const,
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		description: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		isPublic: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+	},
+};

packages/backend/src/models/repositories/drive-file.ts

@@ -0,0 +1,249 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { DriveFile } from '@/models/entities/drive-file';
+import { Users, DriveFolders } from '../index';
+import { User } from '@/models/entities/user';
+import { toPuny } from '@/misc/convert-host';
+import { awaitAll } from '@/prelude/await-all';
+import { Packed } from '@/misc/schema';
+import config from '@/config/index';
+import { query, appendQuery } from '@/prelude/url';
+import { Meta } from '@/models/entities/meta';
+import { fetchMeta } from '@/misc/fetch-meta';
+
+type PackOptions = {
+	detail?: boolean,
+	self?: boolean,
+	withUser?: boolean,
+};
+
+@EntityRepository(DriveFile)
+export class DriveFileRepository extends Repository<DriveFile> {
+	public validateFileName(name: string): boolean {
+		return (
+			(name.trim().length > 0) &&
+			(name.length <= 200) &&
+			(name.indexOf('\\') === -1) &&
+			(name.indexOf('/') === -1) &&
+			(name.indexOf('..') === -1)
+		);
+	}
+
+	public getPublicUrl(file: DriveFile, thumbnail = false, meta?: Meta): string | null {
+		// リモートかつメディアプロキシ
+		if (file.uri != null && file.userHost != null && config.mediaProxy != null) {
+			return appendQuery(config.mediaProxy, query({
+				url: file.uri,
+				thumbnail: thumbnail ? '1' : undefined
+			}));
+		}
+
+		// リモートかつ期限切れはローカルプロキシを試みる
+		if (file.uri != null && file.isLink && meta && meta.proxyRemoteFiles) {
+			const key = thumbnail ? file.thumbnailAccessKey : file.webpublicAccessKey;
+
+			if (key && !key.match('/')) {	// 古いものはここにオブジェクトストレージキーが入ってるので除外
+				return `${config.url}/files/${key}`;
+			}
+		}
+
+		const isImage = file.type && ['image/png', 'image/apng', 'image/gif', 'image/jpeg', 'image/webp', 'image/svg+xml'].includes(file.type);
+
+		return thumbnail ? (file.thumbnailUrl || (isImage ? (file.webpublicUrl || file.url) : null)) : (file.webpublicUrl || file.url);
+	}
+
+	public async calcDriveUsageOf(user: User['id'] | { id: User['id'] }): Promise<number> {
+		const id = typeof user === 'object' ? user.id : user;
+
+		const { sum } = await this
+			.createQueryBuilder('file')
+			.where('file.userId = :id', { id: id })
+			.andWhere('file.isLink = FALSE')
+			.select('SUM(file.size)', 'sum')
+			.getRawOne();
+
+		return parseInt(sum, 10) || 0;
+	}
+
+	public async calcDriveUsageOfHost(host: string): Promise<number> {
+		const { sum } = await this
+			.createQueryBuilder('file')
+			.where('file.userHost = :host', { host: toPuny(host) })
+			.andWhere('file.isLink = FALSE')
+			.select('SUM(file.size)', 'sum')
+			.getRawOne();
+
+		return parseInt(sum, 10) || 0;
+	}
+
+	public async calcDriveUsageOfLocal(): Promise<number> {
+		const { sum } = await this
+			.createQueryBuilder('file')
+			.where('file.userHost IS NULL')
+			.andWhere('file.isLink = FALSE')
+			.select('SUM(file.size)', 'sum')
+			.getRawOne();
+
+		return parseInt(sum, 10) || 0;
+	}
+
+	public async calcDriveUsageOfRemote(): Promise<number> {
+		const { sum } = await this
+			.createQueryBuilder('file')
+			.where('file.userHost IS NOT NULL')
+			.andWhere('file.isLink = FALSE')
+			.select('SUM(file.size)', 'sum')
+			.getRawOne();
+
+		return parseInt(sum, 10) || 0;
+	}
+
+	public async pack(src: DriveFile['id'], options?: PackOptions): Promise<Packed<'DriveFile'> | null>;
+	public async pack(src: DriveFile, options?: PackOptions): Promise<Packed<'DriveFile'>>;
+	public async pack(
+		src: DriveFile['id'] | DriveFile,
+		options?: PackOptions
+	): Promise<Packed<'DriveFile'> | null> {
+		const opts = Object.assign({
+			detail: false,
+			self: false
+		}, options);
+
+		const file = typeof src === 'object' ? src : await this.findOne(src);
+		if (file == null) return null;
+
+		const meta = await fetchMeta();
+
+		return await awaitAll({
+			id: file.id,
+			createdAt: file.createdAt.toISOString(),
+			name: file.name,
+			type: file.type,
+			md5: file.md5,
+			size: file.size,
+			isSensitive: file.isSensitive,
+			blurhash: file.blurhash,
+			properties: file.properties,
+			url: opts.self ? file.url : this.getPublicUrl(file, false, meta),
+			thumbnailUrl: this.getPublicUrl(file, true, meta),
+			comment: file.comment,
+			folderId: file.folderId,
+			folder: opts.detail && file.folderId ? DriveFolders.pack(file.folderId, {
+				detail: true
+			}) : null,
+			userId: opts.withUser ? file.userId : null,
+			user: (opts.withUser && file.userId) ? Users.pack(file.userId) : null
+		});
+	}
+
+	public async packMany(
+		files: (DriveFile['id'] | DriveFile)[],
+		options?: PackOptions
+	) {
+		const items = await Promise.all(files.map(f => this.pack(f, options)));
+		return items.filter(x => x != null);
+	}
+}
+
+export const packedDriveFileSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			example: 'lenna.jpg'
+		},
+		type: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			example: 'image/jpeg'
+		},
+		md5: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'md5',
+			example: '15eca7fba0480996e2245f5185bf39f2'
+		},
+		size: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+			example: 51469
+		},
+		isSensitive: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		blurhash: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		properties: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			properties: {
+				width: {
+					type: 'number' as const,
+					optional: true as const, nullable: false as const,
+					example: 1280
+				},
+				height: {
+					type: 'number' as const,
+					optional: true as const, nullable: false as const,
+					example: 720
+				},
+				avgColor: {
+					type: 'string' as const,
+					optional: true as const, nullable: false as const,
+					example: 'rgb(40,65,87)'
+				}
+			}
+		},
+		url: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'url',
+		},
+		thumbnailUrl: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'url',
+		},
+		comment: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		folderId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		folder: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'DriveFolder' as const,
+		},
+		userId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		user: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'User' as const,
+		}
+	},
+};

packages/backend/src/models/repositories/drive-folder.ts

@@ -0,0 +1,91 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { DriveFolders, DriveFiles } from '../index';
+import { DriveFolder } from '@/models/entities/drive-folder';
+import { awaitAll } from '@/prelude/await-all';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(DriveFolder)
+export class DriveFolderRepository extends Repository<DriveFolder> {
+	public validateFolderName(name: string): boolean {
+		return (
+			(name.trim().length > 0) &&
+			(name.length <= 200)
+		);
+	}
+
+	public async pack(
+		src: DriveFolder['id'] | DriveFolder,
+		options?: {
+			detail: boolean
+		}
+	): Promise<Packed<'DriveFolder'>> {
+		const opts = Object.assign({
+			detail: false
+		}, options);
+
+		const folder = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: folder.id,
+			createdAt: folder.createdAt.toISOString(),
+			name: folder.name,
+			parentId: folder.parentId,
+
+			...(opts.detail ? {
+				foldersCount: DriveFolders.count({
+					parentId: folder.id
+				}),
+				filesCount: DriveFiles.count({
+					folderId: folder.id
+				}),
+
+				...(folder.parentId ? {
+					parent: this.pack(folder.parentId, {
+						detail: true
+					})
+				} : {})
+			} : {})
+		});
+	}
+}
+
+export const packedDriveFolderSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		foldersCount: {
+			type: 'number' as const,
+			optional: true as const, nullable: false as const,
+		},
+		filesCount: {
+			type: 'number' as const,
+			optional: true as const, nullable: false as const,
+		},
+		parentId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		parent: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'DriveFolder' as const,
+		},
+	},
+};

packages/backend/src/models/repositories/emoji.ts

@@ -0,0 +1,65 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Emoji } from '@/models/entities/emoji';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(Emoji)
+export class EmojiRepository extends Repository<Emoji> {
+	public async pack(
+		src: Emoji['id'] | Emoji,
+	): Promise<Packed<'Emoji'>> {
+		const emoji = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: emoji.id,
+			aliases: emoji.aliases,
+			name: emoji.name,
+			category: emoji.category,
+			host: emoji.host,
+			url: emoji.url,
+		};
+	}
+
+	public packMany(
+		emojis: any[],
+	) {
+		return Promise.all(emojis.map(x => this.pack(x)));
+	}
+}
+
+export const packedEmojiSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		aliases: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+				format: 'id',
+			},
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		category: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		host: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		url: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+	}
+};

packages/backend/src/models/repositories/federation-instance.ts

@@ -0,0 +1,106 @@
+import config from '@/config/index';
+
+export const packedFederationInstanceSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id'
+		},
+		caughtAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time'
+		},
+		host: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			example: 'misskey.example.com'
+		},
+		usersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		notesCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		followingCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		followersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		driveUsage: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		driveFiles: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		latestRequestSentAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'date-time'
+		},
+		lastCommunicatedAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time'
+		},
+		isNotResponding: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const
+		},
+		isSuspended: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const
+		},
+		softwareName: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			example: 'misskey'
+		},
+		softwareVersion: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			example: config.version
+		},
+		openRegistrations: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: true as const,
+			example: true
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		description: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		maintainerName: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		maintainerEmail: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const
+		},
+		iconUrl: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'url'
+		},
+		infoUpdatedAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'date-time'
+		}
+	}
+};

packages/backend/src/models/repositories/follow-request.ts

@@ -0,0 +1,20 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { FollowRequest } from '@/models/entities/follow-request';
+import { Users } from '../index';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(FollowRequest)
+export class FollowRequestRepository extends Repository<FollowRequest> {
+	public async pack(
+		src: FollowRequest['id'] | FollowRequest,
+		me?: { id: User['id'] } | null | undefined
+	) {
+		const request = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: request.id,
+			follower: await Users.pack(request.followerId, me),
+			followee: await Users.pack(request.followeeId, me),
+		};
+	}
+}

packages/backend/src/models/repositories/following.ts

@@ -0,0 +1,124 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Users } from '../index';
+import { Following } from '@/models/entities/following';
+import { awaitAll } from '@/prelude/await-all';
+import { Packed } from '@/misc/schema';
+import { User } from '@/models/entities/user';
+
+type LocalFollowerFollowing = Following & {
+	followerHost: null;
+	followerInbox: null;
+	followerSharedInbox: null;
+};
+
+type RemoteFollowerFollowing = Following & {
+	followerHost: string;
+	followerInbox: string;
+	followerSharedInbox: string;
+};
+
+type LocalFolloweeFollowing = Following & {
+	followeeHost: null;
+	followeeInbox: null;
+	followeeSharedInbox: null;
+};
+
+type RemoteFolloweeFollowing = Following & {
+	followeeHost: string;
+	followeeInbox: string;
+	followeeSharedInbox: string;
+};
+
+@EntityRepository(Following)
+export class FollowingRepository extends Repository<Following> {
+	public isLocalFollower(following: Following): following is LocalFollowerFollowing {
+		return following.followerHost == null;
+	}
+
+	public isRemoteFollower(following: Following): following is RemoteFollowerFollowing {
+		return following.followerHost != null;
+	}
+
+	public isLocalFollowee(following: Following): following is LocalFolloweeFollowing {
+		return following.followeeHost == null;
+	}
+
+	public isRemoteFollowee(following: Following): following is RemoteFolloweeFollowing {
+		return following.followeeHost != null;
+	}
+
+	public async pack(
+		src: Following['id'] | Following,
+		me?: { id: User['id'] } | null | undefined,
+		opts?: {
+			populateFollowee?: boolean;
+			populateFollower?: boolean;
+		}
+	): Promise<Packed<'Following'>> {
+		const following = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		if (opts == null) opts = {};
+
+		return await awaitAll({
+			id: following.id,
+			createdAt: following.createdAt.toISOString(),
+			followeeId: following.followeeId,
+			followerId: following.followerId,
+			followee: opts.populateFollowee ? Users.pack(following.followee || following.followeeId, me, {
+				detail: true
+			}) : undefined,
+			follower: opts.populateFollower ? Users.pack(following.follower || following.followerId, me, {
+				detail: true
+			}) : undefined,
+		});
+	}
+
+	public packMany(
+		followings: any[],
+		me?: { id: User['id'] } | null | undefined,
+		opts?: {
+			populateFollowee?: boolean;
+			populateFollower?: boolean;
+		}
+	) {
+		return Promise.all(followings.map(x => this.pack(x, me, opts)));
+	}
+}
+
+export const packedFollowingSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		followeeId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		followee: {
+			type: 'object' as const,
+			optional: true as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+		followerId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		follower: {
+			type: 'object' as const,
+			optional: true as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+	}
+};

packages/backend/src/models/repositories/gallery-like.ts

@@ -0,0 +1,25 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { GalleryLike } from '@/models/entities/gallery-like';
+import { GalleryPosts } from '../index';
+
+@EntityRepository(GalleryLike)
+export class GalleryLikeRepository extends Repository<GalleryLike> {
+	public async pack(
+		src: GalleryLike['id'] | GalleryLike,
+		me?: any
+	) {
+		const like = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: like.id,
+			post: await GalleryPosts.pack(like.post || like.postId, me),
+		};
+	}
+
+	public packMany(
+		likes: any[],
+		me: any
+	) {
+		return Promise.all(likes.map(x => this.pack(x, me)));
+	}
+}

packages/backend/src/models/repositories/gallery-post.ts

@@ -0,0 +1,111 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { GalleryPost } from '@/models/entities/gallery-post';
+import { Packed } from '@/misc/schema';
+import { Users, DriveFiles, GalleryLikes } from '../index';
+import { awaitAll } from '@/prelude/await-all';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(GalleryPost)
+export class GalleryPostRepository extends Repository<GalleryPost> {
+	public async pack(
+		src: GalleryPost['id'] | GalleryPost,
+		me?: { id: User['id'] } | null | undefined,
+	): Promise<Packed<'GalleryPost'>> {
+		const meId = me ? me.id : null;
+		const post = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: post.id,
+			createdAt: post.createdAt.toISOString(),
+			updatedAt: post.updatedAt.toISOString(),
+			userId: post.userId,
+			user: Users.pack(post.user || post.userId, me),
+			title: post.title,
+			description: post.description,
+			fileIds: post.fileIds,
+			files: DriveFiles.packMany(post.fileIds),
+			tags: post.tags.length > 0 ? post.tags : undefined,
+			isSensitive: post.isSensitive,
+			likedCount: post.likedCount,
+			isLiked: meId ? await GalleryLikes.findOne({ postId: post.id, userId: meId }).then(x => x != null) : undefined,
+		});
+	}
+
+	public packMany(
+		posts: GalleryPost[],
+		me?: { id: User['id'] } | null | undefined,
+	) {
+		return Promise.all(posts.map(x => this.pack(x, me)));
+	}
+}
+
+export const packedGalleryPostSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		updatedAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		title: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		description: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		userId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		user: {
+			type: 'object' as const,
+			ref: 'User' as const,
+			optional: false as const, nullable: false as const,
+		},
+		fileIds: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+				format: 'id'
+			}
+		},
+		files: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'object' as const,
+				optional: false as const, nullable: false as const,
+				ref: 'DriveFile' as const,
+			}
+		},
+		tags: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+			}
+		},
+		isSensitive: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+	}
+};

packages/backend/src/models/repositories/games/reversi/game.ts

@@ -0,0 +1,191 @@
+import { User } from '@/models/entities/user';
+import { EntityRepository, Repository } from 'typeorm';
+import { Users } from '../../../index';
+import { ReversiGame } from '@/models/entities/games/reversi/game';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(ReversiGame)
+export class ReversiGameRepository extends Repository<ReversiGame> {
+	public async pack(
+		src: ReversiGame['id'] | ReversiGame,
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			detail?: boolean
+		}
+	): Promise<Packed<'ReversiGame'>> {
+		const opts = Object.assign({
+			detail: true
+		}, options);
+
+		const game = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: game.id,
+			createdAt: game.createdAt.toISOString(),
+			startedAt: game.startedAt && game.startedAt.toISOString(),
+			isStarted: game.isStarted,
+			isEnded: game.isEnded,
+			form1: game.form1,
+			form2: game.form2,
+			user1Accepted: game.user1Accepted,
+			user2Accepted: game.user2Accepted,
+			user1Id: game.user1Id,
+			user2Id: game.user2Id,
+			user1: await Users.pack(game.user1Id, me),
+			user2: await Users.pack(game.user2Id, me),
+			winnerId: game.winnerId,
+			winner: game.winnerId ? await Users.pack(game.winnerId, me) : null,
+			surrendered: game.surrendered,
+			black: game.black,
+			bw: game.bw,
+			isLlotheo: game.isLlotheo,
+			canPutEverywhere: game.canPutEverywhere,
+			loopedBoard: game.loopedBoard,
+			...(opts.detail ? {
+				logs: game.logs.map(log => ({
+					at: log.at.toISOString(),
+					color: log.color,
+					pos: log.pos
+				})),
+				map: game.map,
+			} : {})
+		};
+	}
+}
+
+export const packedReversiGameSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		startedAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'date-time',
+		},
+		isStarted: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		isEnded: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		form1: {
+			type: 'any' as const,
+			optional: false as const, nullable: true as const,
+		},
+		form2: {
+			type: 'any' as const,
+			optional: false as const, nullable: true as const,
+		},
+		user1Accepted: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		user2Accepted: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		user1Id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		user2Id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		user1: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+		user2: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+		winnerId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		winner: {
+			type: 'object' as const,
+			optional: false as const, nullable: true as const,
+			ref: 'User' as const,
+		},
+		surrendered: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		black: {
+			type: 'number' as const,
+			optional: false as const, nullable: true as const,
+		},
+		bw: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		isLlotheo: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		canPutEverywhere: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		loopedBoard: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		logs: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'object' as const,
+				optional: true as const, nullable: false as const,
+				properties: {
+					at: {
+						type: 'string' as const,
+						optional: false as const, nullable: false as const,
+						format: 'date-time',
+					},
+					color: {
+						type: 'boolean' as const,
+						optional: false as const, nullable: false as const,
+					},
+					pos: {
+						type: 'number' as const,
+						optional: false as const, nullable: false as const,
+					},
+				}
+			}
+		},
+		map: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+			}
+		}
+	}
+};

packages/backend/src/models/repositories/games/reversi/matching.ts

@@ -0,0 +1,69 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { ReversiMatching } from '@/models/entities/games/reversi/matching';
+import { Users } from '../../../index';
+import { awaitAll } from '@/prelude/await-all';
+import { User } from '@/models/entities/user';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(ReversiMatching)
+export class ReversiMatchingRepository extends Repository<ReversiMatching> {
+	public async pack(
+		src: ReversiMatching['id'] | ReversiMatching,
+		me: { id: User['id'] }
+	): Promise<Packed<'ReversiMatching'>> {
+		const matching = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: matching.id,
+			createdAt: matching.createdAt.toISOString(),
+			parentId: matching.parentId,
+			parent: Users.pack(matching.parentId, me, {
+				detail: true
+			}),
+			childId: matching.childId,
+			child: Users.pack(matching.childId, me, {
+				detail: true
+			})
+		});
+	}
+}
+
+export const packedReversiMatchingSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		parentId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		parent: {
+			type: 'object' as const,
+			optional: false as const, nullable: true as const,
+			ref: 'User' as const,
+		},
+		childId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		child: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+	}
+};

packages/backend/src/models/repositories/hashtag.ts

@@ -0,0 +1,62 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Hashtag } from '@/models/entities/hashtag';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(Hashtag)
+export class HashtagRepository extends Repository<Hashtag> {
+	public async pack(
+		src: Hashtag,
+	): Promise<Packed<'Hashtag'>> {
+		return {
+			tag: src.name,
+			mentionedUsersCount: src.mentionedUsersCount,
+			mentionedLocalUsersCount: src.mentionedLocalUsersCount,
+			mentionedRemoteUsersCount: src.mentionedRemoteUsersCount,
+			attachedUsersCount: src.attachedUsersCount,
+			attachedLocalUsersCount: src.attachedLocalUsersCount,
+			attachedRemoteUsersCount: src.attachedRemoteUsersCount,
+		};
+	}
+
+	public packMany(
+		hashtags: Hashtag[],
+	) {
+		return Promise.all(hashtags.map(x => this.pack(x)));
+	}
+}
+
+export const packedHashtagSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		tag: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			example: 'misskey',
+		},
+		mentionedUsersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		mentionedLocalUsersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		mentionedRemoteUsersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		attachedUsersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		attachedLocalUsersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		attachedRemoteUsersCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+	}
+};

packages/backend/src/models/repositories/messaging-message.ts

@@ -0,0 +1,119 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { MessagingMessage } from '@/models/entities/messaging-message';
+import { Users, DriveFiles, UserGroups } from '../index';
+import { Packed } from '@/misc/schema';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(MessagingMessage)
+export class MessagingMessageRepository extends Repository<MessagingMessage> {
+	public validateText(text: string): boolean {
+		return text.trim().length <= 1000 && text.trim() != '';
+	}
+
+	public async pack(
+		src: MessagingMessage['id'] | MessagingMessage,
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			populateRecipient?: boolean,
+			populateGroup?: boolean,
+		}
+	): Promise<Packed<'MessagingMessage'>> {
+		const opts = options || {
+			populateRecipient: true,
+			populateGroup: true,
+		};
+
+		const message = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: message.id,
+			createdAt: message.createdAt.toISOString(),
+			text: message.text,
+			userId: message.userId,
+			user: await Users.pack(message.user || message.userId, me),
+			recipientId: message.recipientId,
+			recipient: message.recipientId && opts.populateRecipient ? await Users.pack(message.recipient || message.recipientId, me) : undefined,
+			groupId: message.groupId,
+			group: message.groupId && opts.populateGroup ? await UserGroups.pack(message.group || message.groupId) : undefined,
+			fileId: message.fileId,
+			file: message.fileId ? await DriveFiles.pack(message.fileId) : null,
+			isRead: message.isRead,
+			reads: message.reads,
+		};
+	}
+}
+
+export const packedMessagingMessageSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		userId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		user: {
+			type: 'object' as const,
+			ref: 'User' as const,
+			optional: true as const, nullable: false as const,
+		},
+		text: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		fileId: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+			format: 'id',
+		},
+		file: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'DriveFile' as const,
+		},
+		recipientId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+		},
+		recipient: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'User' as const,
+		},
+		groupId: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+			format: 'id',
+		},
+		group: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'UserGroup' as const,
+		},
+		isRead: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const,
+		},
+		reads: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+				format: 'id'
+			}
+		},
+	},
+};

packages/backend/src/models/repositories/moderation-logs.ts

@@ -0,0 +1,30 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Users } from '../index';
+import { ModerationLog } from '@/models/entities/moderation-log';
+import { awaitAll } from '@/prelude/await-all';
+
+@EntityRepository(ModerationLog)
+export class ModerationLogRepository extends Repository<ModerationLog> {
+	public async pack(
+		src: ModerationLog['id'] | ModerationLog,
+	) {
+		const log = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: log.id,
+			createdAt: log.createdAt,
+			type: log.type,
+			info: log.info,
+			userId: log.userId,
+			user: Users.pack(log.user || log.userId, null, {
+				detail: true
+			}),
+		});
+	}
+
+	public packMany(
+		reports: any[],
+	) {
+		return Promise.all(reports.map(x => this.pack(x)));
+	}
+}

packages/backend/src/models/repositories/muting.ts

@@ -0,0 +1,60 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Users } from '../index';
+import { Muting } from '@/models/entities/muting';
+import { awaitAll } from '@/prelude/await-all';
+import { Packed } from '@/misc/schema';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(Muting)
+export class MutingRepository extends Repository<Muting> {
+	public async pack(
+		src: Muting['id'] | Muting,
+		me?: { id: User['id'] } | null | undefined
+	): Promise<Packed<'Muting'>> {
+		const muting = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return await awaitAll({
+			id: muting.id,
+			createdAt: muting.createdAt.toISOString(),
+			muteeId: muting.muteeId,
+			mutee: Users.pack(muting.muteeId, me, {
+				detail: true
+			})
+		});
+	}
+
+	public packMany(
+		mutings: any[],
+		me: { id: User['id'] }
+	) {
+		return Promise.all(mutings.map(x => this.pack(x, me)));
+	}
+}
+
+export const packedMutingSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		muteeId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		mutee: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+	}
+};

packages/backend/src/models/repositories/note-favorite.ts

@@ -0,0 +1,56 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { NoteFavorite } from '@/models/entities/note-favorite';
+import { Notes } from '../index';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(NoteFavorite)
+export class NoteFavoriteRepository extends Repository<NoteFavorite> {
+	public async pack(
+		src: NoteFavorite['id'] | NoteFavorite,
+		me?: { id: User['id'] } | null | undefined
+	) {
+		const favorite = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: favorite.id,
+			createdAt: favorite.createdAt,
+			noteId: favorite.noteId,
+			note: await Notes.pack(favorite.note || favorite.noteId, me),
+		};
+	}
+
+	public packMany(
+		favorites: any[],
+		me: { id: User['id'] }
+	) {
+		return Promise.all(favorites.map(x => this.pack(x, me)));
+	}
+}
+
+export const packedNoteFavoriteSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		note: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'Note' as const,
+		},
+		noteId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+	},
+};

packages/backend/src/models/repositories/note-reaction.ts

@@ -0,0 +1,60 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { NoteReaction } from '@/models/entities/note-reaction';
+import { Notes, Users } from '../index';
+import { Packed } from '@/misc/schema';
+import { convertLegacyReaction } from '@/misc/reaction-lib';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(NoteReaction)
+export class NoteReactionRepository extends Repository<NoteReaction> {
+	public async pack(
+		src: NoteReaction['id'] | NoteReaction,
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			withNote: boolean;
+		},
+	): Promise<Packed<'NoteReaction'>> {
+		const opts = Object.assign({
+			withNote: false,
+		}, options);
+
+		const reaction = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: reaction.id,
+			createdAt: reaction.createdAt.toISOString(),
+			user: await Users.pack(reaction.userId, me),
+			type: convertLegacyReaction(reaction.reaction),
+			...(opts.withNote ? {
+				note: await Notes.pack(reaction.noteId, me),
+			} : {})
+		};
+	}
+}
+
+export const packedNoteReactionSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		user: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+			ref: 'User' as const,
+		},
+		type: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+	},
+};

packages/backend/src/models/repositories/note.ts

@@ -0,0 +1,512 @@
+import { EntityRepository, Repository, In } from 'typeorm';
+import * as mfm from 'mfm-js';
+import { Note } from '@/models/entities/note';
+import { User } from '@/models/entities/user';
+import { Users, PollVotes, DriveFiles, NoteReactions, Followings, Polls, Channels } from '../index';
+import { Packed } from '@/misc/schema';
+import { nyaize } from '@/misc/nyaize';
+import { awaitAll } from '@/prelude/await-all';
+import { convertLegacyReaction, convertLegacyReactions, decodeReaction } from '@/misc/reaction-lib';
+import { NoteReaction } from '@/models/entities/note-reaction';
+import { aggregateNoteEmojis, populateEmojis, prefetchEmojis } from '@/misc/populate-emojis';
+
+@EntityRepository(Note)
+export class NoteRepository extends Repository<Note> {
+	public validateCw(x: string) {
+		return x.trim().length <= 100;
+	}
+
+	public async isVisibleForMe(note: Note, meId: User['id'] | null): Promise<boolean> {
+		// visibility が specified かつ自分が指定されていなかったら非表示
+		if (note.visibility === 'specified') {
+			if (meId == null) {
+				return false;
+			} else if (meId === note.userId) {
+				return true;
+			} else {
+				// 指定されているかどうか
+				const specified = note.visibleUserIds.some((id: any) => meId === id);
+
+				if (specified) {
+					return true;
+				} else {
+					return false;
+				}
+			}
+		}
+
+		// visibility が followers かつ自分が投稿者のフォロワーでなかったら非表示
+		if (note.visibility === 'followers') {
+			if (meId == null) {
+				return false;
+			} else if (meId === note.userId) {
+				return true;
+			} else if (note.reply && (meId === note.reply.userId)) {
+				// 自分の投稿に対するリプライ
+				return true;
+			} else if (note.mentions && note.mentions.some(id => meId === id)) {
+				// 自分へのメンション
+				return true;
+			} else {
+				// フォロワーかどうか
+				const following = await Followings.findOne({
+					followeeId: note.userId,
+					followerId: meId
+				});
+
+				if (following == null) {
+					return false;
+				} else {
+					return true;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	private async hideNote(packedNote: Packed<'Note'>, meId: User['id'] | null) {
+		// TODO: isVisibleForMe を使うようにしても良さそう(型違うけど)
+		let hide = false;
+
+		// visibility が specified かつ自分が指定されていなかったら非表示
+		if (packedNote.visibility === 'specified') {
+			if (meId == null) {
+				hide = true;
+			} else if (meId === packedNote.userId) {
+				hide = false;
+			} else {
+				// 指定されているかどうか
+				const specified = packedNote.visibleUserIds!.some((id: any) => meId === id);
+
+				if (specified) {
+					hide = false;
+				} else {
+					hide = true;
+				}
+			}
+		}
+
+		// visibility が followers かつ自分が投稿者のフォロワーでなかったら非表示
+		if (packedNote.visibility === 'followers') {
+			if (meId == null) {
+				hide = true;
+			} else if (meId === packedNote.userId) {
+				hide = false;
+			} else if (packedNote.reply && (meId === packedNote.reply.userId)) {
+				// 自分の投稿に対するリプライ
+				hide = false;
+			} else if (packedNote.mentions && packedNote.mentions.some(id => meId === id)) {
+				// 自分へのメンション
+				hide = false;
+			} else {
+				// フォロワーかどうか
+				const following = await Followings.findOne({
+					followeeId: packedNote.userId,
+					followerId: meId
+				});
+
+				if (following == null) {
+					hide = true;
+				} else {
+					hide = false;
+				}
+			}
+		}
+
+		if (hide) {
+			packedNote.visibleUserIds = undefined;
+			packedNote.fileIds = [];
+			packedNote.files = [];
+			packedNote.text = null;
+			packedNote.poll = undefined;
+			packedNote.cw = null;
+			packedNote.isHidden = true;
+		}
+	}
+
+	public async pack(
+		src: Note['id'] | Note,
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			detail?: boolean;
+			skipHide?: boolean;
+			_hint_?: {
+				myReactions: Map<Note['id'], NoteReaction | null>;
+			};
+		}
+	): Promise<Packed<'Note'>> {
+		const opts = Object.assign({
+			detail: true,
+			skipHide: false
+		}, options);
+
+		const meId = me ? me.id : null;
+		const note = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const host = note.userHost;
+
+		async function populatePoll() {
+			const poll = await Polls.findOneOrFail(note.id);
+			const choices = poll.choices.map(c => ({
+				text: c,
+				votes: poll.votes[poll.choices.indexOf(c)],
+				isVoted: false
+			}));
+
+			if (poll.multiple) {
+				const votes = await PollVotes.find({
+					userId: meId!,
+					noteId: note.id
+				});
+
+				const myChoices = votes.map(v => v.choice);
+				for (const myChoice of myChoices) {
+					choices[myChoice].isVoted = true;
+				}
+			} else {
+				const vote = await PollVotes.findOne({
+					userId: meId!,
+					noteId: note.id
+				});
+
+				if (vote) {
+					choices[vote.choice].isVoted = true;
+				}
+			}
+
+			return {
+				multiple: poll.multiple,
+				expiresAt: poll.expiresAt,
+				choices
+			};
+		}
+
+		async function populateMyReaction() {
+			if (options?._hint_?.myReactions) {
+				const reaction = options._hint_.myReactions.get(note.id);
+				if (reaction) {
+					return convertLegacyReaction(reaction.reaction);
+				} else if (reaction === null) {
+					return undefined;
+				}
+				// 実装上抜けがあるだけかもしれないので、「ヒントに含まれてなかったら(=undefinedなら)return」のようにはしない
+			}
+
+			const reaction = await NoteReactions.findOne({
+				userId: meId!,
+				noteId: note.id,
+			});
+
+			if (reaction) {
+				return convertLegacyReaction(reaction.reaction);
+			}
+
+			return undefined;
+		}
+
+		let text = note.text;
+
+		if (note.name && (note.url || note.uri)) {
+			text = `【${note.name}】\n${(note.text || '').trim()}\n\n${note.url || note.uri}`;
+		}
+
+		const channel = note.channelId
+			? note.channel
+				? note.channel
+				: await Channels.findOne(note.channelId)
+			: null;
+
+		const reactionEmojiNames = Object.keys(note.reactions).filter(x => x?.startsWith(':')).map(x => decodeReaction(x).reaction).map(x => x.replace(/:/g, ''));
+
+		const packed = await awaitAll({
+			id: note.id,
+			createdAt: note.createdAt.toISOString(),
+			userId: note.userId,
+			user: Users.pack(note.user || note.userId, me, {
+				detail: false,
+			}),
+			text: text,
+			cw: note.cw,
+			visibility: note.visibility,
+			localOnly: note.localOnly || undefined,
+			visibleUserIds: note.visibility === 'specified' ? note.visibleUserIds : undefined,
+			viaMobile: note.viaMobile || undefined,
+			renoteCount: note.renoteCount,
+			repliesCount: note.repliesCount,
+			reactions: convertLegacyReactions(note.reactions),
+			tags: note.tags.length > 0 ? note.tags : undefined,
+			emojis: populateEmojis(note.emojis.concat(reactionEmojiNames), host),
+			fileIds: note.fileIds,
+			files: DriveFiles.packMany(note.fileIds),
+			replyId: note.replyId,
+			renoteId: note.renoteId,
+			channelId: note.channelId || undefined,
+			channel: channel ? {
+				id: channel.id,
+				name: channel.name,
+			} : undefined,
+			mentions: note.mentions.length > 0 ? note.mentions : undefined,
+			uri: note.uri || undefined,
+			url: note.url || undefined,
+
+			...(opts.detail ? {
+				reply: note.replyId ? this.pack(note.reply || note.replyId, me, {
+					detail: false,
+					_hint_: options?._hint_
+				}) : undefined,
+
+				renote: note.renoteId ? this.pack(note.renote || note.renoteId, me, {
+					detail: true,
+					_hint_: options?._hint_
+				}) : undefined,
+
+				poll: note.hasPoll ? populatePoll() : undefined,
+
+				...(meId ? {
+					myReaction: populateMyReaction()
+				} : {})
+			} : {})
+		});
+
+		if (packed.user.isCat && packed.text) {
+			const tokens = packed.text ? mfm.parse(packed.text) : [];
+			mfm.inspect(tokens, node => {
+				if (node.type === 'text') {
+					// TODO: quoteなtextはskip
+					node.props.text = nyaize(node.props.text);
+				}
+			});
+			packed.text = mfm.toString(tokens);
+		}
+
+		if (!opts.skipHide) {
+			await this.hideNote(packed, meId);
+		}
+
+		return packed;
+	}
+
+	public async packMany(
+		notes: Note[],
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			detail?: boolean;
+			skipHide?: boolean;
+		}
+	) {
+		if (notes.length === 0) return [];
+
+		const meId = me ? me.id : null;
+		const myReactionsMap = new Map<Note['id'], NoteReaction | null>();
+		if (meId) {
+			const renoteIds = notes.filter(n => n.renoteId != null).map(n => n.renoteId!);
+			const targets = [...notes.map(n => n.id), ...renoteIds];
+			const myReactions = await NoteReactions.find({
+				userId: meId,
+				noteId: In(targets),
+			});
+
+			for (const target of targets) {
+				myReactionsMap.set(target, myReactions.find(reaction => reaction.noteId === target) || null);
+			}
+		}
+
+		await prefetchEmojis(aggregateNoteEmojis(notes));
+
+		return await Promise.all(notes.map(n => this.pack(n, me, {
+			...options,
+			_hint_: {
+				myReactions: myReactionsMap
+			}
+		})));
+	}
+}
+
+export const packedNoteSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		text: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		cw: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+		},
+		userId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		user: {
+			type: 'object' as const,
+			ref: 'User' as const,
+			optional: false as const, nullable: false as const,
+		},
+		replyId: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		renoteId: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		reply: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'Note' as const,
+		},
+		renote: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			ref: 'Note' as const,
+		},
+		viaMobile: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const,
+		},
+		isHidden: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const,
+		},
+		visibility: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		mentions: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+				format: 'id'
+			}
+		},
+		visibleUserIds: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+				format: 'id'
+			}
+		},
+		fileIds: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+				format: 'id'
+			}
+		},
+		files: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'object' as const,
+				optional: false as const, nullable: false as const,
+				ref: 'DriveFile' as const,
+			}
+		},
+		tags: {
+			type: 'array' as const,
+			optional: true as const, nullable: false as const,
+			items: {
+				type: 'string' as const,
+				optional: false as const, nullable: false as const,
+			}
+		},
+		poll: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+		},
+		channelId: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		channel: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+			items: {
+				type: 'object' as const,
+				optional: false as const, nullable: false as const,
+				properties: {
+					id: {
+						type: 'string' as const,
+						optional: false as const, nullable: false as const,
+					},
+					name: {
+						type: 'string' as const,
+						optional: false as const, nullable: true as const,
+					},
+				},
+			},
+		},
+		localOnly: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const,
+		},
+		emojis: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+			items: {
+				type: 'object' as const,
+				optional: false as const, nullable: false as const,
+				properties: {
+					name: {
+						type: 'string' as const,
+						optional: false as const, nullable: false as const,
+					},
+					url: {
+						type: 'string' as const,
+						optional: false as const, nullable: true as const,
+					},
+				},
+			},
+		},
+		reactions: {
+			type: 'object' as const,
+			optional: false as const, nullable: false as const,
+		},
+		renoteCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		repliesCount: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const,
+		},
+		uri: {
+			type: 'string' as const,
+			optional: true as const, nullable: false as const,
+		},
+		url: {
+			type: 'string' as const,
+			optional: true as const, nullable: false as const,
+		},
+
+		myReaction: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+		},
+	},
+};

packages/backend/src/models/repositories/notification.ts

@@ -0,0 +1,175 @@
+import { EntityRepository, In, Repository } from 'typeorm';
+import { Users, Notes, UserGroupInvitations, AccessTokens, NoteReactions } from '../index';
+import { Notification } from '@/models/entities/notification';
+import { awaitAll } from '@/prelude/await-all';
+import { Packed } from '@/misc/schema';
+import { Note } from '@/models/entities/note';
+import { NoteReaction } from '@/models/entities/note-reaction';
+import { User } from '@/models/entities/user';
+import { aggregateNoteEmojis, prefetchEmojis } from '@/misc/populate-emojis';
+import { notificationTypes } from '@/types';
+
+@EntityRepository(Notification)
+export class NotificationRepository extends Repository<Notification> {
+	public async pack(
+		src: Notification['id'] | Notification,
+		options: {
+			_hintForEachNotes_?: {
+				myReactions: Map<Note['id'], NoteReaction | null>;
+			};
+		}
+	): Promise<Packed<'Notification'>> {
+		const notification = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const token = notification.appAccessTokenId ? await AccessTokens.findOneOrFail(notification.appAccessTokenId) : null;
+
+		return await awaitAll({
+			id: notification.id,
+			createdAt: notification.createdAt.toISOString(),
+			type: notification.type,
+			isRead: notification.isRead,
+			userId: notification.notifierId,
+			user: notification.notifierId ? Users.pack(notification.notifier || notification.notifierId) : null,
+			...(notification.type === 'mention' ? {
+				note: Notes.pack(notification.note || notification.noteId!, { id: notification.notifieeId }, {
+					detail: true,
+					_hint_: options._hintForEachNotes_
+				}),
+			} : {}),
+			...(notification.type === 'reply' ? {
+				note: Notes.pack(notification.note || notification.noteId!, { id: notification.notifieeId }, {
+					detail: true,
+					_hint_: options._hintForEachNotes_
+				}),
+			} : {}),
+			...(notification.type === 'renote' ? {
+				note: Notes.pack(notification.note || notification.noteId!, { id: notification.notifieeId }, {
+					detail: true,
+					_hint_: options._hintForEachNotes_
+				}),
+			} : {}),
+			...(notification.type === 'quote' ? {
+				note: Notes.pack(notification.note || notification.noteId!, { id: notification.notifieeId }, {
+					detail: true,
+					_hint_: options._hintForEachNotes_
+				}),
+			} : {}),
+			...(notification.type === 'reaction' ? {
+				note: Notes.pack(notification.note || notification.noteId!, { id: notification.notifieeId }, {
+					detail: true,
+					_hint_: options._hintForEachNotes_
+				}),
+				reaction: notification.reaction
+			} : {}),
+			...(notification.type === 'pollVote' ? {
+				note: Notes.pack(notification.note || notification.noteId!, { id: notification.notifieeId }, {
+					detail: true,
+					_hint_: options._hintForEachNotes_
+				}),
+				choice: notification.choice
+			} : {}),
+			...(notification.type === 'groupInvited' ? {
+				invitation: UserGroupInvitations.pack(notification.userGroupInvitationId!),
+			} : {}),
+			...(notification.type === 'app' ? {
+				body: notification.customBody,
+				header: notification.customHeader || token?.name,
+				icon: notification.customIcon || token?.iconUrl,
+			} : {}),
+		});
+	}
+
+	public async packMany(
+		notifications: Notification[],
+		meId: User['id']
+	) {
+		if (notifications.length === 0) return [];
+
+		const notes = notifications.filter(x => x.note != null).map(x => x.note!);
+		const noteIds = notes.map(n => n.id);
+		const myReactionsMap = new Map<Note['id'], NoteReaction | null>();
+		const renoteIds = notes.filter(n => n.renoteId != null).map(n => n.renoteId!);
+		const targets = [...noteIds, ...renoteIds];
+		const myReactions = await NoteReactions.find({
+			userId: meId,
+			noteId: In(targets),
+		});
+
+		for (const target of targets) {
+			myReactionsMap.set(target, myReactions.find(reaction => reaction.noteId === target) || null);
+		}
+
+		await prefetchEmojis(aggregateNoteEmojis(notes));
+
+		return await Promise.all(notifications.map(x => this.pack(x, {
+			_hintForEachNotes_: {
+				myReactions: myReactionsMap
+			}
+		})));
+	}
+}
+
+export const packedNotificationSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		isRead: {
+			type: 'boolean' as const,
+			optional: false as const, nullable: false as const,
+		},
+		type: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			enum: [...notificationTypes],
+		},
+		user: {
+			type: 'object' as const,
+			ref: 'User' as const,
+			optional: true as const, nullable: true as const,
+		},
+		userId: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+			format: 'id',
+		},
+		note: {
+			type: 'object' as const,
+			ref: 'Note' as const,
+			optional: true as const, nullable: true as const,
+		},
+		reaction: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+		},
+		choice: {
+			type: 'number' as const,
+			optional: true as const, nullable: true as const,
+		},
+		invitation: {
+			type: 'object' as const,
+			optional: true as const, nullable: true as const,
+		},
+		body: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+		},
+		header: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+		},
+		icon: {
+			type: 'string' as const,
+			optional: true as const, nullable: true as const,
+		},
+	}
+};

packages/backend/src/models/repositories/page-like.ts

@@ -0,0 +1,26 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { PageLike } from '@/models/entities/page-like';
+import { Pages } from '../index';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(PageLike)
+export class PageLikeRepository extends Repository<PageLike> {
+	public async pack(
+		src: PageLike['id'] | PageLike,
+		me?: { id: User['id'] } | null | undefined
+	) {
+		const like = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: like.id,
+			page: await Pages.pack(like.page || like.pageId, me),
+		};
+	}
+
+	public packMany(
+		likes: any[],
+		me: { id: User['id'] }
+	) {
+		return Promise.all(likes.map(x => this.pack(x, me)));
+	}
+}

packages/backend/src/models/repositories/page.ts

@@ -0,0 +1,142 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Page } from '@/models/entities/page';
+import { Packed } from '@/misc/schema';
+import { Users, DriveFiles, PageLikes } from '../index';
+import { awaitAll } from '@/prelude/await-all';
+import { DriveFile } from '@/models/entities/drive-file';
+import { User } from '@/models/entities/user';
+
+@EntityRepository(Page)
+export class PageRepository extends Repository<Page> {
+	public async pack(
+		src: Page['id'] | Page,
+		me?: { id: User['id'] } | null | undefined,
+	): Promise<Packed<'Page'>> {
+		const meId = me ? me.id : null;
+		const page = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		const attachedFiles: Promise<DriveFile | undefined>[] = [];
+		const collectFile = (xs: any[]) => {
+			for (const x of xs) {
+				if (x.type === 'image') {
+					attachedFiles.push(DriveFiles.findOne({
+						id: x.fileId,
+						userId: page.userId
+					}));
+				}
+				if (x.children) {
+					collectFile(x.children);
+				}
+			}
+		};
+		collectFile(page.content);
+
+		// 後方互換性のため
+		let migrated = false;
+		const migrate = (xs: any[]) => {
+			for (const x of xs) {
+				if (x.type === 'input') {
+					if (x.inputType === 'text') {
+						x.type = 'textInput';
+					}
+					if (x.inputType === 'number') {
+						x.type = 'numberInput';
+						if (x.default) x.default = parseInt(x.default, 10);
+					}
+					migrated = true;
+				}
+				if (x.children) {
+					migrate(x.children);
+				}
+			}
+		};
+		migrate(page.content);
+		if (migrated) {
+			this.update(page.id, {
+				content: page.content
+			});
+		}
+
+		return await awaitAll({
+			id: page.id,
+			createdAt: page.createdAt.toISOString(),
+			updatedAt: page.updatedAt.toISOString(),
+			userId: page.userId,
+			user: Users.pack(page.user || page.userId, me), // { detail: true } すると無限ループするので注意
+			content: page.content,
+			variables: page.variables,
+			title: page.title,
+			name: page.name,
+			summary: page.summary,
+			hideTitleWhenPinned: page.hideTitleWhenPinned,
+			alignCenter: page.alignCenter,
+			font: page.font,
+			script: page.script,
+			eyeCatchingImageId: page.eyeCatchingImageId,
+			eyeCatchingImage: page.eyeCatchingImageId ? await DriveFiles.pack(page.eyeCatchingImageId) : null,
+			attachedFiles: DriveFiles.packMany(await Promise.all(attachedFiles)),
+			likedCount: page.likedCount,
+			isLiked: meId ? await PageLikes.findOne({ pageId: page.id, userId: meId }).then(x => x != null) : undefined,
+		});
+	}
+
+	public packMany(
+		pages: Page[],
+		me?: { id: User['id'] } | null | undefined,
+	) {
+		return Promise.all(pages.map(x => this.pack(x, me)));
+	}
+}
+
+export const packedPageSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		updatedAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		title: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		summary: {
+			type: 'string' as const,
+			optional: false as const, nullable: true as const,
+		},
+		content: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+		},
+		variables: {
+			type: 'array' as const,
+			optional: false as const, nullable: false as const,
+		},
+		userId: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+		},
+		user: {
+			type: 'object' as const,
+			ref: 'User' as const,
+			optional: false as const, nullable: false as const,
+		},
+	}
+};

packages/backend/src/models/repositories/queue.ts

@@ -0,0 +1,30 @@
+export const packedQueueCountSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		waiting: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		active: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		completed: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		failed: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		delayed: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		},
+		paused: {
+			type: 'number' as const,
+			optional: false as const, nullable: false as const
+		}
+	}
+};

packages/backend/src/models/repositories/relay.ts

@@ -0,0 +1,6 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Relay } from '@/models/entities/relay';
+
+@EntityRepository(Relay)
+export class RelayRepository extends Repository<Relay> {
+}

packages/backend/src/models/repositories/signin.ts

@@ -0,0 +1,11 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { Signin } from '@/models/entities/signin';
+
+@EntityRepository(Signin)
+export class SigninRepository extends Repository<Signin> {
+	public async pack(
+		src: Signin,
+	) {
+		return src;
+	}
+}

packages/backend/src/models/repositories/user-group-invitation.ts

@@ -0,0 +1,23 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { UserGroupInvitation } from '@/models/entities/user-group-invitation';
+import { UserGroups } from '../index';
+
+@EntityRepository(UserGroupInvitation)
+export class UserGroupInvitationRepository extends Repository<UserGroupInvitation> {
+	public async pack(
+		src: UserGroupInvitation['id'] | UserGroupInvitation,
+	) {
+		const invitation = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		return {
+			id: invitation.id,
+			group: await UserGroups.pack(invitation.userGroup || invitation.userGroupId),
+		};
+	}
+
+	public packMany(
+		invitations: any[],
+	) {
+		return Promise.all(invitations.map(x => this.pack(x)));
+	}
+}

packages/backend/src/models/repositories/user-group.ts

@@ -0,0 +1,61 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { UserGroup } from '@/models/entities/user-group';
+import { UserGroupJoinings } from '../index';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(UserGroup)
+export class UserGroupRepository extends Repository<UserGroup> {
+	public async pack(
+		src: UserGroup['id'] | UserGroup,
+	): Promise<Packed<'UserGroup'>> {
+		const userGroup = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		const users = await UserGroupJoinings.find({
+			userGroupId: userGroup.id
+		});
+
+		return {
+			id: userGroup.id,
+			createdAt: userGroup.createdAt.toISOString(),
+			name: userGroup.name,
+			ownerId: userGroup.userId,
+			userIds: users.map(x => x.userId)
+		};
+	}
+}
+
+export const packedUserGroupSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		ownerId: {
+			type: 'string' as const,
+			nullable: false as const, optional: false as const,
+			format: 'id',
+		},
+		userIds: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const,
+			items: {
+				type: 'string' as const,
+				nullable: false as const, optional: false as const,
+				format: 'id',
+			}
+		},
+	},
+};

packages/backend/src/models/repositories/user-list.ts

@@ -0,0 +1,55 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { UserList } from '@/models/entities/user-list';
+import { UserListJoinings } from '../index';
+import { Packed } from '@/misc/schema';
+
+@EntityRepository(UserList)
+export class UserListRepository extends Repository<UserList> {
+	public async pack(
+		src: UserList['id'] | UserList,
+	): Promise<Packed<'UserList'>> {
+		const userList = typeof src === 'object' ? src : await this.findOneOrFail(src);
+
+		const users = await UserListJoinings.find({
+			userListId: userList.id
+		});
+
+		return {
+			id: userList.id,
+			createdAt: userList.createdAt.toISOString(),
+			name: userList.name,
+			userIds: users.map(x => x.userId)
+		};
+	}
+}
+
+export const packedUserListSchema = {
+	type: 'object' as const,
+	optional: false as const, nullable: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		createdAt: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+			format: 'date-time',
+		},
+		name: {
+			type: 'string' as const,
+			optional: false as const, nullable: false as const,
+		},
+		userIds: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const,
+			items: {
+				type: 'string' as const,
+				nullable: false as const, optional: false as const,
+				format: 'id',
+			}
+		},
+	},
+};

packages/backend/src/models/repositories/user.ts

@@ -0,0 +1,659 @@
+import $ from 'cafy';
+import { EntityRepository, Repository, In, Not } from 'typeorm';
+import { User, ILocalUser, IRemoteUser } from '@/models/entities/user';
+import { Notes, NoteUnreads, FollowRequests, Notifications, MessagingMessages, UserNotePinings, Followings, Blockings, Mutings, UserProfiles, UserSecurityKeys, UserGroupJoinings, Pages, Announcements, AnnouncementReads, Antennas, AntennaNotes, ChannelFollowings, Instances } from '../index';
+import config from '@/config/index';
+import { Packed } from '@/misc/schema';
+import { awaitAll } from '@/prelude/await-all';
+import { populateEmojis } from '@/misc/populate-emojis';
+import { getAntennas } from '@/misc/antenna-cache';
+import { USER_ACTIVE_THRESHOLD, USER_ONLINE_THRESHOLD } from '@/const';
+
+@EntityRepository(User)
+export class UserRepository extends Repository<User> {
+	public async getRelation(me: User['id'], target: User['id']) {
+		const [following1, following2, followReq1, followReq2, toBlocking, fromBlocked, mute] = await Promise.all([
+			Followings.findOne({
+				followerId: me,
+				followeeId: target
+			}),
+			Followings.findOne({
+				followerId: target,
+				followeeId: me
+			}),
+			FollowRequests.findOne({
+				followerId: me,
+				followeeId: target
+			}),
+			FollowRequests.findOne({
+				followerId: target,
+				followeeId: me
+			}),
+			Blockings.findOne({
+				blockerId: me,
+				blockeeId: target
+			}),
+			Blockings.findOne({
+				blockerId: target,
+				blockeeId: me
+			}),
+			Mutings.findOne({
+				muterId: me,
+				muteeId: target
+			})
+		]);
+
+		return {
+			id: target,
+			isFollowing: following1 != null,
+			hasPendingFollowRequestFromYou: followReq1 != null,
+			hasPendingFollowRequestToYou: followReq2 != null,
+			isFollowed: following2 != null,
+			isBlocking: toBlocking != null,
+			isBlocked: fromBlocked != null,
+			isMuted: mute != null
+		};
+	}
+
+	public async getHasUnreadMessagingMessage(userId: User['id']): Promise<boolean> {
+		const mute = await Mutings.find({
+			muterId: userId
+		});
+
+		const joinings = await UserGroupJoinings.find({ userId: userId });
+
+		const groupQs = Promise.all(joinings.map(j => MessagingMessages.createQueryBuilder('message')
+			.where(`message.groupId = :groupId`, { groupId: j.userGroupId })
+			.andWhere('message.userId != :userId', { userId: userId })
+			.andWhere('NOT (:userId = ANY(message.reads))', { userId: userId })
+			.andWhere('message.createdAt > :joinedAt', { joinedAt: j.createdAt }) // 自分が加入する前の会話については、未読扱いしない
+			.getOne().then(x => x != null)));
+
+		const [withUser, withGroups] = await Promise.all([
+			MessagingMessages.count({
+				where: {
+					recipientId: userId,
+					isRead: false,
+					...(mute.length > 0 ? { userId: Not(In(mute.map(x => x.muteeId))) } : {}),
+				},
+				take: 1
+			}).then(count => count > 0),
+			groupQs
+		]);
+
+		return withUser || withGroups.some(x => x);
+	}
+
+	public async getHasUnreadAnnouncement(userId: User['id']): Promise<boolean> {
+		const reads = await AnnouncementReads.find({
+			userId: userId
+		});
+
+		const count = await Announcements.count(reads.length > 0 ? {
+			id: Not(In(reads.map(read => read.announcementId)))
+		} : {});
+
+		return count > 0;
+	}
+
+	public async getHasUnreadAntenna(userId: User['id']): Promise<boolean> {
+		const myAntennas = (await getAntennas()).filter(a => a.userId === userId);
+
+		const unread = myAntennas.length > 0 ? await AntennaNotes.findOne({
+			antennaId: In(myAntennas.map(x => x.id)),
+			read: false
+		}) : null;
+
+		return unread != null;
+	}
+
+	public async getHasUnreadChannel(userId: User['id']): Promise<boolean> {
+		const channels = await ChannelFollowings.find({ followerId: userId });
+
+		const unread = channels.length > 0 ? await NoteUnreads.findOne({
+			userId: userId,
+			noteChannelId: In(channels.map(x => x.followeeId)),
+		}) : null;
+
+		return unread != null;
+	}
+
+	public async getHasUnreadNotification(userId: User['id']): Promise<boolean> {
+		const mute = await Mutings.find({
+			muterId: userId
+		});
+		const mutedUserIds = mute.map(m => m.muteeId);
+
+		const count = await Notifications.count({
+			where: {
+				notifieeId: userId,
+				...(mutedUserIds.length > 0 ? { notifierId: Not(In(mutedUserIds)) } : {}),
+				isRead: false
+			},
+			take: 1
+		});
+
+		return count > 0;
+	}
+
+	public async getHasPendingReceivedFollowRequest(userId: User['id']): Promise<boolean> {
+		const count = await FollowRequests.count({
+			followeeId: userId
+		});
+
+		return count > 0;
+	}
+
+	public getOnlineStatus(user: User): string {
+		if (user.hideOnlineStatus) return 'unknown';
+		if (user.lastActiveDate == null) return 'unknown';
+		const elapsed = Date.now() - user.lastActiveDate.getTime();
+		return (
+			elapsed < USER_ONLINE_THRESHOLD ? 'online' :
+			elapsed < USER_ACTIVE_THRESHOLD ? 'active' :
+			'offline'
+		);
+	}
+
+	public getAvatarUrl(user: User): string {
+		if (user.avatarUrl) {
+			return user.avatarUrl;
+		} else {
+			return `${config.url}/random-avatar/${user.id}`;
+		}
+	}
+
+	public async pack(
+		src: User['id'] | User,
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			detail?: boolean,
+			includeSecrets?: boolean,
+		}
+	): Promise<Packed<'User'>> {
+		const opts = Object.assign({
+			detail: false,
+			includeSecrets: false
+		}, options);
+
+		const user = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const meId = me ? me.id : null;
+
+		const relation = meId && (meId !== user.id) && opts.detail ? await this.getRelation(meId, user.id) : null;
+		const pins = opts.detail ? await UserNotePinings.createQueryBuilder('pin')
+			.where('pin.userId = :userId', { userId: user.id })
+			.innerJoinAndSelect('pin.note', 'note')
+			.orderBy('pin.id', 'DESC')
+			.getMany() : [];
+		const profile = opts.detail ? await UserProfiles.findOneOrFail(user.id) : null;
+
+		const followingCount = profile == null ? null :
+			(profile.ffVisibility === 'public') || (meId === user.id) ? user.followingCount :
+			(profile.ffVisibility === 'followers') && (relation!.isFollowing) ? user.followingCount :
+			null;
+
+		const followersCount = profile == null ? null :
+			(profile.ffVisibility === 'public') || (meId === user.id) ? user.followersCount :
+			(profile.ffVisibility === 'followers') && (relation!.isFollowing) ? user.followersCount :
+			null;
+
+		const falsy = opts.detail ? false : undefined;
+
+		const packed = {
+			id: user.id,
+			name: user.name,
+			username: user.username,
+			host: user.host,
+			avatarUrl: this.getAvatarUrl(user),
+			avatarBlurhash: user.avatarBlurhash,
+			avatarColor: null, // 後方互換性のため
+			isAdmin: user.isAdmin || falsy,
+			isModerator: user.isModerator || falsy,
+			isBot: user.isBot || falsy,
+			isCat: user.isCat || falsy,
+			instance: user.host ? Instances.findOne({ host: user.host }).then(instance => instance ? {
+				name: instance.name,
+				softwareName: instance.softwareName,
+				softwareVersion: instance.softwareVersion,
+				iconUrl: instance.iconUrl,
+				faviconUrl: instance.faviconUrl,
+				themeColor: instance.themeColor,
+			} : undefined) : undefined,
+			emojis: populateEmojis(user.emojis, user.host),
+			onlineStatus: this.getOnlineStatus(user),
+
+			...(opts.detail ? {
+				url: profile!.url,
+				uri: user.uri,
+				createdAt: user.createdAt.toISOString(),
+				updatedAt: user.updatedAt ? user.updatedAt.toISOString() : null,
+				lastFetchedAt: user.lastFetchedAt?.toISOString(),
+				bannerUrl: user.bannerUrl,
+				bannerBlurhash: user.bannerBlurhash,
+				bannerColor: null, // 後方互換性のため
+				isLocked: user.isLocked,
+				isModerator: user.isModerator || falsy,
+				isSilenced: user.isSilenced || falsy,
+				isSuspended: user.isSuspended || falsy,
+				description: profile!.description,
+				location: profile!.location,
+				birthday: profile!.birthday,
+				lang: profile!.lang,
+				fields: profile!.fields,
+				followersCount: followersCount || 0,
+				followingCount: followingCount || 0,
+				notesCount: user.notesCount,
+				pinnedNoteIds: pins.map(pin => pin.noteId),
+				pinnedNotes: Notes.packMany(pins.map(pin => pin.note!), me, {
+					detail: true
+				}),
+				pinnedPageId: profile!.pinnedPageId,
+				pinnedPage: profile!.pinnedPageId ? Pages.pack(profile!.pinnedPageId, me) : null,
+				publicReactions: profile!.publicReactions,
+				ffVisibility: profile!.ffVisibility,
+				twoFactorEnabled: profile!.twoFactorEnabled,
+				usePasswordLessLogin: profile!.usePasswordLessLogin,
+				securityKeys: profile!.twoFactorEnabled
+					? UserSecurityKeys.count({
+						userId: user.id
+					}).then(result => result >= 1)
+					: false,
+			} : {}),
+
+			...(opts.detail && meId === user.id ? {
+				avatarId: user.avatarId,
+				bannerId: user.bannerId,
+				injectFeaturedNote: profile!.injectFeaturedNote,
+				receiveAnnouncementEmail: profile!.receiveAnnouncementEmail,
+				alwaysMarkNsfw: profile!.alwaysMarkNsfw,
+				carefulBot: profile!.carefulBot,
+				autoAcceptFollowed: profile!.autoAcceptFollowed,
+				noCrawle: profile!.noCrawle,
+				isExplorable: user.isExplorable,
+				isDeleted: user.isDeleted,
+				hideOnlineStatus: user.hideOnlineStatus,
+				hasUnreadSpecifiedNotes: NoteUnreads.count({
+					where: { userId: user.id, isSpecified: true },
+					take: 1
+				}).then(count => count > 0),
+				hasUnreadMentions: NoteUnreads.count({
+					where: { userId: user.id, isMentioned: true },
+					take: 1
+				}).then(count => count > 0),
+				hasUnreadAnnouncement: this.getHasUnreadAnnouncement(user.id),
+				hasUnreadAntenna: this.getHasUnreadAntenna(user.id),
+				hasUnreadChannel: this.getHasUnreadChannel(user.id),
+				hasUnreadMessagingMessage: this.getHasUnreadMessagingMessage(user.id),
+				hasUnreadNotification: this.getHasUnreadNotification(user.id),
+				hasPendingReceivedFollowRequest: this.getHasPendingReceivedFollowRequest(user.id),
+				integrations: profile!.integrations,
+				mutedWords: profile!.mutedWords,
+				mutingNotificationTypes: profile!.mutingNotificationTypes,
+				emailNotificationTypes: profile!.emailNotificationTypes,
+			} : {}),
+
+			...(opts.includeSecrets ? {
+				email: profile!.email,
+				emailVerified: profile!.emailVerified,
+				securityKeysList: profile!.twoFactorEnabled
+					? UserSecurityKeys.find({
+						where: {
+							userId: user.id
+						},
+						select: ['id', 'name', 'lastUsed']
+					})
+					: []
+			} : {}),
+
+			...(relation ? {
+				isFollowing: relation.isFollowing,
+				isFollowed: relation.isFollowed,
+				hasPendingFollowRequestFromYou: relation.hasPendingFollowRequestFromYou,
+				hasPendingFollowRequestToYou: relation.hasPendingFollowRequestToYou,
+				isBlocking: relation.isBlocking,
+				isBlocked: relation.isBlocked,
+				isMuted: relation.isMuted,
+			} : {})
+		};
+
+		return await awaitAll(packed);
+	}
+
+	public packMany(
+		users: (User['id'] | User)[],
+		me?: { id: User['id'] } | null | undefined,
+		options?: {
+			detail?: boolean,
+			includeSecrets?: boolean,
+		}
+	) {
+		return Promise.all(users.map(u => this.pack(u, me, options)));
+	}
+
+	public isLocalUser(user: User): user is ILocalUser;
+	public isLocalUser<T extends { host: User['host'] }>(user: T): user is T & { host: null; };
+	public isLocalUser(user: User | { host: User['host'] }): boolean {
+		return user.host == null;
+	}
+
+	public isRemoteUser(user: User): user is IRemoteUser;
+	public isRemoteUser<T extends { host: User['host'] }>(user: T): user is T & { host: string; };
+	public isRemoteUser(user: User | { host: User['host'] }): boolean {
+		return !this.isLocalUser(user);
+	}
+
+	//#region Validators
+	public validateLocalUsername = $.str.match(/^\w{1,20}$/);
+	public validatePassword = $.str.min(1);
+	public validateName = $.str.min(1).max(50);
+	public validateDescription = $.str.min(1).max(500);
+	public validateLocation = $.str.min(1).max(50);
+	public validateBirthday = $.str.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/);
+	//#endregion
+}
+
+export const packedUserSchema = {
+	type: 'object' as const,
+	nullable: false as const, optional: false as const,
+	properties: {
+		id: {
+			type: 'string' as const,
+			nullable: false as const, optional: false as const,
+			format: 'id',
+			example: 'xxxxxxxxxx',
+		},
+		name: {
+			type: 'string' as const,
+			nullable: true as const, optional: false as const,
+			example: '藍'
+		},
+		username: {
+			type: 'string' as const,
+			nullable: false as const, optional: false as const,
+			example: 'ai'
+		},
+		host: {
+			type: 'string' as const,
+			nullable: true as const, optional: false as const,
+			example: 'misskey.example.com'
+		},
+		avatarUrl: {
+			type: 'string' as const,
+			format: 'url',
+			nullable: true as const, optional: false as const,
+		},
+		avatarBlurhash: {
+			type: 'any' as const,
+			nullable: true as const, optional: false as const,
+		},
+		avatarColor: {
+			type: 'any' as const,
+			nullable: true as const, optional: false as const,
+			default: null
+		},
+		isAdmin: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+			default: false
+		},
+		isModerator: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+			default: false
+		},
+		isBot: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		isCat: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		emojis: {
+			type: 'array' as const,
+			nullable: false as const, optional: false as const,
+			items: {
+				type: 'object' as const,
+				nullable: false as const, optional: false as const,
+				properties: {
+					name: {
+						type: 'string' as const,
+						nullable: false as const, optional: false as const
+					},
+					url: {
+						type: 'string' as const,
+						nullable: false as const, optional: false as const,
+						format: 'url'
+					},
+				}
+			}
+		},
+		url: {
+			type: 'string' as const,
+			format: 'url',
+			nullable: true as const, optional: true as const,
+		},
+		createdAt: {
+			type: 'string' as const,
+			nullable: false as const, optional: true as const,
+			format: 'date-time',
+		},
+		updatedAt: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const,
+			format: 'date-time',
+		},
+		bannerUrl: {
+			type: 'string' as const,
+			format: 'url',
+			nullable: true as const, optional: true as const,
+		},
+		bannerBlurhash: {
+			type: 'any' as const,
+			nullable: true as const, optional: true as const,
+		},
+		bannerColor: {
+			type: 'any' as const,
+			nullable: true as const, optional: true as const,
+			default: null
+		},
+		isLocked: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		isSuspended: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+			example: false
+		},
+		description: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const,
+			example: 'Hi masters, I am Ai!'
+		},
+		location: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const,
+		},
+		birthday: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const,
+			example: '2018-03-12'
+		},
+		fields: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const,
+			items: {
+				type: 'object' as const,
+				nullable: false as const, optional: false as const,
+				properties: {
+					name: {
+						type: 'string' as const,
+						nullable: false as const, optional: false as const
+					},
+					value: {
+						type: 'string' as const,
+						nullable: false as const, optional: false as const
+					}
+				},
+				maxLength: 4
+			}
+		},
+		followersCount: {
+			type: 'number' as const,
+			nullable: false as const, optional: true as const,
+		},
+		followingCount: {
+			type: 'number' as const,
+			nullable: false as const, optional: true as const,
+		},
+		notesCount: {
+			type: 'number' as const,
+			nullable: false as const, optional: true as const,
+		},
+		pinnedNoteIds: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const,
+			items: {
+				type: 'string' as const,
+				nullable: false as const, optional: false as const,
+				format: 'id',
+			}
+		},
+		pinnedNotes: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const,
+			items: {
+				type: 'object' as const,
+				nullable: false as const, optional: false as const,
+				ref: 'Note' as const,
+			}
+		},
+		pinnedPageId: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const
+		},
+		pinnedPage: {
+			type: 'object' as const,
+			nullable: true as const, optional: true as const,
+			ref: 'Page' as const,
+		},
+		twoFactorEnabled: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+			default: false
+		},
+		usePasswordLessLogin: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+			default: false
+		},
+		securityKeys: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+			default: false
+		},
+		avatarId: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const,
+			format: 'id'
+		},
+		bannerId: {
+			type: 'string' as const,
+			nullable: true as const, optional: true as const,
+			format: 'id'
+		},
+		autoWatch: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const
+		},
+		injectFeaturedNote: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const
+		},
+		alwaysMarkNsfw: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const
+		},
+		carefulBot: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const
+		},
+		autoAcceptFollowed: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const
+		},
+		hasUnreadSpecifiedNotes: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasUnreadMentions: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasUnreadAnnouncement: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasUnreadAntenna: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasUnreadChannel: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasUnreadMessagingMessage: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasUnreadNotification: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		hasPendingReceivedFollowRequest: {
+			type: 'boolean' as const,
+			nullable: false as const, optional: true as const,
+		},
+		integrations: {
+			type: 'object' as const,
+			nullable: false as const, optional: true as const
+		},
+		mutedWords: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const
+		},
+		mutingNotificationTypes: {
+			type: 'array' as const,
+			nullable: false as const, optional: true as const
+		},
+		isFollowing: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		},
+		hasPendingFollowRequestFromYou: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		},
+		hasPendingFollowRequestToYou: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		},
+		isFollowed: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		},
+		isBlocking: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		},
+		isBlocked: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		},
+		isMuted: {
+			type: 'boolean' as const,
+			optional: true as const, nullable: false as const
+		}
+	},
+};