refactor: migrate to typeorm 3.0 (#8443)

* wip * wip * wip * Update following.ts * wip * wip * wip * Update resolve-user.ts * maxQueryExecutionTime * wip * wip
2024-11-27 14:28:49 +09:00 · 2022-03-26 15:34:00 +09:00 · 2022-03-26 15:34:00 +09:00 · 1c67c26bd8
commit 1c67c26bd8
parent 41c87074e6
325 changed files with 1314 additions and 1494 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -198,11 +198,13 @@ MongoDBの時とは違い、findOneでレコードを取得する時に対象レ
 MongoDBは`null`で返してきてたので、その感覚で`if (x === null)`とか書くとバグる。代わりに`if (x == null)`と書いてください

 ### Migration作成方法
-```
-npx ts-node ./node_modules/typeorm/cli.js migration:generate -n 変更の名前 -o
+packages/backendで:
+```sh
+npx typeorm migration:generate -d ormconfig.js -o <migration name>
 ```

-作成されたスクリプトは不必要な変更を含むため除去してください。
+- 生成後、ファイルをmigration下に移してください
+- 作成されたスクリプトは不必要な変更を含むため除去してください

 ### コネクションには`markRaw`せよ
 **Vueのコンポーネントのdataオプションとして**misskey.jsのコネクションを設定するとき、必ず`markRaw`でラップしてください。インスタンスが不必要にリアクティブ化されることで、misskey.js内の処理で不具合が発生するとともに、パフォーマンス上の問題にも繋がる。なお、Composition APIを使う場合はこの限りではない(リアクティブ化はマニュアルなため)。
--- a/package.json
+++ b/package.json
@ -13,8 +13,7 @@
 		"start": "cd packages/backend && node --experimental-json-modules ./built/index.js",
 		"start:test": "cd packages/backend && cross-env NODE_ENV=test node --experimental-json-modules ./built/index.js",
 		"init": "npm run migrate",
-		"ormconfig": "node ./packages/backend/ormconfig.js",
-		"migrate": "cd packages/backend && npx typeorm migration:run",
+		"migrate": "cd packages/backend && npx typeorm migration:run -d ormconfig.js",
 		"migrateandstart": "npm run migrate && npm run start",
 		"gulp": "gulp build",
 		"watch": "npm run dev",
--- a/packages/backend/ormconfig.js
+++ b/packages/backend/ormconfig.js
@ -1,7 +1,8 @@
+import { DataSource } from 'typeorm';
 import config from './built/config/index.js';
 import { entities } from './built/db/postgre.js';

-export default {
+export default new DataSource({
 	type: 'postgres',
 	host: config.db.host,
 	port: config.db.port,
@ -11,7 +12,4 @@ export default {
 	extra: config.db.extra,
 	entities: entities,
 	migrations: ['migration/*.js'],
-	cli: {
-		migrationsDir: 'migration'
-	}
-};
+});
--- a/packages/backend/package.json
+++ b/packages/backend/package.json
@ -3,7 +3,6 @@
 	"private": true,
 	"type": "module",
 	"scripts": {
-		"init": "npm run migrate",
 		"build": "tsc -p tsconfig.json || echo done. && tsc-alias -p tsconfig.json",
 		"watch": "node watch.mjs",
 		"lint": "eslint --quiet src/**/*.ts",
@ -163,7 +162,7 @@
 		"tsc-alias": "1.4.1",
 		"tsconfig-paths": "3.14.0",
 		"twemoji-parser": "14.0.0",
-		"typeorm": "0.2.45",
+		"typeorm": "0.3.3",
 		"typescript": "4.6.3",
 		"ulid": "2.3.0",
 		"unzipper": "0.10.11",
--- a/packages/backend/src/boot/master.ts
+++ b/packages/backend/src/boot/master.ts
@ -7,7 +7,6 @@ import chalk from 'chalk';
 import chalkTemplate from 'chalk-template';
 import * as portscanner from 'portscanner';
 import semver from 'semver';
-import { getConnection } from 'typeorm';

 import Logger from '@/services/logger.js';
 import loadConfig from '@/config/load.js';
@ -15,7 +14,7 @@ import { Config } from '@/config/types.js';
 import { lessThan } from '@/prelude/array.js';
 import { envOption } from '../env.js';
 import { showMachineInfo } from '@/misc/show-machine-info.js';
-import { initDb } from '../db/postgre.js';
+import { db, initDb } from '../db/postgre.js';

 const _filename = fileURLToPath(import.meta.url);
 const _dirname = dirname(_filename);
@ -144,7 +143,7 @@ async function connectDb(): Promise<void> {
 	try {
 		dbLogger.info('Connecting...');
 		await initDb();
-		const v = await getConnection().query('SHOW server_version').then(x => x[0].server_version);
+		const v = await db.query('SHOW server_version').then(x => x[0].server_version);
 		dbLogger.succ(`Connected: v${v}`);
 	} catch (e) {
 		dbLogger.error('Cannot connect', null, true);
--- a/packages/backend/src/db/postgre.ts
+++ b/packages/backend/src/db/postgre.ts
@ -2,9 +2,10 @@
 import pg from 'pg';
 pg.types.setTypeParser(20, Number);

-import { createConnection, Logger, getConnection } from 'typeorm';
+import { Logger, DataSource } from 'typeorm';
 import * as highlight from 'cli-highlight';
 import config from '@/config/index.js';
+import { envOption } from '../env.js';

 import { dbLogger } from './logger.js';

@ -61,7 +62,6 @@ import { Antenna } from '@/models/entities/antenna.js';
 import { AntennaNote } from '@/models/entities/antenna-note.js';
 import { PromoNote } from '@/models/entities/promo-note.js';
 import { PromoRead } from '@/models/entities/promo-read.js';
-import { envOption } from '../env.js';
 import { Relay } from '@/models/entities/relay.js';
 import { MutedNote } from '@/models/entities/muted-note.js';
 import { Channel } from '@/models/entities/channel.js';
@ -74,7 +74,7 @@ import { UserPending } from '@/models/entities/user-pending.js';

 import { entities as charts } from '@/services/chart/entities.js';

-const sqlLogger = dbLogger.createSubLogger('sql', 'white', false);
+const sqlLogger = dbLogger.createSubLogger('sql', 'gray', false);

 class MyCustomLogger implements Logger {
 	private highlight(sql: string) {
@ -84,10 +84,8 @@ class MyCustomLogger implements Logger {
 	}

 	public logQuery(query: string, parameters?: any[]) {
-		if (envOption.verbose) {
 		sqlLogger.info(this.highlight(query).substring(0, 100));
 	}
-	}

 	public logQueryError(error: string, query: string, parameters?: any[]) {
 		sqlLogger.error(this.highlight(query));
@ -176,17 +174,9 @@ export const entities = [
 	...charts,
 ];

-export function initDb(justBorrow = false, sync = false, forceRecreate = false) {
-	if (!forceRecreate) {
-		try {
-			const conn = getConnection();
-			return Promise.resolve(conn);
-		} catch (e) {}
-	}
+const log = process.env.NODE_ENV !== 'production';

-	const log = process.env.NODE_ENV !== 'production';
-
-	return createConnection({
+export const db = new DataSource({
 	type: 'postgres',
 	host: config.db.host,
 	port: config.db.port,
@ -197,8 +187,8 @@ export function initDb(justBorrow = false, sync = false, forceRecreate = false)
 		statement_timeout: 1000 * 10,
 		...config.db.extra,
 	},
-		synchronize: process.env.NODE_ENV === 'test' || sync,
-		dropSchema: process.env.NODE_ENV === 'test' && !justBorrow,
+	synchronize: process.env.NODE_ENV === 'test',
+	dropSchema: process.env.NODE_ENV === 'test',
 	cache: !config.db.disableCache ? {
 		type: 'redis',
 		options: {
@ -211,20 +201,24 @@ export function initDb(justBorrow = false, sync = false, forceRecreate = false)
 	} : false,
 	logging: log,
 	logger: log ? new MyCustomLogger() : undefined,
+	maxQueryExecutionTime: 300,
 	entities: entities,
-	});
+	migrations: ['../../migration/*.js'],
+});
+
+export async function initDb() {
+	await db.connect();
 }

 export async function resetDb() {
 	const reset = async () => {
-		const conn = await getConnection();
-		const tables = await conn.query(`SELECT relname AS "table"
+		const tables = await db.query(`SELECT relname AS "table"
 		FROM pg_class C LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
 		WHERE nspname NOT IN ('pg_catalog', 'information_schema')
 			AND C.relkind = 'r'
 			AND nspname !~ '^pg_toast';`);
 		for (const table of tables) {
-			await conn.query(`DELETE FROM "${table.table}" CASCADE`);
+			await db.query(`DELETE FROM "${table.table}" CASCADE`);
 		}
 	};

--- a/packages/backend/src/misc/check-hit-antenna.ts
+++ b/packages/backend/src/misc/check-hit-antenna.ts
@ -18,7 +18,7 @@ export async function checkHitAntenna(antenna: Antenna, note: (Note | Packed<'No
 	if (note.visibility === 'specified') return false;

 	// アンテナ作成者がノート作成者にブロックされていたらスキップ
-	const blockings = await blockingCache.fetch(noteUser.id, () => Blockings.find({ blockerId: noteUser.id }).then(res => res.map(x => x.blockeeId)));
+	const blockings = await blockingCache.fetch(noteUser.id, () => Blockings.findBy({ blockerId: noteUser.id }).then(res => res.map(x => x.blockeeId)));
 	if (blockings.some(blocking => blocking === antenna.userId)) return false;

 	if (note.visibility === 'followers') {
@ -32,15 +32,15 @@ export async function checkHitAntenna(antenna: Antenna, note: (Note | Packed<'No
 		if (noteUserFollowers && !noteUserFollowers.includes(antenna.userId)) return false;
 		if (antennaUserFollowing && !antennaUserFollowing.includes(note.userId)) return false;
 	} else if (antenna.src === 'list') {
-		const listUsers = (await UserListJoinings.find({
+		const listUsers = (await UserListJoinings.findBy({
 			userListId: antenna.userListId!,
 		})).map(x => x.userId);

 		if (!listUsers.includes(note.userId)) return false;
 	} else if (antenna.src === 'group') {
-		const joining = await UserGroupJoinings.findOneOrFail(antenna.userGroupJoiningId!);
+		const joining = await UserGroupJoinings.findOneByOrFail({ id: antenna.userGroupJoiningId! });

-		const groupUsers = (await UserGroupJoinings.find({
+		const groupUsers = (await UserGroupJoinings.findBy({
 			userGroupId: joining.userGroupId,
 		})).map(x => x.userId);

--- a/packages/backend/src/misc/fetch-meta.ts
+++ b/packages/backend/src/misc/fetch-meta.ts
@ -1,12 +1,12 @@
+import { db } from '@/db/postgre.js';
 import { Meta } from '@/models/entities/meta.js';
-import { getConnection } from 'typeorm';

 let cache: Meta;

 export async function fetchMeta(noCache = false): Promise<Meta> {
 	if (!noCache && cache) return cache;

-	return await getConnection().transaction(async transactionalEntityManager => {
+	return await db.transaction(async transactionalEntityManager => {
 		// 過去のバグでレコードが複数出来てしまっている可能性があるので新しいIDを優先する
 		const meta = await transactionalEntityManager.findOne(Meta, {
 			order: {
--- a/packages/backend/src/misc/fetch-proxy-account.ts
+++ b/packages/backend/src/misc/fetch-proxy-account.ts
@ -5,5 +5,5 @@ import { Users } from '@/models/index.js';
 export async function fetchProxyAccount(): Promise<ILocalUser | null> {
 	const meta = await fetchMeta();
 	if (meta.proxyAccountId == null) return null;
-	return await Users.findOneOrFail(meta.proxyAccountId) as ILocalUser;
+	return await Users.findOneByOrFail({ id: meta.proxyAccountId }) as ILocalUser;
 }
--- a/packages/backend/src/misc/keypair-store.ts
+++ b/packages/backend/src/misc/keypair-store.ts
@ -6,5 +6,5 @@ import { Cache } from './cache.js';
 const cache = new Cache<UserKeypair>(Infinity);

 export async function getUserKeypair(userId: User['id']): Promise<UserKeypair> {
-	return await cache.fetch(userId, () => UserKeypairs.findOneOrFail(userId));
+	return await cache.fetch(userId, () => UserKeypairs.findOneByOrFail({ userId: userId }));
 }
--- a/packages/backend/src/misc/populate-emojis.ts
+++ b/packages/backend/src/misc/populate-emojis.ts
@ -1,4 +1,4 @@
-import { In } from 'typeorm';
+import { In, IsNull } from 'typeorm';
 import { Emojis } from '@/models/index.js';
 import { Emoji } from '@/models/entities/emoji.js';
 import { Note } from '@/models/entities/note.js';
@ -52,9 +52,9 @@ export async function populateEmoji(emojiName: string, noteUserHost: string | nu
 	const { name, host } = parseEmojiStr(emojiName, noteUserHost);
 	if (name == null) return null;

-	const queryOrNull = async () => (await Emojis.findOne({
+	const queryOrNull = async () => (await Emojis.findOneBy({
 		name,
-		host,
+		host: host ?? IsNull(),
 	})) || null;

 	const emoji = await cache.fetch(`${name} ${host}`, queryOrNull);
@ -112,7 +112,7 @@ export async function prefetchEmojis(emojis: { name: string; host: string | null
 	for (const host of hosts) {
 		emojisQuery.push({
 			name: In(notCachedEmojis.filter(e => e.host === host).map(e => e.name)),
-			host: host,
+			host: host ?? IsNull(),
 		});
 	}
 	const _emojis = emojisQuery.length > 0 ? await Emojis.find({
--- a/packages/backend/src/misc/reaction-lib.ts
+++ b/packages/backend/src/misc/reaction-lib.ts
@ -3,6 +3,7 @@ import { emojiRegex } from './emoji-regex.js';
 import { fetchMeta } from './fetch-meta.js';
 import { Emojis } from '@/models/index.js';
 import { toPunyNullable } from './convert-host.js';
+import { IsNull } from 'typeorm';

 const legacies: Record<string, string> = {
 	'like':     '👍',
@ -74,8 +75,8 @@ export async function toDbReaction(reaction?: string | null, reacterHost?: strin
 	const custom = reaction.match(/^:([\w+-]+)(?:@\.)?:$/);
 	if (custom) {
 		const name = custom[1];
-		const emoji = await Emojis.findOne({
-			host: reacterHost || null,
+		const emoji = await Emojis.findOneBy({
+			host: reacterHost ?? IsNull(),
 			name,
 		});

--- a/packages/backend/src/models/index.ts
+++ b/packages/backend/src/models/index.ts
@ -1,4 +1,6 @@
-import { getRepository, getCustomRepository } from 'typeorm';
+import { } from 'typeorm';
+import { db } from '@/db/postgre.js';
+
 import { Announcement } from './entities/announcement.js';
 import { AnnouncementRead } from './entities/announcement-read.js';
 import { Instance } from './entities/instance.js';
@ -63,65 +65,65 @@ import { PasswordResetRequest } from './entities/password-reset-request.js';
 import { UserPending } from './entities/user-pending.js';
 import { InstanceRepository } from './repositories/instance.js';

-export const Announcements = getRepository(Announcement);
-export const AnnouncementReads = getRepository(AnnouncementRead);
-export const Apps = getCustomRepository(AppRepository);
-export const Notes = getCustomRepository(NoteRepository);
-export const NoteFavorites = getCustomRepository(NoteFavoriteRepository);
-export const NoteWatchings = getRepository(NoteWatching);
-export const NoteThreadMutings = getRepository(NoteThreadMuting);
-export const NoteReactions = getCustomRepository(NoteReactionRepository);
-export const NoteUnreads = getRepository(NoteUnread);
-export const Polls = getRepository(Poll);
-export const PollVotes = getRepository(PollVote);
-export const Users = getCustomRepository(UserRepository);
-export const UserProfiles = getRepository(UserProfile);
-export const UserKeypairs = getRepository(UserKeypair);
-export const UserPendings = getRepository(UserPending);
-export const AttestationChallenges = getRepository(AttestationChallenge);
-export const UserSecurityKeys = getRepository(UserSecurityKey);
-export const UserPublickeys = getRepository(UserPublickey);
-export const UserLists = getCustomRepository(UserListRepository);
-export const UserListJoinings = getRepository(UserListJoining);
-export const UserGroups = getCustomRepository(UserGroupRepository);
-export const UserGroupJoinings = getRepository(UserGroupJoining);
-export const UserGroupInvitations = getCustomRepository(UserGroupInvitationRepository);
-export const UserNotePinings = getRepository(UserNotePining);
-export const UsedUsernames = getRepository(UsedUsername);
-export const Followings = getCustomRepository(FollowingRepository);
-export const FollowRequests = getCustomRepository(FollowRequestRepository);
-export const Instances = getCustomRepository(InstanceRepository);
-export const Emojis = getCustomRepository(EmojiRepository);
-export const DriveFiles = getCustomRepository(DriveFileRepository);
-export const DriveFolders = getCustomRepository(DriveFolderRepository);
-export const Notifications = getCustomRepository(NotificationRepository);
-export const Metas = getRepository(Meta);
-export const Mutings = getCustomRepository(MutingRepository);
-export const Blockings = getCustomRepository(BlockingRepository);
-export const SwSubscriptions = getRepository(SwSubscription);
-export const Hashtags = getCustomRepository(HashtagRepository);
-export const AbuseUserReports = getCustomRepository(AbuseUserReportRepository);
-export const RegistrationTickets = getRepository(RegistrationTicket);
-export const AuthSessions = getCustomRepository(AuthSessionRepository);
-export const AccessTokens = getRepository(AccessToken);
-export const Signins = getCustomRepository(SigninRepository);
-export const MessagingMessages = getCustomRepository(MessagingMessageRepository);
-export const Pages = getCustomRepository(PageRepository);
-export const PageLikes = getCustomRepository(PageLikeRepository);
-export const GalleryPosts = getCustomRepository(GalleryPostRepository);
-export const GalleryLikes = getCustomRepository(GalleryLikeRepository);
-export const ModerationLogs = getCustomRepository(ModerationLogRepository);
-export const Clips = getCustomRepository(ClipRepository);
-export const ClipNotes = getRepository(ClipNote);
-export const Antennas = getCustomRepository(AntennaRepository);
-export const AntennaNotes = getRepository(AntennaNote);
-export const PromoNotes = getRepository(PromoNote);
-export const PromoReads = getRepository(PromoRead);
-export const Relays = getCustomRepository(RelayRepository);
-export const MutedNotes = getRepository(MutedNote);
-export const Channels = getCustomRepository(ChannelRepository);
-export const ChannelFollowings = getRepository(ChannelFollowing);
-export const ChannelNotePinings = getRepository(ChannelNotePining);
-export const RegistryItems = getRepository(RegistryItem);
-export const Ads = getRepository(Ad);
-export const PasswordResetRequests = getRepository(PasswordResetRequest);
+export const Announcements = db.getRepository(Announcement);
+export const AnnouncementReads = db.getRepository(AnnouncementRead);
+export const Apps = (AppRepository);
+export const Notes = (NoteRepository);
+export const NoteFavorites = (NoteFavoriteRepository);
+export const NoteWatchings = db.getRepository(NoteWatching);
+export const NoteThreadMutings = db.getRepository(NoteThreadMuting);
+export const NoteReactions = (NoteReactionRepository);
+export const NoteUnreads = db.getRepository(NoteUnread);
+export const Polls = db.getRepository(Poll);
+export const PollVotes = db.getRepository(PollVote);
+export const Users = (UserRepository);
+export const UserProfiles = db.getRepository(UserProfile);
+export const UserKeypairs = db.getRepository(UserKeypair);
+export const UserPendings = db.getRepository(UserPending);
+export const AttestationChallenges = db.getRepository(AttestationChallenge);
+export const UserSecurityKeys = db.getRepository(UserSecurityKey);
+export const UserPublickeys = db.getRepository(UserPublickey);
+export const UserLists = (UserListRepository);
+export const UserListJoinings = db.getRepository(UserListJoining);
+export const UserGroups = (UserGroupRepository);
+export const UserGroupJoinings = db.getRepository(UserGroupJoining);
+export const UserGroupInvitations = (UserGroupInvitationRepository);
+export const UserNotePinings = db.getRepository(UserNotePining);
+export const UsedUsernames = db.getRepository(UsedUsername);
+export const Followings = (FollowingRepository);
+export const FollowRequests = (FollowRequestRepository);
+export const Instances = (InstanceRepository);
+export const Emojis = (EmojiRepository);
+export const DriveFiles = (DriveFileRepository);
+export const DriveFolders = (DriveFolderRepository);
+export const Notifications = (NotificationRepository);
+export const Metas = db.getRepository(Meta);
+export const Mutings = (MutingRepository);
+export const Blockings = (BlockingRepository);
+export const SwSubscriptions = db.getRepository(SwSubscription);
+export const Hashtags = (HashtagRepository);
+export const AbuseUserReports = (AbuseUserReportRepository);
+export const RegistrationTickets = db.getRepository(RegistrationTicket);
+export const AuthSessions = (AuthSessionRepository);
+export const AccessTokens = db.getRepository(AccessToken);
+export const Signins = (SigninRepository);
+export const MessagingMessages = (MessagingMessageRepository);
+export const Pages = (PageRepository);
+export const PageLikes = (PageLikeRepository);
+export const GalleryPosts = (GalleryPostRepository);
+export const GalleryLikes = (GalleryLikeRepository);
+export const ModerationLogs = (ModerationLogRepository);
+export const Clips = (ClipRepository);
+export const ClipNotes = db.getRepository(ClipNote);
+export const Antennas = (AntennaRepository);
+export const AntennaNotes = db.getRepository(AntennaNote);
+export const PromoNotes = db.getRepository(PromoNote);
+export const PromoReads = db.getRepository(PromoRead);
+export const Relays = (RelayRepository);
+export const MutedNotes = db.getRepository(MutedNote);
+export const Channels = (ChannelRepository);
+export const ChannelFollowings = db.getRepository(ChannelFollowing);
+export const ChannelNotePinings = db.getRepository(ChannelNotePining);
+export const RegistryItems = db.getRepository(RegistryItem);
+export const Ads = db.getRepository(Ad);
+export const PasswordResetRequests = db.getRepository(PasswordResetRequest);
--- a/packages/backend/src/models/repositories/abuse-user-report.ts
+++ b/packages/backend/src/models/repositories/abuse-user-report.ts
@ -1,14 +1,13 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Users } from '../index.js';
 import { AbuseUserReport } from '@/models/entities/abuse-user-report.js';
 import { awaitAll } from '@/prelude/await-all.js';

-@EntityRepository(AbuseUserReport)
-export class AbuseUserReportRepository extends Repository<AbuseUserReport> {
-	public async pack(
+export const AbuseUserReportRepository = db.getRepository(AbuseUserReport).extend({
+	async pack(
 		src: AbuseUserReport['id'] | AbuseUserReport,
 	) {
-		const report = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const report = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: report.id,
@ -29,11 +28,11 @@ export class AbuseUserReportRepository extends Repository<AbuseUserReport> {
 			}) : null,
 			forwarded: report.forwarded,
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		reports: any[],
 	) {
 		return Promise.all(reports.map(x => this.pack(x)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/antenna.ts
+++ b/packages/backend/src/models/repositories/antenna.ts
@ -1,17 +1,16 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Antenna } from '@/models/entities/antenna.js';
 import { Packed } from '@/misc/schema.js';
 import { AntennaNotes, UserGroupJoinings } from '../index.js';

-@EntityRepository(Antenna)
-export class AntennaRepository extends Repository<Antenna> {
-	public async pack(
+export const AntennaRepository = db.getRepository(Antenna).extend({
+	async pack(
 		src: Antenna['id'] | Antenna,
 	): Promise<Packed<'Antenna'>> {
-		const antenna = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const antenna = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

-		const hasUnreadNote = (await AntennaNotes.findOne({ antennaId: antenna.id, read: false })) != null;
-		const userGroupJoining = antenna.userGroupJoiningId ? await UserGroupJoinings.findOne(antenna.userGroupJoiningId) : null;
+		const hasUnreadNote = (await AntennaNotes.findOneBy({ antennaId: antenna.id, read: false })) != null;
+		const userGroupJoining = antenna.userGroupJoiningId ? await UserGroupJoinings.findOneBy({ id: antenna.userGroupJoiningId }) : null;

 		return {
 			id: antenna.id,
@ -29,5 +28,5 @@ export class AntennaRepository extends Repository<Antenna> {
 			withFile: antenna.withFile,
 			hasUnreadNote,
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/app.ts
+++ b/packages/backend/src/models/repositories/app.ts
@ -1,12 +1,11 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { App } from '@/models/entities/app.js';
 import { AccessTokens } from '../index.js';
 import { Packed } from '@/misc/schema.js';
 import { User } from '../entities/user.js';

-@EntityRepository(App)
-export class AppRepository extends Repository<App> {
-	public async pack(
+export const AppRepository = db.getRepository(App).extend({
+	async pack(
 		src: App['id'] | App,
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -21,7 +20,7 @@ export class AppRepository extends Repository<App> {
 			includeProfileImageIds: false,
 		}, options);

-		const app = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const app = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: app.id,
@ -30,11 +29,11 @@ export class AppRepository extends Repository<App> {
 			permission: app.permission,
 			...(opts.includeSecret ? { secret: app.secret } : {}),
 			...(me ? {
-				isAuthorized: await AccessTokens.count({
+				isAuthorized: await AccessTokens.countBy({
 					appId: app.id,
 					userId: me.id,
 				}).then(count => count > 0),
 			} : {}),
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/auth-session.ts
+++ b/packages/backend/src/models/repositories/auth-session.ts
@ -1,21 +1,20 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Apps } from '../index.js';
 import { AuthSession } from '@/models/entities/auth-session.js';
 import { awaitAll } from '@/prelude/await-all.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(AuthSession)
-export class AuthSessionRepository extends Repository<AuthSession> {
-	public async pack(
+export const AuthSessionRepository = db.getRepository(AuthSession).extend({
+	async pack(
 		src: AuthSession['id'] | AuthSession,
 		me?: { id: User['id'] } | null | undefined
 	) {
-		const session = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const session = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: session.id,
 			app: Apps.pack(session.appId, me),
 			token: session.token,
 		});
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/blocking.ts
+++ b/packages/backend/src/models/repositories/blocking.ts
@ -1,17 +1,16 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Users } from '../index.js';
 import { Blocking } from '@/models/entities/blocking.js';
 import { awaitAll } from '@/prelude/await-all.js';
 import { Packed } from '@/misc/schema.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(Blocking)
-export class BlockingRepository extends Repository<Blocking> {
-	public async pack(
+export const BlockingRepository = db.getRepository(Blocking).extend({
+	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);
+		const blocking = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: blocking.id,
@ -21,12 +20,12 @@ export class BlockingRepository extends Repository<Blocking> {
 				detail: true,
 			}),
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		blockings: any[],
 		me: { id: User['id'] }
 	) {
 		return Promise.all(blockings.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/channel.ts
+++ b/packages/backend/src/models/repositories/channel.ts
@ -1,23 +1,22 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Channel } from '@/models/entities/channel.js';
 import { Packed } from '@/misc/schema.js';
 import { DriveFiles, ChannelFollowings, NoteUnreads } from '../index.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(Channel)
-export class ChannelRepository extends Repository<Channel> {
-	public async pack(
+export const ChannelRepository = db.getRepository(Channel).extend({
+	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 channel = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });
 		const meId = me ? me.id : null;

-		const banner = channel.bannerId ? await DriveFiles.findOne(channel.bannerId) : null;
+		const banner = channel.bannerId ? await DriveFiles.findOneBy({ id: channel.bannerId }) : null;

-		const hasUnreadNote = meId ? (await NoteUnreads.findOne({ noteChannelId: channel.id, userId: meId })) != null : undefined;
+		const hasUnreadNote = meId ? (await NoteUnreads.findOneBy({ noteChannelId: channel.id, userId: meId })) != null : undefined;

-		const following = meId ? await ChannelFollowings.findOne({
+		const following = meId ? await ChannelFollowings.findOneBy({
 			followerId: meId,
 			followeeId: channel.id,
 		}) : null;
@ -38,5 +37,5 @@ export class ChannelRepository extends Repository<Channel> {
 				hasUnreadNote,
 			} : {}),
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/clip.ts
+++ b/packages/backend/src/models/repositories/clip.ts
@ -1,15 +1,14 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Clip } from '@/models/entities/clip.js';
 import { Packed } from '@/misc/schema.js';
 import { Users } from '../index.js';
 import { awaitAll } from '@/prelude/await-all.js';

-@EntityRepository(Clip)
-export class ClipRepository extends Repository<Clip> {
-	public async pack(
+export const ClipRepository = db.getRepository(Clip).extend({
+	async pack(
 		src: Clip['id'] | Clip,
 	): Promise<Packed<'Clip'>> {
-		const clip = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const clip = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: clip.id,
@ -20,12 +19,12 @@ export class ClipRepository extends Repository<Clip> {
 			description: clip.description,
 			isPublic: clip.isPublic,
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		clips: Clip[],
 	) {
 		return Promise.all(clips.map(x => this.pack(x)));
-	}
-}
+	},
+});

--- a/packages/backend/src/models/repositories/drive-file.ts
+++ b/packages/backend/src/models/repositories/drive-file.ts
@ -1,4 +1,4 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { DriveFile } from '@/models/entities/drive-file.js';
 import { Users, DriveFolders } from '../index.js';
 import { User } from '@/models/entities/user.js';
@ -16,9 +16,8 @@ type PackOptions = {
 	withUser?: boolean,
 };

-@EntityRepository(DriveFile)
-export class DriveFileRepository extends Repository<DriveFile> {
-	public validateFileName(name: string): boolean {
+export const DriveFileRepository = db.getRepository(DriveFile).extend({
+	validateFileName(name: string): boolean {
 		return (
 			(name.trim().length > 0) &&
 			(name.length <= 200) &&
@ -26,9 +25,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			(name.indexOf('/') === -1) &&
 			(name.indexOf('..') === -1)
 		);
-	}
+	},

-	public getPublicProperties(file: DriveFile): DriveFile['properties'] {
+	getPublicProperties(file: DriveFile): DriveFile['properties'] {
 		if (file.properties.orientation != null) {
 			const properties = JSON.parse(JSON.stringify(file.properties));
 			if (file.properties.orientation >= 5) {
@ -39,9 +38,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 		}

 		return file.properties;
-	}
+	},

-	public getPublicUrl(file: DriveFile, thumbnail = false): string | null {
+	getPublicUrl(file: DriveFile, thumbnail = false): string | null {
 		// リモートかつメディアプロキシ
 		if (file.uri != null && file.userHost != null && config.mediaProxy != null) {
 			return appendQuery(config.mediaProxy, query({
@ -62,9 +61,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 		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> {
+	async calcDriveUsageOf(user: User['id'] | { id: User['id'] }): Promise<number> {
 		const id = typeof user === 'object' ? user.id : user;

 		const { sum } = await this
@ -75,9 +74,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			.getRawOne();

 		return parseInt(sum, 10) || 0;
-	}
+	},

-	public async calcDriveUsageOfHost(host: string): Promise<number> {
+	async calcDriveUsageOfHost(host: string): Promise<number> {
 		const { sum } = await this
 			.createQueryBuilder('file')
 			.where('file.userHost = :host', { host: toPuny(host) })
@ -86,9 +85,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			.getRawOne();

 		return parseInt(sum, 10) || 0;
-	}
+	},

-	public async calcDriveUsageOfLocal(): Promise<number> {
+	async calcDriveUsageOfLocal(): Promise<number> {
 		const { sum } = await this
 			.createQueryBuilder('file')
 			.where('file.userHost IS NULL')
@ -97,9 +96,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			.getRawOne();

 		return parseInt(sum, 10) || 0;
-	}
+	},

-	public async calcDriveUsageOfRemote(): Promise<number> {
+	async calcDriveUsageOfRemote(): Promise<number> {
 		const { sum } = await this
 			.createQueryBuilder('file')
 			.where('file.userHost IS NOT NULL')
@ -108,11 +107,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			.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(
+	async pack(
 		src: DriveFile['id'] | DriveFile,
 		options?: PackOptions
 	): Promise<Packed<'DriveFile'> | null> {
@ -121,11 +118,9 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			self: false,
 		}, options);

-		const file = typeof src === 'object' ? src : await this.findOne(src);
+		const file = typeof src === 'object' ? src : await this.findOneBy({ id: src });
 		if (file == null) return null;

-		const meta = await fetchMeta();
-
 		return await awaitAll<Packed<'DriveFile'>>({
 			id: file.id,
 			createdAt: file.createdAt.toISOString(),
@ -146,13 +141,13 @@ export class DriveFileRepository extends Repository<DriveFile> {
 			userId: opts.withUser ? file.userId : null,
 			user: (opts.withUser && file.userId) ? Users.pack(file.userId) : null,
 		});
-	}
+	},

-	public async packMany(
+	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);
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/drive-folder.ts
+++ b/packages/backend/src/models/repositories/drive-folder.ts
@ -1,12 +1,11 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { DriveFolders, DriveFiles } from '../index.js';
 import { DriveFolder } from '@/models/entities/drive-folder.js';
 import { awaitAll } from '@/prelude/await-all.js';
 import { Packed } from '@/misc/schema.js';

-@EntityRepository(DriveFolder)
-export class DriveFolderRepository extends Repository<DriveFolder> {
-	public async pack(
+export const DriveFolderRepository = db.getRepository(DriveFolder).extend({
+	async pack(
 		src: DriveFolder['id'] | DriveFolder,
 		options?: {
 			detail: boolean
@ -16,7 +15,7 @@ export class DriveFolderRepository extends Repository<DriveFolder> {
 			detail: false,
 		}, options);

-		const folder = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const folder = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: folder.id,
@ -25,10 +24,10 @@ export class DriveFolderRepository extends Repository<DriveFolder> {
 			parentId: folder.parentId,

 			...(opts.detail ? {
-				foldersCount: DriveFolders.count({
+				foldersCount: DriveFolders.countBy({
 					parentId: folder.id,
 				}),
-				filesCount: DriveFiles.count({
+				filesCount: DriveFiles.countBy({
 					folderId: folder.id,
 				}),

@ -39,5 +38,5 @@ export class DriveFolderRepository extends Repository<DriveFolder> {
 				} : {}),
 			} : {}),
 		});
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/emoji.ts
+++ b/packages/backend/src/models/repositories/emoji.ts
@ -1,13 +1,12 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Emoji } from '@/models/entities/emoji.js';
 import { Packed } from '@/misc/schema.js';

-@EntityRepository(Emoji)
-export class EmojiRepository extends Repository<Emoji> {
-	public async pack(
+export const EmojiRepository = db.getRepository(Emoji).extend({
+	async pack(
 		src: Emoji['id'] | Emoji,
 	): Promise<Packed<'Emoji'>> {
-		const emoji = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const emoji = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: emoji.id,
@ -18,11 +17,11 @@ export class EmojiRepository extends Repository<Emoji> {
 			// || emoji.originalUrl してるのは後方互換性のため
 			url: emoji.publicUrl || emoji.originalUrl,
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		emojis: any[],
 	) {
 		return Promise.all(emojis.map(x => this.pack(x)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/follow-request.ts
+++ b/packages/backend/src/models/repositories/follow-request.ts
@ -1,20 +1,19 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { FollowRequest } from '@/models/entities/follow-request.js';
 import { Users } from '../index.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(FollowRequest)
-export class FollowRequestRepository extends Repository<FollowRequest> {
-	public async pack(
+export const FollowRequestRepository = db.getRepository(FollowRequest).extend({
+	async pack(
 		src: FollowRequest['id'] | FollowRequest,
 		me?: { id: User['id'] } | null | undefined
 	) {
-		const request = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const request = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: request.id,
 			follower: await Users.pack(request.followerId, me),
 			followee: await Users.pack(request.followeeId, me),
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/following.ts
+++ b/packages/backend/src/models/repositories/following.ts
@ -1,4 +1,4 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Users } from '../index.js';
 import { Following } from '@/models/entities/following.js';
 import { awaitAll } from '@/prelude/await-all.js';
@ -29,25 +29,24 @@ type RemoteFolloweeFollowing = Following & {
 	followeeSharedInbox: string;
 };

-@EntityRepository(Following)
-export class FollowingRepository extends Repository<Following> {
-	public isLocalFollower(following: Following): following is LocalFollowerFollowing {
+export const FollowingRepository = db.getRepository(Following).extend({
+	isLocalFollower(following: Following): following is LocalFollowerFollowing {
 		return following.followerHost == null;
-	}
+	},

-	public isRemoteFollower(following: Following): following is RemoteFollowerFollowing {
+	isRemoteFollower(following: Following): following is RemoteFollowerFollowing {
 		return following.followerHost != null;
-	}
+	},

-	public isLocalFollowee(following: Following): following is LocalFolloweeFollowing {
+	isLocalFollowee(following: Following): following is LocalFolloweeFollowing {
 		return following.followeeHost == null;
-	}
+	},

-	public isRemoteFollowee(following: Following): following is RemoteFolloweeFollowing {
+	isRemoteFollowee(following: Following): following is RemoteFolloweeFollowing {
 		return following.followeeHost != null;
-	}
+	},

-	public async pack(
+	async pack(
 		src: Following['id'] | Following,
 		me?: { id: User['id'] } | null | undefined,
 		opts?: {
@ -55,7 +54,7 @@ export class FollowingRepository extends Repository<Following> {
 			populateFollower?: boolean;
 		}
 	): Promise<Packed<'Following'>> {
-		const following = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const following = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		if (opts == null) opts = {};

@ -71,9 +70,9 @@ export class FollowingRepository extends Repository<Following> {
 				detail: true,
 			}) : undefined,
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		followings: any[],
 		me?: { id: User['id'] } | null | undefined,
 		opts?: {
@ -82,5 +81,5 @@ export class FollowingRepository extends Repository<Following> {
 		}
 	) {
 		return Promise.all(followings.map(x => this.pack(x, me, opts)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/gallery-like.ts
+++ b/packages/backend/src/models/repositories/gallery-like.ts
@ -1,25 +1,24 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { GalleryLike } from '@/models/entities/gallery-like.js';
 import { GalleryPosts } from '../index.js';

-@EntityRepository(GalleryLike)
-export class GalleryLikeRepository extends Repository<GalleryLike> {
-	public async pack(
+export const GalleryLikeRepository = db.getRepository(GalleryLike).extend({
+	async pack(
 		src: GalleryLike['id'] | GalleryLike,
 		me?: any
 	) {
-		const like = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const like = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: like.id,
 			post: await GalleryPosts.pack(like.post || like.postId, me),
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		likes: any[],
 		me: any
 	) {
 		return Promise.all(likes.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/gallery-post.ts
+++ b/packages/backend/src/models/repositories/gallery-post.ts
@ -1,18 +1,17 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { GalleryPost } from '@/models/entities/gallery-post.js';
 import { Packed } from '@/misc/schema.js';
 import { Users, DriveFiles, GalleryLikes } from '../index.js';
 import { awaitAll } from '@/prelude/await-all.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(GalleryPost)
-export class GalleryPostRepository extends Repository<GalleryPost> {
-	public async pack(
+export const GalleryPostRepository = db.getRepository(GalleryPost).extend({
+	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);
+		const post = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: post.id,
@ -27,14 +26,14 @@ export class GalleryPostRepository extends Repository<GalleryPost> {
 			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,
+			isLiked: meId ? await GalleryLikes.findOneBy({ postId: post.id, userId: meId }).then(x => x != null) : undefined,
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		posts: GalleryPost[],
 		me?: { id: User['id'] } | null | undefined,
 	) {
 		return Promise.all(posts.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/hashtag.ts
+++ b/packages/backend/src/models/repositories/hashtag.ts
@ -1,10 +1,9 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Hashtag } from '@/models/entities/hashtag.js';
 import { Packed } from '@/misc/schema.js';

-@EntityRepository(Hashtag)
-export class HashtagRepository extends Repository<Hashtag> {
-	public async pack(
+export const HashtagRepository = db.getRepository(Hashtag).extend({
+	async pack(
 		src: Hashtag,
 	): Promise<Packed<'Hashtag'>> {
 		return {
@ -16,11 +15,11 @@ export class HashtagRepository extends Repository<Hashtag> {
 			attachedLocalUsersCount: src.attachedLocalUsersCount,
 			attachedRemoteUsersCount: src.attachedRemoteUsersCount,
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		hashtags: Hashtag[],
 	) {
 		return Promise.all(hashtags.map(x => this.pack(x)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/instance.ts
+++ b/packages/backend/src/models/repositories/instance.ts
@ -1,10 +1,9 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Instance } from '@/models/entities/instance.js';
 import { Packed } from '@/misc/schema.js';

-@EntityRepository(Instance)
-export class InstanceRepository extends Repository<Instance> {
-	public async pack(
+export const InstanceRepository = db.getRepository(Instance).extend({
+	async pack(
 		instance: Instance,
 	): Promise<Packed<'FederationInstance'>> {
 		return {
@ -29,11 +28,11 @@ export class InstanceRepository extends Repository<Instance> {
 			iconUrl: instance.iconUrl,
 			infoUpdatedAt: instance.infoUpdatedAt ? instance.infoUpdatedAt.toISOString() : null,
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		instances: Instance[],
 	) {
 		return Promise.all(instances.map(x => this.pack(x)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/messaging-message.ts
+++ b/packages/backend/src/models/repositories/messaging-message.ts
@ -1,12 +1,11 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { MessagingMessage } from '@/models/entities/messaging-message.js';
 import { Users, DriveFiles, UserGroups } from '../index.js';
 import { Packed } from '@/misc/schema.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(MessagingMessage)
-export class MessagingMessageRepository extends Repository<MessagingMessage> {
-	public async pack(
+export const MessagingMessageRepository = db.getRepository(MessagingMessage).extend({
+	async pack(
 		src: MessagingMessage['id'] | MessagingMessage,
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -19,7 +18,7 @@ export class MessagingMessageRepository extends Repository<MessagingMessage> {
 			populateGroup: true,
 		};

-		const message = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const message = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: message.id,
@ -36,5 +35,5 @@ export class MessagingMessageRepository extends Repository<MessagingMessage> {
 			isRead: message.isRead,
 			reads: message.reads,
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/moderation-logs.ts
+++ b/packages/backend/src/models/repositories/moderation-logs.ts
@ -1,14 +1,13 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Users } from '../index.js';
 import { ModerationLog } from '@/models/entities/moderation-log.js';
 import { awaitAll } from '@/prelude/await-all.js';

-@EntityRepository(ModerationLog)
-export class ModerationLogRepository extends Repository<ModerationLog> {
-	public async pack(
+export const ModerationLogRepository = db.getRepository(ModerationLog).extend({
+	async pack(
 		src: ModerationLog['id'] | ModerationLog,
 	) {
-		const log = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const log = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: log.id,
@ -20,11 +19,11 @@ export class ModerationLogRepository extends Repository<ModerationLog> {
 				detail: true,
 			}),
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		reports: any[],
 	) {
 		return Promise.all(reports.map(x => this.pack(x)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/muting.ts
+++ b/packages/backend/src/models/repositories/muting.ts
@ -1,17 +1,16 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Users } from '../index.js';
 import { Muting } from '@/models/entities/muting.js';
 import { awaitAll } from '@/prelude/await-all.js';
 import { Packed } from '@/misc/schema.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(Muting)
-export class MutingRepository extends Repository<Muting> {
-	public async pack(
+export const MutingRepository = db.getRepository(Muting).extend({
+	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);
+		const muting = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return await awaitAll({
 			id: muting.id,
@ -22,12 +21,12 @@ export class MutingRepository extends Repository<Muting> {
 				detail: true,
 			}),
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		mutings: any[],
 		me: { id: User['id'] }
 	) {
 		return Promise.all(mutings.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/note-favorite.ts
+++ b/packages/backend/src/models/repositories/note-favorite.ts
@ -1,15 +1,14 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { NoteFavorite } from '@/models/entities/note-favorite.js';
 import { Notes } from '../index.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(NoteFavorite)
-export class NoteFavoriteRepository extends Repository<NoteFavorite> {
-	public async pack(
+export const NoteFavoriteRepository = db.getRepository(NoteFavorite).extend({
+	async pack(
 		src: NoteFavorite['id'] | NoteFavorite,
 		me?: { id: User['id'] } | null | undefined
 	) {
-		const favorite = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const favorite = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: favorite.id,
@ -17,12 +16,12 @@ export class NoteFavoriteRepository extends Repository<NoteFavorite> {
 			noteId: favorite.noteId,
 			note: await Notes.pack(favorite.note || favorite.noteId, me),
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		favorites: any[],
 		me: { id: User['id'] }
 	) {
 		return Promise.all(favorites.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/note-reaction.ts
+++ b/packages/backend/src/models/repositories/note-reaction.ts
@ -1,13 +1,12 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { NoteReaction } from '@/models/entities/note-reaction.js';
 import { Notes, Users } from '../index.js';
 import { Packed } from '@/misc/schema.js';
 import { convertLegacyReaction } from '@/misc/reaction-lib.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(NoteReaction)
-export class NoteReactionRepository extends Repository<NoteReaction> {
-	public async pack(
+export const NoteReactionRepository = db.getRepository(NoteReaction).extend({
+	async pack(
 		src: NoteReaction['id'] | NoteReaction,
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -18,7 +17,7 @@ export class NoteReactionRepository extends Repository<NoteReaction> {
 			withNote: false,
 		}, options);

-		const reaction = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const reaction = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: reaction.id,
@ -29,5 +28,5 @@ export class NoteReactionRepository extends Repository<NoteReaction> {
 				note: await Notes.pack(reaction.note ?? reaction.noteId, me),
 			} : {}),
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/note.ts
+++ b/packages/backend/src/models/repositories/note.ts
@ -1,4 +1,4 @@
-import { EntityRepository, Repository, In } from 'typeorm';
+import { In } from 'typeorm';
 import * as mfm from 'mfm-js';
 import { Note } from '@/models/entities/note.js';
 import { User } from '@/models/entities/user.js';
@ -9,59 +9,9 @@ import { awaitAll } from '@/prelude/await-all.js';
 import { convertLegacyReaction, convertLegacyReactions, decodeReaction } from '@/misc/reaction-lib.js';
 import { NoteReaction } from '@/models/entities/note-reaction.js';
 import { aggregateNoteEmojis, populateEmojis, prefetchEmojis } from '@/misc/populate-emojis.js';
+import { db } from '@/db/postgre.js';

-@EntityRepository(Note)
-export class NoteRepository extends Repository<Note> {
-	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) {
+async function hideNote(packedNote: Packed<'Note'>, meId: User['id'] | null) {
 	// TODO: isVisibleForMe を使うようにしても良さそう(型違うけど)
 	let hide = false;

@ -97,7 +47,7 @@ export class NoteRepository extends Repository<Note> {
 			hide = false;
 		} else {
 			// フォロワーかどうか
-				const following = await Followings.findOne({
+			const following = await Followings.findOneBy({
 				followeeId: packedNote.userId,
 				followerId: meId,
 			});
@ -119,9 +69,59 @@ export class NoteRepository extends Repository<Note> {
 		packedNote.cw = null;
 		packedNote.isHidden = true;
 	}
+}
+
+export const NoteRepository = db.getRepository(Note).extend({
+	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;
+				}
+			}
 		}

-	public async pack(
+		// 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.findOneBy({
+					followeeId: note.userId,
+					followerId: meId,
+				});
+
+				if (following == null) {
+					return false;
+				} else {
+					return true;
+				}
+			}
+		}
+
+		return true;
+	},
+
+	async pack(
 		src: Note['id'] | Note,
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -138,11 +138,11 @@ export class NoteRepository extends Repository<Note> {
 		}, options);

 		const meId = me ? me.id : null;
-		const note = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const note = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });
 		const host = note.userHost;

 		async function populatePoll() {
-			const poll = await Polls.findOneOrFail(note.id);
+			const poll = await Polls.findOneByOrFail({ noteId: note.id });
 			const choices = poll.choices.map(c => ({
 				text: c,
 				votes: poll.votes[poll.choices.indexOf(c)],
@ -150,7 +150,7 @@ export class NoteRepository extends Repository<Note> {
 			}));

 			if (poll.multiple) {
-				const votes = await PollVotes.find({
+				const votes = await PollVotes.findBy({
 					userId: meId!,
 					noteId: note.id,
 				});
@ -160,7 +160,7 @@ export class NoteRepository extends Repository<Note> {
 					choices[myChoice].isVoted = true;
 				}
 			} else {
-				const vote = await PollVotes.findOne({
+				const vote = await PollVotes.findOneBy({
 					userId: meId!,
 					noteId: note.id,
 				});
@ -188,7 +188,7 @@ export class NoteRepository extends Repository<Note> {
 				// 実装上抜けがあるだけかもしれないので、「ヒントに含まれてなかったら(=undefinedなら)return」のようにはしない
 			}

-			const reaction = await NoteReactions.findOne({
+			const reaction = await NoteReactions.findOneBy({
 				userId: meId!,
 				noteId: note.id,
 			});
@ -209,7 +209,7 @@ export class NoteRepository extends Repository<Note> {
 		const channel = note.channelId
 			? note.channel
 				? note.channel
-				: await Channels.findOne(note.channelId)
+				: await Channels.findOneBy({ id: note.channelId })
 			: null;

 		const reactionEmojiNames = Object.keys(note.reactions).filter(x => x?.startsWith(':')).map(x => decodeReaction(x).reaction).map(x => x.replace(/:/g, ''));
@ -275,13 +275,13 @@ export class NoteRepository extends Repository<Note> {
 		}

 		if (!opts.skipHide) {
-			await this.hideNote(packed, meId);
+			await hideNote(packed, meId);
 		}

 		return packed;
-	}
+	},

-	public async packMany(
+	async packMany(
 		notes: Note[],
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -296,7 +296,7 @@ export class NoteRepository extends Repository<Note> {
 		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({
+			const myReactions = await NoteReactions.findBy({
 				userId: meId,
 				noteId: In(targets),
 			});
@ -314,5 +314,5 @@ export class NoteRepository extends Repository<Note> {
 				myReactions: myReactionsMap,
 			},
 		})));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/notification.ts
+++ b/packages/backend/src/models/repositories/notification.ts
@ -1,4 +1,4 @@
-import { EntityRepository, In, Repository } from 'typeorm';
+import { In, Repository } from 'typeorm';
 import { Users, Notes, UserGroupInvitations, AccessTokens, NoteReactions } from '../index.js';
 import { Notification } from '@/models/entities/notification.js';
 import { awaitAll } from '@/prelude/await-all.js';
@ -8,10 +8,10 @@ import { NoteReaction } from '@/models/entities/note-reaction.js';
 import { User } from '@/models/entities/user.js';
 import { aggregateNoteEmojis, prefetchEmojis } from '@/misc/populate-emojis.js';
 import { notificationTypes } from '@/types.js';
+import { db } from '@/db/postgre.js';

-@EntityRepository(Notification)
-export class NotificationRepository extends Repository<Notification> {
-	public async pack(
+export const NotificationRepository = db.getRepository(Notification).extend({
+	async pack(
 		src: Notification['id'] | Notification,
 		options: {
 			_hintForEachNotes_?: {
@ -19,8 +19,8 @@ export class NotificationRepository extends Repository<Notification> {
 			};
 		}
 	): Promise<Packed<'Notification'>> {
-		const notification = typeof src === 'object' ? src : await this.findOneOrFail(src);
-		const token = notification.appAccessTokenId ? await AccessTokens.findOneOrFail(notification.appAccessTokenId) : null;
+		const notification = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });
+		const token = notification.appAccessTokenId ? await AccessTokens.findOneByOrFail({ id: notification.appAccessTokenId }) : null;

 		return await awaitAll({
 			id: notification.id,
@ -82,9 +82,9 @@ export class NotificationRepository extends Repository<Notification> {
 				icon: notification.customIcon || token?.iconUrl,
 			} : {}),
 		});
-	}
+	},

-	public async packMany(
+	async packMany(
 		notifications: Notification[],
 		meId: User['id']
 	) {
@ -95,7 +95,7 @@ export class NotificationRepository extends Repository<Notification> {
 		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({
+		const myReactions = await NoteReactions.findBy({
 			userId: meId,
 			noteId: In(targets),
 		});
@ -111,5 +111,5 @@ export class NotificationRepository extends Repository<Notification> {
 				myReactions: myReactionsMap,
 			},
 		})));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/page-like.ts
+++ b/packages/backend/src/models/repositories/page-like.ts
@ -1,26 +1,25 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { PageLike } from '@/models/entities/page-like.js';
 import { Pages } from '../index.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(PageLike)
-export class PageLikeRepository extends Repository<PageLike> {
-	public async pack(
+export const PageLikeRepository = db.getRepository(PageLike).extend({
+	async pack(
 		src: PageLike['id'] | PageLike,
 		me?: { id: User['id'] } | null | undefined
 	) {
-		const like = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const like = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: like.id,
 			page: await Pages.pack(like.page || like.pageId, me),
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		likes: any[],
 		me: { id: User['id'] }
 	) {
 		return Promise.all(likes.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/page.ts
+++ b/packages/backend/src/models/repositories/page.ts
@ -1,4 +1,4 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Page } from '@/models/entities/page.js';
 import { Packed } from '@/misc/schema.js';
 import { Users, DriveFiles, PageLikes } from '../index.js';
@ -6,20 +6,19 @@ import { awaitAll } from '@/prelude/await-all.js';
 import { DriveFile } from '@/models/entities/drive-file.js';
 import { User } from '@/models/entities/user.js';

-@EntityRepository(Page)
-export class PageRepository extends Repository<Page> {
-	public async pack(
+export const PageRepository = db.getRepository(Page).extend({
+	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 page = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		const attachedFiles: Promise<DriveFile | undefined>[] = [];
 		const collectFile = (xs: any[]) => {
 			for (const x of xs) {
 				if (x.type === 'image') {
-					attachedFiles.push(DriveFiles.findOne({
+					attachedFiles.push(DriveFiles.findOneBy({
 						id: x.fileId,
 						userId: page.userId,
 					}));
@ -76,14 +75,14 @@ export class PageRepository extends Repository<Page> {
 			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,
+			isLiked: meId ? await PageLikes.findOneBy({ pageId: page.id, userId: meId }).then(x => x != null) : undefined,
 		});
-	}
+	},

-	public packMany(
+	packMany(
 		pages: Page[],
 		me?: { id: User['id'] } | null | undefined,
 	) {
 		return Promise.all(pages.map(x => this.pack(x, me)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/relay.ts
+++ b/packages/backend/src/models/repositories/relay.ts
@ -1,6 +1,5 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Relay } from '@/models/entities/relay.js';

-@EntityRepository(Relay)
-export class RelayRepository extends Repository<Relay> {
-}
+export const RelayRepository = db.getRepository(Relay).extend({
+});
--- a/packages/backend/src/models/repositories/signin.ts
+++ b/packages/backend/src/models/repositories/signin.ts
@ -1,11 +1,10 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { Signin } from '@/models/entities/signin.js';

-@EntityRepository(Signin)
-export class SigninRepository extends Repository<Signin> {
-	public async pack(
+export const SigninRepository = db.getRepository(Signin).extend({
+	async pack(
 		src: Signin,
 	) {
 		return src;
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/user-group-invitation.ts
+++ b/packages/backend/src/models/repositories/user-group-invitation.ts
@ -1,23 +1,22 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { UserGroupInvitation } from '@/models/entities/user-group-invitation.js';
 import { UserGroups } from '../index.js';

-@EntityRepository(UserGroupInvitation)
-export class UserGroupInvitationRepository extends Repository<UserGroupInvitation> {
-	public async pack(
+export const UserGroupInvitationRepository = db.getRepository(UserGroupInvitation).extend({
+	async pack(
 		src: UserGroupInvitation['id'] | UserGroupInvitation,
 	) {
-		const invitation = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const invitation = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

 		return {
 			id: invitation.id,
 			group: await UserGroups.pack(invitation.userGroup || invitation.userGroupId),
 		};
-	}
+	},

-	public packMany(
+	packMany(
 		invitations: any[],
 	) {
 		return Promise.all(invitations.map(x => this.pack(x)));
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/user-group.ts
+++ b/packages/backend/src/models/repositories/user-group.ts
@ -1,16 +1,15 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { UserGroup } from '@/models/entities/user-group.js';
 import { UserGroupJoinings } from '../index.js';
 import { Packed } from '@/misc/schema.js';

-@EntityRepository(UserGroup)
-export class UserGroupRepository extends Repository<UserGroup> {
-	public async pack(
+export const UserGroupRepository = db.getRepository(UserGroup).extend({
+	async pack(
 		src: UserGroup['id'] | UserGroup,
 	): Promise<Packed<'UserGroup'>> {
-		const userGroup = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const userGroup = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

-		const users = await UserGroupJoinings.find({
+		const users = await UserGroupJoinings.findBy({
 			userGroupId: userGroup.id,
 		});

@ -21,5 +20,5 @@ export class UserGroupRepository extends Repository<UserGroup> {
 			ownerId: userGroup.userId,
 			userIds: users.map(x => x.userId),
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/user-list.ts
+++ b/packages/backend/src/models/repositories/user-list.ts
@ -1,16 +1,15 @@
-import { EntityRepository, Repository } from 'typeorm';
+import { db } from '@/db/postgre.js';
 import { UserList } from '@/models/entities/user-list.js';
 import { UserListJoinings } from '../index.js';
 import { Packed } from '@/misc/schema.js';

-@EntityRepository(UserList)
-export class UserListRepository extends Repository<UserList> {
-	public async pack(
+export const UserListRepository = db.getRepository(UserList).extend({
+	async pack(
 		src: UserList['id'] | UserList,
 	): Promise<Packed<'UserList'>> {
-		const userList = typeof src === 'object' ? src : await this.findOneOrFail(src);
+		const userList = typeof src === 'object' ? src : await this.findOneByOrFail({ id: src });

-		const users = await UserListJoinings.find({
+		const users = await UserListJoinings.findBy({
 			userListId: userList.id,
 		});

@ -20,5 +19,5 @@ export class UserListRepository extends Repository<UserList> {
 			name: userList.name,
 			userIds: users.map(x => x.userId),
 		};
-	}
-}
+	},
+});
--- a/packages/backend/src/models/repositories/user.ts
+++ b/packages/backend/src/models/repositories/user.ts
@ -10,6 +10,7 @@ import { getAntennas } from '@/misc/antenna-cache.js';
 import { USER_ACTIVE_THRESHOLD, USER_ONLINE_THRESHOLD } from '@/const.js';
 import { Cache } from '@/misc/cache.js';
 import { Instance } from '../entities/instance.js';
+import { db } from '@/db/postgre.js';

 const userInstanceCache = new Cache<Instance | null>(1000 * 60 * 60 * 3);

@ -23,51 +24,69 @@ type IsMeAndIsUserDetailed<ExpectsMe extends boolean | null, Detailed extends bo

 const ajv = new Ajv();

-@EntityRepository(User)
-export class UserRepository extends Repository<User> {
-	public localUsernameSchema = { type: 'string', pattern: /^\w{1,20}$/.toString().slice(1, -1) } as const;
-	public passwordSchema = { type: 'string', minLength: 1 } as const;
-	public nameSchema = { type: 'string', minLength: 1, maxLength: 50 } as const;
-	public descriptionSchema = { type: 'string', minLength: 1, maxLength: 500 } as const;
-	public locationSchema = { type: 'string', minLength: 1, maxLength: 50 } as const;
-	public birthdaySchema = { type: 'string', pattern: /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.toString().slice(1, -1) } as const;
+const localUsernameSchema = { type: 'string', pattern: /^\w{1,20}$/.toString().slice(1, -1) } as const;
+const passwordSchema = { type: 'string', minLength: 1 } as const;
+const nameSchema = { type: 'string', minLength: 1, maxLength: 50 } as const;
+const descriptionSchema = { type: 'string', minLength: 1, maxLength: 500 } as const;
+const locationSchema = { type: 'string', minLength: 1, maxLength: 50 } as const;
+const birthdaySchema = { type: 'string', pattern: /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.toString().slice(1, -1) } as const;
+
+function isLocalUser(user: User): user is ILocalUser;
+function isLocalUser<T extends { host: User['host'] }>(user: T): user is T & { host: null; };
+function isLocalUser(user: User | { host: User['host'] }): boolean {
+	return user.host == null;
+}
+
+function isRemoteUser(user: User): user is IRemoteUser;
+function isRemoteUser<T extends { host: User['host'] }>(user: T): user is T & { host: string; };
+function isRemoteUser(user: User | { host: User['host'] }): boolean {
+	return !isLocalUser(user);
+}
+
+export const UserRepository = db.getRepository(User).extend({
+	localUsernameSchema,
+	passwordSchema,
+	nameSchema,
+	descriptionSchema,
+	locationSchema,
+	birthdaySchema,

 	//#region Validators
-	public validateLocalUsername = ajv.compile(this.localUsernameSchema);
-	public validatePassword = ajv.compile(this.passwordSchema);
-	public validateName = ajv.compile(this.nameSchema);
-	public validateDescription = ajv.compile(this.descriptionSchema);
-	public validateLocation = ajv.compile(this.locationSchema);
-	public validateBirthday = ajv.compile(this.birthdaySchema);
+	validateLocalUsername: ajv.compile(localUsernameSchema),
+	validatePassword: ajv.compile(passwordSchema),
+	validateName: ajv.compile(nameSchema),
+	validateDescription: ajv.compile(descriptionSchema),
+	validateLocation: ajv.compile(locationSchema),
+	validateBirthday: ajv.compile(birthdaySchema),
 	//#endregion

-	public async getRelation(me: User['id'], target: User['id']) {
+	async getRelation(me: User['id'], target: User['id']) {
 		const [following1, following2, followReq1, followReq2, toBlocking, fromBlocked, mute] = await Promise.all([
-			Followings.findOne({
+			Followings.findOneBy({
 				followerId: me,
 				followeeId: target,
 			}),
-			Followings.findOne({
+			Followings.findOneBy({
 				followerId: target,
 				followeeId: me,
 			}),
-			FollowRequests.findOne({
+			FollowRequests.findOneBy({
 				followerId: me,
 				followeeId: target,
 			}),
-			FollowRequests.findOne({
+			FollowRequests.findOneBy({
 				followerId: target,
 				followeeId: me,
 			}),
-			Blockings.findOne({
+			Blockings.findOneBy({
 				blockerId: me,
 				blockeeId: target,
 			}),
-			Blockings.findOne({
+			Blockings.findOneBy({
 				blockerId: target,
 				blockeeId: me,
 			}),
-			Mutings.findOne({
+			Mutings.findOneBy({
 				muterId: me,
 				muteeId: target,
 			}),
@ -83,14 +102,14 @@ export class UserRepository extends Repository<User> {
 			isBlocked: fromBlocked != null,
 			isMuted: mute != null,
 		};
-	}
+	},

-	public async getHasUnreadMessagingMessage(userId: User['id']): Promise<boolean> {
-		const mute = await Mutings.find({
+	async getHasUnreadMessagingMessage(userId: User['id']): Promise<boolean> {
+		const mute = await Mutings.findBy({
 			muterId: userId,
 		});

-		const joinings = await UserGroupJoinings.find({ userId: userId });
+		const joinings = await UserGroupJoinings.findBy({ userId: userId });

 		const groupQs = Promise.all(joinings.map(j => MessagingMessages.createQueryBuilder('message')
 			.where(`message.groupId = :groupId`, { groupId: j.userGroupId })
@ -112,44 +131,44 @@ export class UserRepository extends Repository<User> {
 		]);

 		return withUser || withGroups.some(x => x);
-	}
+	},

-	public async getHasUnreadAnnouncement(userId: User['id']): Promise<boolean> {
-		const reads = await AnnouncementReads.find({
+	async getHasUnreadAnnouncement(userId: User['id']): Promise<boolean> {
+		const reads = await AnnouncementReads.findBy({
 			userId: userId,
 		});

-		const count = await Announcements.count(reads.length > 0 ? {
+		const count = await Announcements.countBy(reads.length > 0 ? {
 			id: Not(In(reads.map(read => read.announcementId))),
 		} : {});

 		return count > 0;
-	}
+	},

-	public async getHasUnreadAntenna(userId: User['id']): Promise<boolean> {
+	async getHasUnreadAntenna(userId: User['id']): Promise<boolean> {
 		const myAntennas = (await getAntennas()).filter(a => a.userId === userId);

-		const unread = myAntennas.length > 0 ? await AntennaNotes.findOne({
+		const unread = myAntennas.length > 0 ? await AntennaNotes.findOneBy({
 			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 });
+	async getHasUnreadChannel(userId: User['id']): Promise<boolean> {
+		const channels = await ChannelFollowings.findBy({ followerId: userId });

-		const unread = channels.length > 0 ? await NoteUnreads.findOne({
+		const unread = channels.length > 0 ? await NoteUnreads.findOneBy({
 			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({
+	async getHasUnreadNotification(userId: User['id']): Promise<boolean> {
+		const mute = await Mutings.findBy({
 			muterId: userId,
 		});
 		const mutedUserIds = mute.map(m => m.muteeId);
@ -164,17 +183,17 @@ export class UserRepository extends Repository<User> {
 		});

 		return count > 0;
-	}
+	},

-	public async getHasPendingReceivedFollowRequest(userId: User['id']): Promise<boolean> {
-		const count = await FollowRequests.count({
+	async getHasPendingReceivedFollowRequest(userId: User['id']): Promise<boolean> {
+		const count = await FollowRequests.countBy({
 			followeeId: userId,
 		});

 		return count > 0;
-	}
+	},

-	public getOnlineStatus(user: User): 'unknown' | 'online' | 'active' | 'offline' {
+	getOnlineStatus(user: User): 'unknown' | 'online' | 'active' | 'offline' {
 		if (user.hideOnlineStatus) return 'unknown';
 		if (user.lastActiveDate == null) return 'unknown';
 		const elapsed = Date.now() - user.lastActiveDate.getTime();
@ -183,22 +202,22 @@ export class UserRepository extends Repository<User> {
 			elapsed < USER_ACTIVE_THRESHOLD ? 'active' :
 			'offline'
 		);
-	}
+	},

-	public getAvatarUrl(user: User): string {
+	getAvatarUrl(user: User): string {
 		// TODO: avatarIdがあるがavatarがない(JOINされてない)場合のハンドリング
 		if (user.avatar) {
 			return DriveFiles.getPublicUrl(user.avatar, true) || this.getIdenticonUrl(user.id);
 		} else {
 			return this.getIdenticonUrl(user.id);
 		}
-	}
+	},

-	public getIdenticonUrl(userId: User['id']): string {
+	getIdenticonUrl(userId: User['id']): string {
 		return `${config.url}/identicon/${userId}`;
-	}
+	},

-	public async pack<ExpectsMe extends boolean | null = null, D extends boolean = false>(
+	async pack<ExpectsMe extends boolean | null = null, D extends boolean = false>(
 		src: User['id'] | User,
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -215,11 +234,15 @@ export class UserRepository extends Repository<User> {

 		if (typeof src === 'object') {
 			user = src;
-			if (src.avatar === undefined && src.avatarId) src.avatar = await DriveFiles.findOne(src.avatarId) ?? null;
-			if (src.banner === undefined && src.bannerId) src.banner = await DriveFiles.findOne(src.bannerId) ?? null;
+			if (src.avatar === undefined && src.avatarId) src.avatar = await DriveFiles.findOneBy({ id: src.avatarId }) ?? null;
+			if (src.banner === undefined && src.bannerId) src.banner = await DriveFiles.findOneBy({ id: src.bannerId }) ?? null;
 		} else {
-			user = await this.findOneOrFail(src, {
-				relations: ['avatar', 'banner'],
+			user = await this.findOneOrFail({
+				where: { id: src },
+				relations: {
+					avatar: true,
+					banner: true,
+				},
 			});
 		}

@ -232,7 +255,7 @@ export class UserRepository extends Repository<User> {
 			.innerJoinAndSelect('pin.note', 'note')
 			.orderBy('pin.id', 'DESC')
 			.getMany() : [];
-		const profile = opts.detail ? await UserProfiles.findOneOrFail(user.id) : null;
+		const profile = opts.detail ? await UserProfiles.findOneByOrFail({ userId: user.id }) : null;

 		const followingCount = profile == null ? null :
 			(profile.ffVisibility === 'public') || isMe ? user.followingCount :
@ -258,9 +281,8 @@ export class UserRepository extends Repository<User> {
 			isModerator: user.isModerator || falsy,
 			isBot: user.isBot || falsy,
 			isCat: user.isCat || falsy,
-			// TODO: typeorm 3.0にしたら .then(x => x || null) は消せる
 			instance: user.host ? userInstanceCache.fetch(user.host,
-				() => Instances.findOne({ host: user.host }).then(x => x || null),
+				() => Instances.findOneBy({ host: user.host! }),
 				v => v != null
 			).then(instance => instance ? {
 				name: instance.name,
@ -304,7 +326,7 @@ export class UserRepository extends Repository<User> {
 				twoFactorEnabled: profile!.twoFactorEnabled,
 				usePasswordLessLogin: profile!.usePasswordLessLogin,
 				securityKeys: profile!.twoFactorEnabled
-					? UserSecurityKeys.count({
+					? UserSecurityKeys.countBy({
 						userId: user.id,
 					}).then(result => result >= 1)
 					: false,
@ -352,7 +374,11 @@ export class UserRepository extends Repository<User> {
 						where: {
 							userId: user.id,
 						},
-						select: ['id', 'name', 'lastUsed'],
+						select: {
+							id: true,
+							name: true,
+							lastUsed: true,
+						},
 					})
 					: [],
 			} : {}),
@ -369,9 +395,9 @@ export class UserRepository extends Repository<User> {
 		} as Promiseable<Packed<'User'>> as Promiseable<IsMeAndIsUserDetailed<ExpectsMe, D>>;

 		return await awaitAll(packed);
-	}
+	},

-	public packMany<D extends boolean = false>(
+	packMany<D extends boolean = false>(
 		users: (User['id'] | User)[],
 		me?: { id: User['id'] } | null | undefined,
 		options?: {
@ -380,17 +406,8 @@ export class UserRepository extends Repository<User> {
 		}
 	): Promise<IsUserDetailed<D>[]> {
 		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);
-	}
-}
+	isLocalUser,
+	isRemoteUser,
+});
--- a/packages/backend/src/queue/processors/db/delete-account.ts
+++ b/packages/backend/src/queue/processors/db/delete-account.ts
@ -13,7 +13,7 @@ const logger = queueLogger.createSubLogger('delete-account');
 export async function deleteAccount(job: Bull.Job<DbUserDeleteJobData>): Promise<string | void> {
 	logger.info(`Deleting account of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		return;
 	}
@ -75,7 +75,7 @@ export async function deleteAccount(job: Bull.Job<DbUserDeleteJobData>): Promise
 	}

 	{ // Send email notification
-		const profile = await UserProfiles.findOneOrFail(user.id);
+		const profile = await UserProfiles.findOneByOrFail({ userId: user.id });
 		if (profile.email && profile.emailVerified) {
 			sendEmail(profile.email, 'Account deleted',
 				`Your account has been deleted.`,
--- a/packages/backend/src/queue/processors/db/delete-drive-files.ts
+++ b/packages/backend/src/queue/processors/db/delete-drive-files.ts
@ -11,7 +11,7 @@ const logger = queueLogger.createSubLogger('delete-drive-files');
 export async function deleteDriveFiles(job: Bull.Job<DbUserJobData>, done: any): Promise<void> {
 	logger.info(`Deleting drive files of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
@ -44,7 +44,7 @@ export async function deleteDriveFiles(job: Bull.Job<DbUserJobData>, done: any):
 			deletedCount++;
 		}

-		const total = await DriveFiles.count({
+		const total = await DriveFiles.countBy({
 			userId: user.id,
 		});

--- a/packages/backend/src/queue/processors/db/export-blocking.ts
+++ b/packages/backend/src/queue/processors/db/export-blocking.ts
@ -15,7 +15,7 @@ const logger = queueLogger.createSubLogger('export-blocking');
 export async function exportBlocking(job: Bull.Job<DbUserJobData>, done: any): Promise<void> {
 	logger.info(`Exporting blocking of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
@ -56,7 +56,7 @@ export async function exportBlocking(job: Bull.Job<DbUserJobData>, done: any): P
 		cursor = blockings[blockings.length - 1].id;

 		for (const block of blockings) {
-			const u = await Users.findOne({ id: block.blockeeId });
+			const u = await Users.findOneBy({ id: block.blockeeId });
 			if (u == null) {
 				exportedCount++; continue;
 			}
@ -75,7 +75,7 @@ export async function exportBlocking(job: Bull.Job<DbUserJobData>, done: any): P
 			exportedCount++;
 		}

-		const total = await Blockings.count({
+		const total = await Blockings.countBy({
 			blockerId: user.id,
 		});

--- a/packages/backend/src/queue/processors/db/export-custom-emojis.ts
+++ b/packages/backend/src/queue/processors/db/export-custom-emojis.ts
@ -12,13 +12,14 @@ import { Users, Emojis } from '@/models/index.js';
 import {  } from '@/queue/types.js';
 import { downloadUrl } from '@/misc/download-url.js';
 import config from '@/config/index.js';
+import { IsNull } from 'typeorm';

 const logger = queueLogger.createSubLogger('export-custom-emojis');

 export async function exportCustomEmojis(job: Bull.Job, done: () => void): Promise<void> {
 	logger.info(`Exporting custom emojis ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
@ -57,7 +58,7 @@ export async function exportCustomEmojis(job: Bull.Job, done: () => void): Promi

 	const customEmojis = await Emojis.find({
 		where: {
-			host: null,
+			host: IsNull(),
 		},
 		order: {
 			id: 'ASC',
--- a/packages/backend/src/queue/processors/db/export-following.ts
+++ b/packages/backend/src/queue/processors/db/export-following.ts
@ -16,7 +16,7 @@ const logger = queueLogger.createSubLogger('export-following');
 export async function exportFollowing(job: Bull.Job<DbUserJobData>, done: () => void): Promise<void> {
 	logger.info(`Exporting following of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
@ -36,7 +36,7 @@ export async function exportFollowing(job: Bull.Job<DbUserJobData>, done: () =>

 	let cursor: Following['id'] | null = null;

-	const mutings = job.data.excludeMuting ? await Mutings.find({
+	const mutings = job.data.excludeMuting ? await Mutings.findBy({
 		muterId: user.id,
 	}) : [];

@ -60,7 +60,7 @@ export async function exportFollowing(job: Bull.Job<DbUserJobData>, done: () =>
 		cursor = followings[followings.length - 1].id;

 		for (const following of followings) {
-			const u = await Users.findOne({ id: following.followeeId });
+			const u = await Users.findOneBy({ id: following.followeeId });
 			if (u == null) {
 				continue;
 			}
--- a/packages/backend/src/queue/processors/db/export-mute.ts
+++ b/packages/backend/src/queue/processors/db/export-mute.ts
@ -15,7 +15,7 @@ const logger = queueLogger.createSubLogger('export-mute');
 export async function exportMute(job: Bull.Job<DbUserJobData>, done: any): Promise<void> {
 	logger.info(`Exporting mute of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
@ -57,7 +57,7 @@ export async function exportMute(job: Bull.Job<DbUserJobData>, done: any): Promi
 		cursor = mutes[mutes.length - 1].id;

 		for (const mute of mutes) {
-			const u = await Users.findOne({ id: mute.muteeId });
+			const u = await Users.findOneBy({ id: mute.muteeId });
 			if (u == null) {
 				exportedCount++; continue;
 			}
@ -76,7 +76,7 @@ export async function exportMute(job: Bull.Job<DbUserJobData>, done: any): Promi
 			exportedCount++;
 		}

-		const total = await Mutings.count({
+		const total = await Mutings.countBy({
 			muterId: user.id,
 		});

--- a/packages/backend/src/queue/processors/db/export-notes.ts
+++ b/packages/backend/src/queue/processors/db/export-notes.ts
@ -16,7 +16,7 @@ const logger = queueLogger.createSubLogger('export-notes');
 export async function exportNotes(job: Bull.Job<DbUserJobData>, done: any): Promise<void> {
 	logger.info(`Exporting notes of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
@ -74,7 +74,7 @@ export async function exportNotes(job: Bull.Job<DbUserJobData>, done: any): Prom
 		for (const note of notes) {
 			let poll: Poll | undefined;
 			if (note.hasPoll) {
-				poll = await Polls.findOneOrFail({ noteId: note.id });
+				poll = await Polls.findOneByOrFail({ noteId: note.id });
 			}
 			const content = JSON.stringify(serialize(note, poll));
 			const isFirst = exportedNotesCount === 0;
@ -82,7 +82,7 @@ export async function exportNotes(job: Bull.Job<DbUserJobData>, done: any): Prom
 			exportedNotesCount++;
 		}

-		const total = await Notes.count({
+		const total = await Notes.countBy({
 			userId: user.id,
 		});

--- a/packages/backend/src/queue/processors/db/export-user-lists.ts
+++ b/packages/backend/src/queue/processors/db/export-user-lists.ts
@ -15,13 +15,13 @@ const logger = queueLogger.createSubLogger('export-user-lists');
 export async function exportUserLists(job: Bull.Job<DbUserJobData>, done: any): Promise<void> {
 	logger.info(`Exporting user lists of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
 	}

-	const lists = await UserLists.find({
+	const lists = await UserLists.findBy({
 		userId: user.id,
 	});

@ -38,8 +38,8 @@ export async function exportUserLists(job: Bull.Job<DbUserJobData>, done: any):
 	const stream = fs.createWriteStream(path, { flags: 'a' });

 	for (const list of lists) {
-		const joinings = await UserListJoinings.find({ userListId: list.id });
-		const users = await Users.find({
+		const joinings = await UserListJoinings.findBy({ userListId: list.id });
+		const users = await Users.findBy({
 			id: In(joinings.map(j => j.userId)),
 		});

--- a/packages/backend/src/queue/processors/db/import-blocking.ts
+++ b/packages/backend/src/queue/processors/db/import-blocking.ts
@ -8,19 +8,20 @@ import { isSelfHost, toPuny } from '@/misc/convert-host.js';
 import { Users, DriveFiles, Blockings } from '@/models/index.js';
 import { DbUserImportJobData } from '@/queue/types.js';
 import block from '@/services/blocking/create.js';
+import { IsNull } from 'typeorm';

 const logger = queueLogger.createSubLogger('import-blocking');

 export async function importBlocking(job: Bull.Job<DbUserImportJobData>, done: any): Promise<void> {
 	logger.info(`Importing blocking of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
 	}

-	const file = await DriveFiles.findOne({
+	const file = await DriveFiles.findOneBy({
 		id: job.data.fileId,
 	});
 	if (file == null) {
@ -39,10 +40,10 @@ export async function importBlocking(job: Bull.Job<DbUserImportJobData>, done: a
 			const acct = line.split(',')[0].trim();
 			const { username, host } = Acct.parse(acct);

-			let target = isSelfHost(host!) ? await Users.findOne({
-				host: null,
+			let target = isSelfHost(host!) ? await Users.findOneBy({
+				host: IsNull(),
 				usernameLower: username.toLowerCase(),
-			}) : await Users.findOne({
+			}) : await Users.findOneBy({
 				host: toPuny(host!),
 				usernameLower: username.toLowerCase(),
 			});
--- a/packages/backend/src/queue/processors/db/import-custom-emojis.ts
+++ b/packages/backend/src/queue/processors/db/import-custom-emojis.ts
@ -2,7 +2,6 @@ import Bull from 'bull';
 import * as tmp from 'tmp';
 import * as fs from 'node:fs';
 import unzipper from 'unzipper';
-import { getConnection } from 'typeorm';

 import { queueLogger } from '../../logger.js';
 import { downloadUrl } from '@/misc/download-url.js';
@ -10,6 +9,7 @@ import { DriveFiles, Emojis } from '@/models/index.js';
 import { DbUserImportJobData } from '@/queue/types.js';
 import { addFile } from '@/services/drive/add-file.js';
 import { genId } from '@/misc/gen-id.js';
+import { db } from '@/db/postgre.js';

 const logger = queueLogger.createSubLogger('import-custom-emojis');

@ -17,7 +17,7 @@ const logger = queueLogger.createSubLogger('import-custom-emojis');
 export async function importCustomEmojis(job: Bull.Job<DbUserImportJobData>, done: any): Promise<void> {
 	logger.info(`Importing custom emojis ...`);

-	const file = await DriveFiles.findOne({
+	const file = await DriveFiles.findOneBy({
 		id: job.data.fileId,
 	});
 	if (file == null) {
@ -72,10 +72,10 @@ export async function importCustomEmojis(job: Bull.Job<DbUserImportJobData>, don
 				originalUrl: driveFile.url,
 				publicUrl: driveFile.webpublicUrl ?? driveFile.url,
 				type: driveFile.webpublicType ?? driveFile.type,
-			}).then(x => Emojis.findOneOrFail(x.identifiers[0]));
+			}).then(x => Emojis.findOneByOrFail(x.identifiers[0]));
 		}

-		await getConnection().queryResultCache!.remove(['meta_emojis']);
+		await db.queryResultCache!.remove(['meta_emojis']);

 		cleanup();
 	
--- a/packages/backend/src/queue/processors/db/import-following.ts
+++ b/packages/backend/src/queue/processors/db/import-following.ts
@ -8,19 +8,20 @@ import { downloadTextFile } from '@/misc/download-text-file.js';
 import { isSelfHost, toPuny } from '@/misc/convert-host.js';
 import { Users, DriveFiles } from '@/models/index.js';
 import { DbUserImportJobData } from '@/queue/types.js';
+import { IsNull } from 'typeorm';

 const logger = queueLogger.createSubLogger('import-following');

 export async function importFollowing(job: Bull.Job<DbUserImportJobData>, done: any): Promise<void> {
 	logger.info(`Importing following of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
 	}

-	const file = await DriveFiles.findOne({
+	const file = await DriveFiles.findOneBy({
 		id: job.data.fileId,
 	});
 	if (file == null) {
@ -39,10 +40,10 @@ export async function importFollowing(job: Bull.Job<DbUserImportJobData>, done:
 			const acct = line.split(',')[0].trim();
 			const { username, host } = Acct.parse(acct);

-			let target = isSelfHost(host!) ? await Users.findOne({
-				host: null,
+			let target = isSelfHost(host!) ? await Users.findOneBy({
+				host: IsNull(),
 				usernameLower: username.toLowerCase(),
-			}) : await Users.findOne({
+			}) : await Users.findOneBy({
 				host: toPuny(host!),
 				usernameLower: username.toLowerCase(),
 			});
--- a/packages/backend/src/queue/processors/db/import-muting.ts
+++ b/packages/backend/src/queue/processors/db/import-muting.ts
@ -9,19 +9,20 @@ import { Users, DriveFiles, Mutings } from '@/models/index.js';
 import { DbUserImportJobData } from '@/queue/types.js';
 import { User } from '@/models/entities/user.js';
 import { genId } from '@/misc/gen-id.js';
+import { IsNull } from 'typeorm';

 const logger = queueLogger.createSubLogger('import-muting');

 export async function importMuting(job: Bull.Job<DbUserImportJobData>, done: any): Promise<void> {
 	logger.info(`Importing muting of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
 	}

-	const file = await DriveFiles.findOne({
+	const file = await DriveFiles.findOneBy({
 		id: job.data.fileId,
 	});
 	if (file == null) {
@ -40,10 +41,10 @@ export async function importMuting(job: Bull.Job<DbUserImportJobData>, done: any
 			const acct = line.split(',')[0].trim();
 			const { username, host } = Acct.parse(acct);

-			let target = isSelfHost(host!) ? await Users.findOne({
-				host: null,
+			let target = isSelfHost(host!) ? await Users.findOneBy({
+				host: IsNull(),
 				usernameLower: username.toLowerCase(),
-			}) : await Users.findOne({
+			}) : await Users.findOneBy({
 				host: toPuny(host!),
 				usernameLower: username.toLowerCase(),
 			});
--- a/packages/backend/src/queue/processors/db/import-user-lists.ts
+++ b/packages/backend/src/queue/processors/db/import-user-lists.ts
@ -9,19 +9,20 @@ import { isSelfHost, toPuny } from '@/misc/convert-host.js';
 import { DriveFiles, Users, UserLists, UserListJoinings } from '@/models/index.js';
 import { genId } from '@/misc/gen-id.js';
 import { DbUserImportJobData } from '@/queue/types.js';
+import { IsNull } from 'typeorm';

 const logger = queueLogger.createSubLogger('import-user-lists');

 export async function importUserLists(job: Bull.Job<DbUserImportJobData>, done: any): Promise<void> {
 	logger.info(`Importing user lists of ${job.data.user.id} ...`);

-	const user = await Users.findOne(job.data.user.id);
+	const user = await Users.findOneBy({ id: job.data.user.id });
 	if (user == null) {
 		done();
 		return;
 	}

-	const file = await DriveFiles.findOne({
+	const file = await DriveFiles.findOneBy({
 		id: job.data.fileId,
 	});
 	if (file == null) {
@ -40,7 +41,7 @@ export async function importUserLists(job: Bull.Job<DbUserImportJobData>, done:
 			const listName = line.split(',')[0].trim();
 			const { username, host } = Acct.parse(line.split(',')[1].trim());

-			let list = await UserLists.findOne({
+			let list = await UserLists.findOneBy({
 				userId: user.id,
 				name: listName,
 			});
@ -51,13 +52,13 @@ export async function importUserLists(job: Bull.Job<DbUserImportJobData>, done:
 					createdAt: new Date(),
 					userId: user.id,
 					name: listName,
-				}).then(x => UserLists.findOneOrFail(x.identifiers[0]));
+				}).then(x => UserLists.findOneByOrFail(x.identifiers[0]));
 			}

-			let target = isSelfHost(host!) ? await Users.findOne({
-				host: null,
+			let target = isSelfHost(host!) ? await Users.findOneBy({
+				host: IsNull(),
 				usernameLower: username.toLowerCase(),
-			}) : await Users.findOne({
+			}) : await Users.findOneBy({
 				host: toPuny(host!),
 				usernameLower: username.toLowerCase(),
 			});
@ -66,7 +67,7 @@ export async function importUserLists(job: Bull.Job<DbUserImportJobData>, done:
 				target = await resolveUser(username, host);
 			}

-			if (await UserListJoinings.findOne({ userListId: list!.id, userId: target.id }) != null) continue;
+			if (await UserListJoinings.findOneBy({ userListId: list!.id, userId: target.id }) != null) continue;

 			pushUserToUserList(target, list!);
 		} catch (e) {
--- a/packages/backend/src/queue/processors/ended-poll-notification.ts
+++ b/packages/backend/src/queue/processors/ended-poll-notification.ts
@ -8,7 +8,7 @@ import { createNotification } from '@/services/create-notification.js';
 const logger = queueLogger.createSubLogger('ended-poll-notification');

 export async function endedPollNotification(job: Bull.Job<EndedPollNotificationJobData>, done: any): Promise<void> {
-	const note = await Notes.findOne(job.data.noteId);
+	const note = await Notes.findOneBy({ id: job.data.noteId });
 	if (note == null || !note.hasPoll) {
 		done();
 		return;
--- a/packages/backend/src/queue/processors/object-storage/clean-remote-files.ts
+++ b/packages/backend/src/queue/processors/object-storage/clean-remote-files.ts
@ -37,7 +37,7 @@ export default async function cleanRemoteFiles(job: Bull.Job<Record<string, unkn

 		deletedCount += 8;

-		const total = await DriveFiles.count({
+		const total = await DriveFiles.countBy({
 			userHost: Not(IsNull()),
 			isLink: false,
 		});
--- a/packages/backend/src/remote/activitypub/db-resolver.ts
+++ b/packages/backend/src/remote/activitypub/db-resolver.ts
@ -24,13 +24,13 @@ export default class DbResolver {
 		const parsed = this.parseUri(value);

 		if (parsed.id) {
-			return (await Notes.findOne({
+			return (await Notes.findOneBy({
 				id: parsed.id,
 			})) || null;
 		}

 		if (parsed.uri) {
-			return (await Notes.findOne({
+			return (await Notes.findOneBy({
 				uri: parsed.uri,
 			})) || null;
 		}
@ -42,13 +42,13 @@ export default class DbResolver {
 		const parsed = this.parseUri(value);

 		if (parsed.id) {
-			return (await MessagingMessages.findOne({
+			return (await MessagingMessages.findOneBy({
 				id: parsed.id,
 			})) || null;
 		}

 		if (parsed.uri) {
-			return (await MessagingMessages.findOne({
+			return (await MessagingMessages.findOneBy({
 				uri: parsed.uri,
 			})) || null;
 		}
@ -63,13 +63,13 @@ export default class DbResolver {
 		const parsed = this.parseUri(value);

 		if (parsed.id) {
-			return (await Users.findOne({
+			return (await Users.findOneBy({
 				id: parsed.id,
 			})) || null;
 		}

 		if (parsed.uri) {
-			return (await Users.findOne({
+			return (await Users.findOneBy({
 				uri: parsed.uri,
 			})) || null;
 		}
@ -85,7 +85,7 @@ export default class DbResolver {
 		key: UserPublickey;
 	} | null> {
 		const key = await publicKeyCache.fetch(keyId, async () => {
-			const key = await UserPublickeys.findOne({
+			const key = await UserPublickeys.findOneBy({
 				keyId,
 			});
 	
@ -97,7 +97,7 @@ export default class DbResolver {
 		if (key == null) return null;

 		return {
-			user: await userByIdCache.fetch(key.userId, () => Users.findOneOrFail(key.userId)) as CacheableRemoteUser,
+			user: await userByIdCache.fetch(key.userId, () => Users.findOneByOrFail({ id: key.userId })) as CacheableRemoteUser,
 			key,
 		};
 	}
@ -113,7 +113,7 @@ export default class DbResolver {

 		if (user == null) return null;

-		const key = await publicKeyByUserIdCache.fetch(user.id, () => UserPublickeys.findOne(user.id).then(x => x || null), v => v != null); // TODO: typeorm 3.0 にしたら.then(x => x || null)は消せる
+		const key = await publicKeyByUserIdCache.fetch(user.id, () => UserPublickeys.findOneBy({ userId: user.id }), v => v != null); 

 		return {
 			user,
--- a/packages/backend/src/remote/activitypub/deliver-manager.ts
+++ b/packages/backend/src/remote/activitypub/deliver-manager.ts
@ -82,7 +82,7 @@ export default class DeliverManager {
 		for (const recipe of this.recipes) {
 			if (isFollowers(recipe)) {
 				// followers deliver
-				const followers = await Followings.find({
+				const followers = await Followings.findBy({
 					followeeId: this.actor.id,
 				});

--- a/packages/backend/src/remote/activitypub/kernel/block/index.ts
+++ b/packages/backend/src/remote/activitypub/kernel/block/index.ts
@ -18,6 +18,6 @@ export default async (actor: CacheableRemoteUser, activity: IBlock): Promise<str
 		return `skip: ブロックしようとしているユーザーはローカルユーザーではありません`;
 	}

-	await block(await Users.findOneOrFail(actor.id), blockee);
+	await block(await Users.findOneByOrFail({ id: actor.id }), blockee);
 	return `ok`;
 };
--- a/packages/backend/src/remote/activitypub/kernel/delete/actor.ts
+++ b/packages/backend/src/remote/activitypub/kernel/delete/actor.ts
@ -12,7 +12,7 @@ export async function deleteActor(actor: CacheableRemoteUser, uri: string): Prom
 		return `skip: delete actor ${actor.uri} !== ${uri}`;
 	}

-	const user = await Users.findOneOrFail(actor.id);
+	const user = await Users.findOneByOrFail({ id: actor.id });
 	if (user.isDeleted) {
 		logger.info(`skip: already deleted`);
 	}
--- a/packages/backend/src/remote/activitypub/kernel/flag/index.ts
+++ b/packages/backend/src/remote/activitypub/kernel/flag/index.ts
@ -11,7 +11,7 @@ export default async (actor: CacheableRemoteUser, activity: IFlag): Promise<stri
 	const uris = getApIds(activity.object);

 	const userIds = uris.filter(uri => uri.startsWith(config.url + '/users/')).map(uri => uri.split('/').pop()!);
-	const users = await Users.find({
+	const users = await Users.findBy({
 		id: In(userIds),
 	});
 	if (users.length < 1) return `skip`;
--- a/packages/backend/src/remote/activitypub/kernel/read.ts
+++ b/packages/backend/src/remote/activitypub/kernel/read.ts
@ -13,7 +13,7 @@ export const performReadActivity = async (actor: CacheableRemoteUser, activity:

 	const messageId = id.split('/').pop();

-	const message = await MessagingMessages.findOne(messageId);
+	const message = await MessagingMessages.findOneBy({ id: messageId });
 	if (message == null) {
 		return `skip: message not found`;
 	}
--- a/packages/backend/src/remote/activitypub/kernel/undo/accept.ts
+++ b/packages/backend/src/remote/activitypub/kernel/undo/accept.ts
@ -13,7 +13,7 @@ export default async (actor: CacheableRemoteUser, activity: IAccept): Promise<st
 		return `skip: follower not found`;
 	}

-	const following = await Followings.findOne({
+	const following = await Followings.findOneBy({
 		followerId: follower.id,
 		followeeId: actor.id,
 	});
--- a/packages/backend/src/remote/activitypub/kernel/undo/announce.ts
+++ b/packages/backend/src/remote/activitypub/kernel/undo/announce.ts
@ -6,7 +6,7 @@ import deleteNote from '@/services/note/delete.js';
 export const undoAnnounce = async (actor: CacheableRemoteUser, activity: IAnnounce): Promise<string> => {
 	const uri = getApId(activity);

-	const note = await Notes.findOne({
+	const note = await Notes.findOneBy({
 		uri,
 	});

--- a/packages/backend/src/remote/activitypub/kernel/undo/block.ts
+++ b/packages/backend/src/remote/activitypub/kernel/undo/block.ts
@ -16,6 +16,6 @@ export default async (actor: CacheableRemoteUser, activity: IBlock): Promise<str
 		return `skip: ブロック解除しようとしているユーザーはローカルユーザーではありません`;
 	}

-	await unblock(await Users.findOneOrFail(actor.id), blockee);
+	await unblock(await Users.findOneByOrFail({ id: actor.id }), blockee);
 	return `ok`;
 };
--- a/packages/backend/src/remote/activitypub/kernel/undo/follow.ts
+++ b/packages/backend/src/remote/activitypub/kernel/undo/follow.ts
@ -17,12 +17,12 @@ export default async (actor: CacheableRemoteUser, activity: IFollow): Promise<st
 		return `skip: フォロー解除しようとしているユーザーはローカルユーザーではありません`;
 	}

-	const req = await FollowRequests.findOne({
+	const req = await FollowRequests.findOneBy({
 		followerId: actor.id,
 		followeeId: followee.id,
 	});

-	const following = await Followings.findOne({
+	const following = await Followings.findOneBy({
 		followerId: actor.id,
 		followeeId: followee.id,
 	});
--- a/packages/backend/src/remote/activitypub/models/image.ts
+++ b/packages/backend/src/remote/activitypub/models/image.ts
@ -47,7 +47,7 @@ export async function createImage(actor: CacheableRemoteUser, value: any): Promi
 				uri: image.url,
 			});

-			file = await DriveFiles.findOneOrFail(file.id);
+			file = await DriveFiles.findOneByOrFail({ id: file.id });
 		}
 	}

--- a/packages/backend/src/remote/activitypub/models/note.ts
+++ b/packages/backend/src/remote/activitypub/models/note.ts
@ -141,7 +141,7 @@ export async function createNote(value: string | IObject, resolver?: Resolver, s
 			const uri = getApId(note.inReplyTo);
 			if (uri.startsWith(config.url + '/')) {
 				const id = uri.split('/').pop();
-				const talk = await MessagingMessages.findOne(id);
+				const talk = await MessagingMessages.findOneBy({ id });
 				if (talk) {
 					isTalk = true;
 					return null;
@ -201,7 +201,7 @@ export async function createNote(value: string | IObject, resolver?: Resolver, s

 	// vote
 	if (reply && reply.hasPoll) {
-		const poll = await Polls.findOneOrFail(reply.id);
+		const poll = await Polls.findOneByOrFail({ noteId: reply.id });

 		const tryCreateVote = async (name: string, index: number): Promise<null> => {
 			if (poll.expiresAt && Date.now() > new Date(poll.expiresAt).getTime()) {
@ -306,7 +306,7 @@ export async function extractEmojis(tags: IObject | IObject[], host: string): Pr
 		const name = tag.name!.replace(/^:/, '').replace(/:$/, '');
 		tag.icon = toSingle(tag.icon);

-		const exists = await Emojis.findOne({
+		const exists = await Emojis.findOneBy({
 			host,
 			name,
 		});
@ -327,7 +327,7 @@ export async function extractEmojis(tags: IObject | IObject[], host: string): Pr
 					updatedAt: new Date(),
 				});

-				return await Emojis.findOne({
+				return await Emojis.findOneBy({
 					host,
 					name,
 				}) as Emoji;
@ -347,6 +347,6 @@ export async function extractEmojis(tags: IObject | IObject[], host: string): Pr
 			publicUrl: tag.icon!.url,
 			updatedAt: new Date(),
 			aliases: [],
-		} as Partial<Emoji>).then(x => Emojis.findOneOrFail(x.identifiers[0]));
+		} as Partial<Emoji>).then(x => Emojis.findOneByOrFail(x.identifiers[0]));
 	}));
 }
--- a/packages/backend/src/remote/activitypub/models/person.ts
+++ b/packages/backend/src/remote/activitypub/models/person.ts
@ -24,7 +24,6 @@ import { UserPublickey } from '@/models/entities/user-publickey.js';
 import { isDuplicateKeyValueError } from '@/misc/is-duplicate-key-value-error.js';
 import { toPuny } from '@/misc/convert-host.js';
 import { UserProfile } from '@/models/entities/user-profile.js';
-import { getConnection } from 'typeorm';
 import { toArray } from '@/prelude/array.js';
 import { fetchInstanceMetadata } from '@/services/fetch-instance-metadata.js';
 import { normalizeForSearch } from '@/misc/normalize-for-search.js';
@ -32,6 +31,7 @@ import { truncate } from '@/misc/truncate.js';
 import { StatusError } from '@/misc/fetch.js';
 import { uriPersonCache } from '@/services/user-cache.js';
 import { publishInternalEvent } from '@/services/stream.js';
+import { db } from '@/db/postgre.js';

 const logger = apLogger;

@ -102,13 +102,13 @@ export async function fetchPerson(uri: string, resolver?: Resolver): Promise<Cac
 	// URIがこのサーバーを指しているならデータベースからフェッチ
 	if (uri.startsWith(config.url + '/')) {
 		const id = uri.split('/').pop();
-		const u = await Users.findOne(id).then(x => x || null); // TODO: typeorm 3.0 にしたら .then(x => x || null) を消す
+		const u = await Users.findOneBy({ id });
 		if (u) uriPersonCache.set(uri, u);
 		return u;
 	}

 	//#region このサーバーに既に登録されていたらそれを返す
-	const exist = await Users.findOne({ uri });
+	const exist = await Users.findOneBy({ uri });

 	if (exist) {
 		uriPersonCache.set(uri, exist);
@ -151,7 +151,7 @@ export async function createPerson(uri: string, resolver?: Resolver): Promise<Us
 	let user: IRemoteUser;
 	try {
 		// Start transaction
-		await getConnection().transaction(async transactionalEntityManager => {
+		await db.transaction(async transactionalEntityManager => {
 			user = await transactionalEntityManager.save(new User({
 				id: genId(),
 				avatarId: null,
@ -197,7 +197,7 @@ export async function createPerson(uri: string, resolver?: Resolver): Promise<Us
 		// duplicate key error
 		if (isDuplicateKeyValueError(e)) {
 			// /users/@a => /users/:id のように入力がaliasなときにエラーになることがあるのを対応
-			const u = await Users.findOne({
+			const u = await Users.findOneBy({
 				uri: person.id,
 			});

@ -280,7 +280,7 @@ export async function updatePerson(uri: string, resolver?: Resolver | null, hint
 	}

 	//#region このサーバーに既に登録されているか
-	const exist = await Users.findOne({ uri }) as IRemoteUser;
+	const exist = await Users.findOneBy({ uri }) as IRemoteUser;

 	if (exist == null) {
 		return;
@ -451,7 +451,7 @@ export function analyzeAttachments(attachments: IObject | IObject[] | undefined)
 }

 export async function updateFeatured(userId: User['id']) {
-	const user = await Users.findOneOrFail(userId);
+	const user = await Users.findOneByOrFail({ id: userId });
 	if (!Users.isRemoteUser(user)) return;
 	if (!user.featured) return;

@ -474,7 +474,7 @@ export async function updateFeatured(userId: User['id']) {
 		.slice(0, 5)
 		.map(item => limit(() => resolveNote(item, resolver))));

-	await getConnection().transaction(async transactionalEntityManager => {
+	await db.transaction(async transactionalEntityManager => {
 		await transactionalEntityManager.delete(UserNotePining, { userId: user.id });

 		// とりあえずidを別の時間で生成して順番を維持
--- a/packages/backend/src/remote/activitypub/models/question.ts
+++ b/packages/backend/src/remote/activitypub/models/question.ts
@ -47,10 +47,10 @@ export async function updateQuestion(value: any) {
 	if (uri.startsWith(config.url + '/')) throw new Error('uri points local');

 	//#region このサーバーに既に登録されているか
-	const note = await Notes.findOne({ uri });
+	const note = await Notes.findOneBy({ uri });
 	if (note == null) throw new Error('Question is not registed');

-	const poll = await Polls.findOne({ noteId: note.id });
+	const poll = await Polls.findOneBy({ noteId: note.id });
 	if (poll == null) throw new Error('Question is not registed');
 	//#endregion

--- a/packages/backend/src/remote/activitypub/renderer/follow-user.ts
+++ b/packages/backend/src/remote/activitypub/renderer/follow-user.ts
@ -7,6 +7,6 @@ import { User } from '@/models/entities/user.js';
 * @param id Follower|Followee ID
 */
 export default async function renderFollowUser(id: User['id']): Promise<any> {
-	const user = await Users.findOneOrFail(id);
+	const user = await Users.findOneByOrFail({ id: id });
 	return Users.isLocalUser(user) ? `${config.url}/users/${user.id}` : user.uri;
 }
--- a/packages/backend/src/remote/activitypub/renderer/like.ts
+++ b/packages/backend/src/remote/activitypub/renderer/like.ts
@ -2,6 +2,7 @@ import config from '@/config/index.js';
 import { NoteReaction } from '@/models/entities/note-reaction.js';
 import { Note } from '@/models/entities/note.js';
 import { Emojis } from '@/models/index.js';
+import { IsNull } from 'typeorm';
 import renderEmoji from './emoji.js';

 export const renderLike = async (noteReaction: NoteReaction, note: Note) => {
@ -18,9 +19,9 @@ export const renderLike = async (noteReaction: NoteReaction, note: Note) => {

 	if (reaction.startsWith(':')) {
 		const name = reaction.replace(/:/g, '');
-		const emoji = await Emojis.findOne({
+		const emoji = await Emojis.findOneBy({
 			name,
-			host: null,
+			host: IsNull(),
 		});

 		if (emoji) object.tag = [ renderEmoji(emoji) ];
--- a/packages/backend/src/remote/activitypub/renderer/note.ts
+++ b/packages/backend/src/remote/activitypub/renderer/note.ts
@ -7,25 +7,25 @@ import toHtml from '../misc/get-note-html.js';
 import { Note, IMentionedRemoteUsers } from '@/models/entities/note.js';
 import { DriveFile } from '@/models/entities/drive-file.js';
 import { DriveFiles, Notes, Users, Emojis, Polls } from '@/models/index.js';
-import { In } from 'typeorm';
+import { In, IsNull } from 'typeorm';
 import { Emoji } from '@/models/entities/emoji.js';
 import { Poll } from '@/models/entities/poll.js';

 export default async function renderNote(note: Note, dive = true, isTalk = false): Promise<Record<string, unknown>> {
 	const getPromisedFiles = async (ids: string[]) => {
 		if (!ids || ids.length === 0) return [];
-		const items = await DriveFiles.find({ id: In(ids) });
+		const items = await DriveFiles.findBy({ id: In(ids) });
 		return ids.map(id => items.find(item => item.id === id)).filter(item => item != null) as DriveFile[];
 	};

 	let inReplyTo;
-	let inReplyToNote: Note | undefined;
+	let inReplyToNote: Note | null;

 	if (note.replyId) {
-		inReplyToNote = await Notes.findOne(note.replyId);
+		inReplyToNote = await Notes.findOneBy({ id: note.replyId });

 		if (inReplyToNote != null) {
-			const inReplyToUser = await Users.findOne(inReplyToNote.userId);
+			const inReplyToUser = await Users.findOneBy({ id: inReplyToNote.userId });

 			if (inReplyToUser != null) {
 				if (inReplyToNote.uri) {
@ -46,7 +46,7 @@ export default async function renderNote(note: Note, dive = true, isTalk = false
 	let quote;

 	if (note.renoteId) {
-		const renote = await Notes.findOne(note.renoteId);
+		const renote = await Notes.findOneBy({ id: note.renoteId });

 		if (renote) {
 			quote = renote.uri ? renote.uri : `${config.url}/notes/${renote.id}`;
@ -73,7 +73,7 @@ export default async function renderNote(note: Note, dive = true, isTalk = false
 		to = mentions;
 	}

-	const mentionedUsers = note.mentions.length > 0 ? await Users.find({
+	const mentionedUsers = note.mentions.length > 0 ? await Users.findBy({
 		id: In(note.mentions),
 	}) : [];

@ -83,10 +83,10 @@ export default async function renderNote(note: Note, dive = true, isTalk = false
 	const files = await getPromisedFiles(note.fileIds);

 	const text = note.text;
-	let poll: Poll | undefined;
+	let poll: Poll | null;

 	if (note.hasPoll) {
-		poll = await Polls.findOne({ noteId: note.id });
+		poll = await Polls.findOneBy({ noteId: note.id });
 	}

 	let apText = text;
@ -156,9 +156,9 @@ export async function getEmojis(names: string[]): Promise<Emoji[]> {
 	if (names == null || names.length === 0) return [];

 	const emojis = await Promise.all(
-		names.map(name => Emojis.findOne({
+		names.map(name => Emojis.findOneBy({
 			name,
-			host: null,
+			host: IsNull(),
 		}))
 	);

--- a/packages/backend/src/remote/activitypub/renderer/person.ts
+++ b/packages/backend/src/remote/activitypub/renderer/person.ts
@ -17,9 +17,9 @@ export async function renderPerson(user: ILocalUser) {
 	const isSystem = !!user.username.match(/\./);

 	const [avatar, banner, profile] = await Promise.all([
-		user.avatarId ? DriveFiles.findOne(user.avatarId) : Promise.resolve(undefined),
-		user.bannerId ? DriveFiles.findOne(user.bannerId) : Promise.resolve(undefined),
-		UserProfiles.findOneOrFail(user.id),
+		user.avatarId ? DriveFiles.findOneBy({ id: user.avatarId }) : Promise.resolve(undefined),
+		user.bannerId ? DriveFiles.findOneBy({ id: user.bannerId }) : Promise.resolve(undefined),
+		UserProfiles.findOneByOrFail({ userId: user.id }),
 	]);

 	const attachment: {
--- a/packages/backend/src/remote/resolve-user.ts
+++ b/packages/backend/src/remote/resolve-user.ts
@ -7,15 +7,16 @@ import chalk from 'chalk';
 import { User, IRemoteUser } from '@/models/entities/user.js';
 import { Users } from '@/models/index.js';
 import { toPuny } from '@/misc/convert-host.js';
+import { IsNull } from 'typeorm';

 const logger = remoteLogger.createSubLogger('resolve-user');

-export async function resolveUser(username: string, host: string | null, option?: any, resync = false): Promise<User> {
+export async function resolveUser(username: string, host: string | null): Promise<User> {
 	const usernameLower = username.toLowerCase();

 	if (host == null) {
 		logger.info(`return local user: ${usernameLower}`);
-		return await Users.findOne({ usernameLower, host: null }).then(u => {
+		return await Users.findOneBy({ usernameLower, host: IsNull() }).then(u => {
 			if (u == null) {
 				throw new Error('user not found');
 			} else {
@ -28,7 +29,7 @@ export async function resolveUser(username: string, host: string | null, option?

 	if (config.host === host) {
 		logger.info(`return local user: ${usernameLower}`);
-		return await Users.findOne({ usernameLower, host: null }).then(u => {
+		return await Users.findOneBy({ usernameLower, host: IsNull() }).then(u => {
 			if (u == null) {
 				throw new Error('user not found');
 			} else {
@ -37,7 +38,7 @@ export async function resolveUser(username: string, host: string | null, option?
 		});
 	}

-	const user = await Users.findOne({ usernameLower, host }, option) as IRemoteUser | null;
+	const user = await Users.findOneBy({ usernameLower, host }) as IRemoteUser | null;

 	const acctLower = `${usernameLower}@${host}`;

@ -48,8 +49,8 @@ export async function resolveUser(username: string, host: string | null, option?
 		return await createPerson(self.href);
 	}

-	// resyncオプション OR ユーザー情報が古い場合は、WebFilgerからやりなおして返す
-	if (resync || user.lastFetchedAt == null || Date.now() - user.lastFetchedAt.getTime() > 1000 * 60 * 60 * 24) {
+	// ユーザー情報が古い場合は、WebFilgerからやりなおして返す
+	if (user.lastFetchedAt == null || Date.now() - user.lastFetchedAt.getTime() > 1000 * 60 * 60 * 24) {
 		// 繋がらないインスタンスに何回も試行するのを防ぐ, 後続の同様処理の連続試行を防ぐ ため 試行前にも更新する
 		await Users.update(user.id, {
 			lastFetchedAt: new Date(),
@ -82,7 +83,7 @@ export async function resolveUser(username: string, host: string | null, option?
 		await updatePerson(self.href);

 		logger.info(`return resynced remote user: ${acctLower}`);
-		return await Users.findOne({ uri: self.href }).then(u => {
+		return await Users.findOneBy({ uri: self.href }).then(u => {
 			if (u == null) {
 				throw new Error('user not found');
 			} else {
--- a/packages/backend/src/server/activitypub.ts
+++ b/packages/backend/src/server/activitypub.ts
@ -15,7 +15,7 @@ import { inbox as processInbox } from '@/queue/index.js';
 import { isSelfHost } from '@/misc/convert-host.js';
 import { Notes, Users, Emojis, NoteReactions } from '@/models/index.js';
 import { ILocalUser, User } from '@/models/entities/user.js';
-import { In } from 'typeorm';
+import { In, IsNull } from 'typeorm';
 import { renderLike } from '@/remote/activitypub/renderer/like.js';
 import { getUserKeypair } from '@/misc/keypair-store.js';

@ -65,7 +65,7 @@ router.post('/users/:user/inbox', json(), inbox);
 router.get('/notes/:note', async (ctx, next) => {
 	if (!isActivityPubReq(ctx)) return await next();

-	const note = await Notes.findOne({
+	const note = await Notes.findOneBy({
 		id: ctx.params.note,
 		visibility: In(['public' as const, 'home' as const]),
 		localOnly: false,
@ -93,9 +93,9 @@ router.get('/notes/:note', async (ctx, next) => {

 // note activity
 router.get('/notes/:note/activity', async ctx => {
-	const note = await Notes.findOne({
+	const note = await Notes.findOneBy({
 		id: ctx.params.note,
-		userHost: null,
+		userHost: IsNull(),
 		visibility: In(['public' as const, 'home' as const]),
 		localOnly: false,
 	});
@ -126,9 +126,9 @@ router.get('/users/:user/collections/featured', Featured);
 router.get('/users/:user/publickey', async ctx => {
 	const userId = ctx.params.user;

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		id: userId,
-		host: null,
+		host: IsNull(),
 	});

 	if (user == null) {
@ -164,9 +164,9 @@ router.get('/users/:user', async (ctx, next) => {

 	const userId = ctx.params.user;

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		id: userId,
-		host: null,
+		host: IsNull(),
 		isSuspended: false,
 	});

@ -176,9 +176,9 @@ router.get('/users/:user', async (ctx, next) => {
 router.get('/@:user', async (ctx, next) => {
 	if (!isActivityPubReq(ctx)) return await next();

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		usernameLower: ctx.params.user.toLowerCase(),
-		host: null,
+		host: IsNull(),
 		isSuspended: false,
 	});

@ -188,8 +188,8 @@ router.get('/@:user', async (ctx, next) => {

 // emoji
 router.get('/emojis/:emoji', async ctx => {
-	const emoji = await Emojis.findOne({
-		host: null,
+	const emoji = await Emojis.findOneBy({
+		host: IsNull(),
 		name: ctx.params.emoji,
 	});

@ -205,14 +205,14 @@ router.get('/emojis/:emoji', async ctx => {

 // like
 router.get('/likes/:like', async ctx => {
-	const reaction = await NoteReactions.findOne(ctx.params.like);
+	const reaction = await NoteReactions.findOneBy({ id: ctx.params.like });

 	if (reaction == null) {
 		ctx.status = 404;
 		return;
 	}

-	const note = await Notes.findOne(reaction.noteId);
+	const note = await Notes.findOneBy({ id: reaction.noteId });

 	if (note == null) {
 		ctx.status = 404;
--- a/packages/backend/src/server/activitypub/featured.ts
+++ b/packages/backend/src/server/activitypub/featured.ts
@ -5,13 +5,14 @@ import renderOrderedCollection from '@/remote/activitypub/renderer/ordered-colle
 import { setResponseType } from '../activitypub.js';
 import renderNote from '@/remote/activitypub/renderer/note.js';
 import { Users, Notes, UserNotePinings } from '@/models/index.js';
+import { IsNull } from 'typeorm';

 export default async (ctx: Router.RouterContext) => {
 	const userId = ctx.params.user;

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		id: userId,
-		host: null,
+		host: IsNull(),
 	});

 	if (user == null) {
@ -25,7 +26,7 @@ export default async (ctx: Router.RouterContext) => {
 	});

 	const pinnedNotes = await Promise.all(pinings.map(pining =>
-		Notes.findOneOrFail(pining.noteId)));
+		Notes.findOneByOrFail({ id: pining.noteId })));

 	const renderedNotes = await Promise.all(pinnedNotes.map(note => renderNote(note)));

--- a/packages/backend/src/server/activitypub/followers.ts
+++ b/packages/backend/src/server/activitypub/followers.ts
@ -9,7 +9,7 @@ import renderOrderedCollectionPage from '@/remote/activitypub/renderer/ordered-c
 import renderFollowUser from '@/remote/activitypub/renderer/follow-user.js';
 import { setResponseType } from '../activitypub.js';
 import { Users, Followings, UserProfiles } from '@/models/index.js';
-import { LessThan } from 'typeorm';
+import { IsNull, LessThan } from 'typeorm';

 export default async (ctx: Router.RouterContext) => {
 	const userId = ctx.params.user;
@ -27,9 +27,9 @@ export default async (ctx: Router.RouterContext) => {
 		return;
 	}

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		id: userId,
-		host: null,
+		host: IsNull(),
 	});

 	if (user == null) {
@ -38,7 +38,7 @@ export default async (ctx: Router.RouterContext) => {
 	}

 	//#region Check ff visibility
-	const profile = await UserProfiles.findOneOrFail(user.id);
+	const profile = await UserProfiles.findOneByOrFail({ userId: user.id });

 	if (profile.ffVisibility === 'private') {
 		ctx.status = 403;
--- a/packages/backend/src/server/activitypub/following.ts
+++ b/packages/backend/src/server/activitypub/following.ts
@ -9,7 +9,7 @@ import renderOrderedCollectionPage from '@/remote/activitypub/renderer/ordered-c
 import renderFollowUser from '@/remote/activitypub/renderer/follow-user.js';
 import { setResponseType } from '../activitypub.js';
 import { Users, Followings, UserProfiles } from '@/models/index.js';
-import { LessThan, FindConditions } from 'typeorm';
+import { LessThan, IsNull, FindOptionsWhere } from 'typeorm';
 import { Following } from '@/models/entities/following.js';

 export default async (ctx: Router.RouterContext) => {
@ -28,9 +28,9 @@ export default async (ctx: Router.RouterContext) => {
 		return;
 	}

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		id: userId,
-		host: null,
+		host: IsNull(),
 	});

 	if (user == null) {
@ -39,7 +39,7 @@ export default async (ctx: Router.RouterContext) => {
 	}

 	//#region Check ff visibility
-	const profile = await UserProfiles.findOneOrFail(user.id);
+	const profile = await UserProfiles.findOneByOrFail({ userId: user.id });

 	if (profile.ffVisibility === 'private') {
 		ctx.status = 403;
@ -58,7 +58,7 @@ export default async (ctx: Router.RouterContext) => {
 	if (page) {
 		const query = {
 			followerId: user.id,
-		} as FindConditions<Following>;
+		} as FindOptionsWhere<Following>;

 		// カーソルが指定されている場合
 		if (cursor) {
--- a/packages/backend/src/server/activitypub/outbox.ts
+++ b/packages/backend/src/server/activitypub/outbox.ts
@ -13,7 +13,7 @@ import { countIf } from '@/prelude/array.js';
 import * as url from '@/prelude/url.js';
 import { Users, Notes } from '@/models/index.js';
 import { makePaginationQuery } from '../api/common/make-pagination-query.js';
-import { Brackets } from 'typeorm';
+import { Brackets, IsNull } from 'typeorm';
 import { Note } from '@/models/entities/note.js';

 export default async (ctx: Router.RouterContext) => {
@ -35,9 +35,9 @@ export default async (ctx: Router.RouterContext) => {
 		return;
 	}

-	const user = await Users.findOne({
+	const user = await Users.findOneBy({
 		id: userId,
-		host: null,
+		host: IsNull(),
 	});

 	if (user == null) {
@ -99,7 +99,7 @@ export default async (ctx: Router.RouterContext) => {
 */
 export async function packActivity(note: Note): Promise<any> {
 	if (note.renoteId && note.text == null && !note.hasPoll && (note.fileIds == null || note.fileIds.length === 0)) {
-		const renote = await Notes.findOneOrFail(note.renoteId);
+		const renote = await Notes.findOneByOrFail({ id: note.renoteId });
 		return renderAnnounce(renote.uri ? renote.uri : `${config.url}/notes/${renote.id}`, note);
 	}

--- a/packages/backend/src/server/api/authenticate.ts
+++ b/packages/backend/src/server/api/authenticate.ts
@ -21,9 +21,8 @@ export default async (token: string | null): Promise<[CacheableLocalUser | null
 	}

 	if (isNativeToken(token)) {
-		// TODO: typeorm 3.0にしたら .then(x => x || null) は消せる
 		const user = await localUserByNativeTokenCache.fetch(token,
-			() => Users.findOne({ token }).then(x => x || null) as Promise<ILocalUser | null>);
+			() => Users.findOneBy({ token }) as Promise<ILocalUser | null>);

 		if (user == null) {
 			throw new AuthenticationError('user not found');
@ -48,13 +47,13 @@ export default async (token: string | null): Promise<[CacheableLocalUser | null
 		});

 		const user = await localUserByIdCache.fetch(accessToken.userId,
-			() => Users.findOne({
-				id: accessToken.userId, // findOne(accessToken.userId) のように書かないのは後方互換性のため
+			() => Users.findOneBy({
+				id: accessToken.userId,
 			}) as Promise<ILocalUser>);

 		if (accessToken.appId) {
 			const app = await appCache.fetch(accessToken.appId,
-				() => Apps.findOneOrFail(accessToken.appId!));
+				() => Apps.findOneByOrFail({ id: accessToken.appId! }));

 			return [user, {
 				id: accessToken.id,
--- a/packages/backend/src/server/api/common/getters.ts
+++ b/packages/backend/src/server/api/common/getters.ts
@ -7,7 +7,7 @@ import { Notes, Users } from '@/models/index.js';
 * Get note for API processing
 */
 export async function getNote(noteId: Note['id']) {
-	const note = await Notes.findOne(noteId);
+	const note = await Notes.findOneBy({ id: noteId });

 	if (note == null) {
 		throw new IdentifiableError('9725d0ce-ba28-4dde-95a7-2cbb2c15de24', 'No such note.');
@ -20,7 +20,7 @@ export async function getNote(noteId: Note['id']) {
 * Get user for API processing
 */
 export async function getUser(userId: User['id']) {
-	const user = await Users.findOne(userId);
+	const user = await Users.findOneBy({ id: userId });

 	if (user == null) {
 		throw new IdentifiableError('15348ddd-432d-49c2-8a5a-8069753becff', 'No such user.');
--- a/packages/backend/src/server/api/common/inject-featured.ts
+++ b/packages/backend/src/server/api/common/inject-featured.ts
@ -11,7 +11,7 @@ export async function injectFeatured(timeline: Note[], user?: User | null) {
 	if (timeline.length < 5) return;

 	if (user) {
-		const profile = await UserProfiles.findOneOrFail(user.id);
+		const profile = await UserProfiles.findOneByOrFail({ userId: user.id });
 		if (!profile.injectFeaturedNote) return;
 	}

--- a/packages/backend/src/server/api/common/inject-promo.ts
+++ b/packages/backend/src/server/api/common/inject-promo.ts
@ -8,7 +8,7 @@ export async function injectPromo(timeline: Note[], user?: User | null) {

 	// TODO: readやexpireフィルタはクエリ側でやる

-	const reads = user ? await PromoReads.find({
+	const reads = user ? await PromoReads.findBy({
 		userId: user.id,
 	}) : [];

@ -22,10 +22,10 @@ export async function injectPromo(timeline: Note[], user?: User | null) {
 	// Pick random promo
 	const promo = promos[Math.floor(Math.random() * promos.length)];

-	const note = await Notes.findOneOrFail(promo.noteId);
+	const note = await Notes.findOneByOrFail({ id: promo.noteId });

 	// Join
-	note.user = await Users.findOneOrFail(note.userId);
+	note.user = await Users.findOneByOrFail({ id: note.userId });

 	(note as any)._prId_ = rndstr('a-z0-9', 8);

--- a/packages/backend/src/server/api/common/read-messaging-message.ts
+++ b/packages/backend/src/server/api/common/read-messaging-message.ts
@ -23,7 +23,7 @@ export async function readUserMessagingMessage(
 ) {
 	if (messageIds.length === 0) return;

-	const messages = await MessagingMessages.find({
+	const messages = await MessagingMessages.findBy({
 		id: In(messageIds),
 	});

@ -64,7 +64,7 @@ export async function readGroupMessagingMessage(
 	if (messageIds.length === 0) return;

 	// check joined
-	const joining = await UserGroupJoinings.findOne({
+	const joining = await UserGroupJoinings.findOneBy({
 		userId: userId,
 		userGroupId: groupId,
 	});
@ -73,7 +73,7 @@ export async function readGroupMessagingMessage(
 		throw new IdentifiableError('930a270c-714a-46b2-b776-ad27276dc569', 'Access denied (group).');
 	}

-	const messages = await MessagingMessages.find({
+	const messages = await MessagingMessages.findBy({
 		id: In(messageIds),
 	});

--- a/packages/backend/src/server/api/common/signin.ts
+++ b/packages/backend/src/server/api/common/signin.ts
@ -36,7 +36,7 @@ export default function(ctx: Koa.Context, user: ILocalUser, redirect = false) {
 			ip: ctx.ip,
 			headers: ctx.headers,
 			success: true,
-		}).then(x => Signins.findOneOrFail(x.identifiers[0]));
+		}).then(x => Signins.findOneByOrFail(x.identifiers[0]));

 		// Publish signin event
 		publishMainStream(user.id, 'signin', await Signins.pack(record));
--- a/packages/backend/src/server/api/common/signup.ts
+++ b/packages/backend/src/server/api/common/signup.ts
@ -4,12 +4,13 @@ import generateUserToken from './generate-native-user-token.js';
 import { User } from '@/models/entities/user.js';
 import { Users, UsedUsernames } from '@/models/index.js';
 import { UserProfile } from '@/models/entities/user-profile.js';
-import { getConnection } from 'typeorm';
+import { IsNull } from 'typeorm';
 import { genId } from '@/misc/gen-id.js';
 import { toPunyNullable } from '@/misc/convert-host.js';
 import { UserKeypair } from '@/models/entities/user-keypair.js';
 import { usersChart } from '@/services/chart/index.js';
 import { UsedUsername } from '@/models/entities/used-username.js';
+import { db } from '@/db/postgre.js';

 export async function signup(opts: {
 	username: User['username'];
@ -40,12 +41,12 @@ export async function signup(opts: {
 	const secret = generateUserToken();

 	// Check username duplication
-	if (await Users.findOne({ usernameLower: username.toLowerCase(), host: null })) {
+	if (await Users.findOneBy({ usernameLower: username.toLowerCase(), host: IsNull() })) {
 		throw new Error('DUPLICATED_USERNAME');
 	}

 	// Check deleted username duplication
-	if (await UsedUsernames.findOne({ username: username.toLowerCase() })) {
+	if (await UsedUsernames.findOneBy({ username: username.toLowerCase() })) {
 		throw new Error('USED_USERNAME');
 	}

@ -69,10 +70,10 @@ export async function signup(opts: {
 	let account!: User;

 	// Start transaction
-	await getConnection().transaction(async transactionalEntityManager => {
-		const exist = await transactionalEntityManager.findOne(User, {
+	await db.transaction(async transactionalEntityManager => {
+		const exist = await transactionalEntityManager.findOneBy(User, {
 			usernameLower: username.toLowerCase(),
-			host: null,
+			host: IsNull(),
 		});

 		if (exist) throw new Error(' the username is already used');
@ -84,8 +85,8 @@ export async function signup(opts: {
 			usernameLower: username.toLowerCase(),
 			host: toPunyNullable(host),
 			token: secret,
-			isAdmin: (await Users.count({
-				host: null,
+			isAdmin: (await Users.countBy({
+				host: IsNull(),
 			})) === 0,
 		}));

--- a/packages/backend/src/server/api/endpoints/admin/accounts/create.ts
+++ b/packages/backend/src/server/api/endpoints/admin/accounts/create.ts
@ -1,6 +1,7 @@
 import define from '../../../define.js';
 import { Users } from '@/models/index.js';
 import { signup } from '../../../common/signup.js';
+import { IsNull } from 'typeorm';

 export const meta = {
 	tags: ['admin'],
@ -29,9 +30,9 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, _me) => {
-	const me = _me ? await Users.findOneOrFail(_me.id) : null;
-	const noUsers = (await Users.count({
-		host: null,
+	const me = _me ? await Users.findOneByOrFail({ id: _me.id }) : null;
+	const noUsers = (await Users.countBy({
+		host: IsNull(),
 	})) === 0;
 	if (!noUsers && !me?.isAdmin) throw new Error('access denied');

--- a/packages/backend/src/server/api/endpoints/admin/accounts/delete.ts
+++ b/packages/backend/src/server/api/endpoints/admin/accounts/delete.ts
@ -21,7 +21,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const user = await Users.findOne(ps.userId);
+	const user = await Users.findOneBy({ id: ps.userId });

 	if (user == null) {
 		throw new Error('user not found');
--- a/packages/backend/src/server/api/endpoints/admin/ad/delete.ts
+++ b/packages/backend/src/server/api/endpoints/admin/ad/delete.ts
@ -27,7 +27,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const ad = await Ads.findOne(ps.id);
+	const ad = await Ads.findOneBy({ id: ps.id });

 	if (ad == null) throw new ApiError(meta.errors.noSuchAd);

--- a/packages/backend/src/server/api/endpoints/admin/ad/update.ts
+++ b/packages/backend/src/server/api/endpoints/admin/ad/update.ts
@ -34,7 +34,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const ad = await Ads.findOne(ps.id);
+	const ad = await Ads.findOneBy({ id: ps.id });

 	if (ad == null) throw new ApiError(meta.errors.noSuchAd);

--- a/packages/backend/src/server/api/endpoints/admin/announcements/create.ts
+++ b/packages/backend/src/server/api/endpoints/admin/announcements/create.ts
@ -63,7 +63,7 @@ export default define(meta, paramDef, async (ps) => {
 		title: ps.title,
 		text: ps.text,
 		imageUrl: ps.imageUrl,
-	}).then(x => Announcements.findOneOrFail(x.identifiers[0]));
+	}).then(x => Announcements.findOneByOrFail(x.identifiers[0]));

 	return Object.assign({}, announcement, { createdAt: announcement.createdAt.toISOString(), updatedAt: null });
 });
--- a/packages/backend/src/server/api/endpoints/admin/announcements/delete.ts
+++ b/packages/backend/src/server/api/endpoints/admin/announcements/delete.ts
@ -27,7 +27,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const announcement = await Announcements.findOne(ps.id);
+	const announcement = await Announcements.findOneBy({ id: ps.id });

 	if (announcement == null) throw new ApiError(meta.errors.noSuchAnnouncement);

--- a/packages/backend/src/server/api/endpoints/admin/announcements/list.ts
+++ b/packages/backend/src/server/api/endpoints/admin/announcements/list.ts
@ -69,7 +69,7 @@ export default define(meta, paramDef, async (ps) => {
 	const announcements = await query.take(ps.limit).getMany();

 	for (const announcement of announcements) {
-		(announcement as any).reads = await AnnouncementReads.count({
+		(announcement as any).reads = await AnnouncementReads.countBy({
 			announcementId: announcement.id,
 		});
 	}
--- a/packages/backend/src/server/api/endpoints/admin/announcements/update.ts
+++ b/packages/backend/src/server/api/endpoints/admin/announcements/update.ts
@ -30,7 +30,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const announcement = await Announcements.findOne(ps.id);
+	const announcement = await Announcements.findOneBy({ id: ps.id });

 	if (announcement == null) throw new ApiError(meta.errors.noSuchAnnouncement);

--- a/packages/backend/src/server/api/endpoints/admin/delete-all-files-of-a-user.ts
+++ b/packages/backend/src/server/api/endpoints/admin/delete-all-files-of-a-user.ts
@ -19,7 +19,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const files = await DriveFiles.find({
+	const files = await DriveFiles.findBy({
 		userId: ps.userId,
 	});

--- a/packages/backend/src/server/api/endpoints/admin/drive/cleanup.ts
+++ b/packages/backend/src/server/api/endpoints/admin/drive/cleanup.ts
@ -18,7 +18,7 @@ export const paramDef = {

 // eslint-disable-next-line import/no-default-export
 export default define(meta, paramDef, async (ps, me) => {
-	const files = await DriveFiles.find({
+	const files = await DriveFiles.findBy({
 		userId: IsNull(),
 	});

--- a/Show More
+++ b/Show More