Feat: 特定ユーザーからのリアクションをブロックする機能の追加

locales/index.d.ts

@@ -606,6 +606,14 @@ export interface Locale extends ILocale {
      * ブロック解除
      */
     "unblock": string;
+    /**
+     * リアクションをブロック
+     */
+    "blockReactionUser": string;
+    /**
+     * リアクションのブロックを解除
+     */
+    "unblockReactionUser": string;
     /**
      * 凍結
      */
@@ -622,6 +630,14 @@ export interface Locale extends ILocale {
      * ブロック解除しますか？
      */
     "unblockConfirm": string;
+    /**
+     * リアクションをブロックしますか？
+     */
+    "blockReactionUserConfirm": string;
+    /**
+     * リアクションのブロックを解除しますか？
+     */
+    "unblockReactionUserConfirm": string;
     /**
      * 凍結しますか？
      */
@@ -994,6 +1010,10 @@ export interface Locale extends ILocale {
      * ブロックしたユーザー
      */
     "blockedUsers": string;
+    /**
+     * リアクションをブロックしたユーザー
+     */
+    "reactionBlockedUsers": string;
     /**
      * ユーザーはいません
      */

locales/ja-JP.yml

@@ -147,10 +147,14 @@ renoteMute: "リノートをミュート"
 renoteUnmute: "リノートのミュートを解除"
 block: "ブロック"
 unblock: "ブロック解除"
+blockReactionUser: "リアクションをブロック"
+unblockReactionUser: "リアクションのブロックを解除"
 suspend: "凍結"
 unsuspend: "解凍"
 blockConfirm: "ブロックしますか？"
 unblockConfirm: "ブロック解除しますか？"
+blockReactionUserConfirm: "リアクションをブロックしますか？"
+unblockReactionUserConfirm: "リアクションのブロックを解除しますか？"
 suspendConfirm: "凍結しますか？"
 unsuspendConfirm: "解凍しますか？"
 selectList: "リストを選択"
@@ -244,6 +248,7 @@ federationAllowedHostsDescription: "連合を許可するサーバーのホス
 muteAndBlock: "ミュートとブロック"
 mutedUsers: "ミュートしたユーザー"
 blockedUsers: "ブロックしたユーザー"
+reactionBlockedUsers: "リアクションをブロックしたユーザー"
 noUsers: "ユーザーはいません"
 editProfile: "プロフィールを編集"
 noteDeleteConfirm: "このノートを削除しますか？"

packages/backend/migration/1731898598469-addBlockingReactionUser.js

@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: syuilo and misskey-project
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+export class AddBlockingReactionUser1731898598469 {
+    name = 'AddBlockingReactionUser1731898598469'
+
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "blocking" ADD "isReactionBlock" boolean NOT NULL DEFAULT false`);
+        await queryRunner.query(`COMMENT ON COLUMN "blocking"."isReactionBlock" IS 'Whether the blockee is a reaction block.'`);
+        await queryRunner.query(`CREATE INDEX "IDX_7b0698c38d27a5554bed4858bd" ON "blocking" ("isReactionBlock") `);
+    }
+
+    async down(queryRunner) {
+				await queryRunner.query(`DELETE FROM blocking WHERE "isReactionBlock" = 'true'`);　// blockingテーブルのisReactionBlockカラムがtrueの行を削除する
+				await queryRunner.query(`DROP INDEX "IDX_7b0698c38d27a5554bed4858bd"`);
+        await queryRunner.query(`ALTER TABLE "blocking" DROP COLUMN "isReactionBlock"`);
+    }
+}

packages/backend/src/core/CacheService.ts

@@ -24,6 +24,8 @@ export class CacheService implements OnApplicationShutdown {
 	public userMutingsCache: RedisKVCache<Set<string>>;
 	public userBlockingCache: RedisKVCache<Set<string>>;
 	public userBlockedCache: RedisKVCache<Set<string>>; // NOTE: 「被」Blockキャッシュ
+	public userReactionBlockingCache: RedisKVCache<Set<string>>; // NOTE: リアクションBlockキャッシュ
+	public userReactionBlockedCache: RedisKVCache<Set<string>>; // NOTE: 「被」リアクションBlockキャッシュ
 	public renoteMutingsCache: RedisKVCache<Set<string>>;
 	public userFollowingsCache: RedisKVCache<Record<string, Pick<MiFollowing, 'withReplies'> | undefined>>;
 
@@ -80,15 +82,31 @@ export class CacheService implements OnApplicationShutdown {
 		this.userBlockingCache = new RedisKVCache<Set<string>>(this.redisClient, 'userBlocking', {
 			lifetime: 1000 * 60 * 30, // 30m
 			memoryCacheLifetime: 1000 * 60, // 1m
-			fetcher: (key) => this.blockingsRepository.find({ where: { blockerId: key }, select: ['blockeeId'] }).then(xs => new Set(xs.map(x => x.blockeeId))),
+			fetcher: (key) => this.blockingsRepository.find({ where: { blockerId: key, isReactionBlock: false }, select: ['blockeeId'] }).then(xs => new Set(xs.map(x => x.blockeeId))),
 			toRedisConverter: (value) => JSON.stringify(Array.from(value)),
 			fromRedisConverter: (value) => new Set(JSON.parse(value)),
 		});
 
 		this.userBlockedCache = new RedisKVCache<Set<string>>(this.redisClient, 'userBlocked', {
 			lifetime: 1000 * 60 * 30, // 30m
 			memoryCacheLifetime: 1000 * 60, // 1m
-			fetcher: (key) => this.blockingsRepository.find({ where: { blockeeId: key }, select: ['blockerId'] }).then(xs => new Set(xs.map(x => x.blockerId))),
+			fetcher: (key) => this.blockingsRepository.find({ where: { blockeeId: key, isReactionBlock: false }, select: ['blockerId'] }).then(xs => new Set(xs.map(x => x.blockerId))),
+			toRedisConverter: (value) => JSON.stringify(Array.from(value)),
+			fromRedisConverter: (value) => new Set(JSON.parse(value)),
+		});
+
+		this.userReactionBlockingCache = new RedisKVCache<Set<string>>(this.redisClient, 'userReactionBlocking', {
+			lifetime: 1000 * 60 * 30, // 30m
+			memoryCacheLifetime: 1000 * 60, // 1m
+			fetcher: (key) => this.blockingsRepository.find({ where: { blockerId: key, isReactionBlock: true }, select: ['blockeeId'] }).then(xs => new Set(xs.map(x => x.blockeeId))),
+			toRedisConverter: (value) => JSON.stringify(Array.from(value)),
+			fromRedisConverter: (value) => new Set(JSON.parse(value)),
+		});
+
+		this.userReactionBlockedCache = new RedisKVCache<Set<string>>(this.redisClient, 'userReactionBlocked', {
+			lifetime: 1000 * 60 * 30, // 30m
+			memoryCacheLifetime: 1000 * 60, // 1m
+			fetcher: (key) => this.blockingsRepository.find({ where: { blockeeId: key, isReactionBlock: true }, select: ['blockerId'] }).then(xs => new Set(xs.map(x => x.blockerId))),
 			toRedisConverter: (value) => JSON.stringify(Array.from(value)),
 			fromRedisConverter: (value) => new Set(JSON.parse(value)),
 		});

packages/backend/src/core/CoreModule.ts

@@ -58,6 +58,7 @@ import { S3Service } from './S3Service.js';
 import { SignupService } from './SignupService.js';
 import { WebAuthnService } from './WebAuthnService.js';
 import { UserBlockingService } from './UserBlockingService.js';
+import { UserReactionBlockingService } from './UserReactionBlockingService.js';
 import { CacheService } from './CacheService.js';
 import { UserService } from './UserService.js';
 import { UserFollowingService } from './UserFollowingService.js';
@@ -202,6 +203,7 @@ const $S3Service: Provider = { provide: 'S3Service', useExisting: S3Service };
 const $SignupService: Provider = { provide: 'SignupService', useExisting: SignupService };
 const $WebAuthnService: Provider = { provide: 'WebAuthnService', useExisting: WebAuthnService };
 const $UserBlockingService: Provider = { provide: 'UserBlockingService', useExisting: UserBlockingService };
+const $UserReactionBlockingService: Provider = { provide: 'UserReactionBlockingService', useExisting: UserReactionBlockingService };
 const $CacheService: Provider = { provide: 'CacheService', useExisting: CacheService };
 const $UserService: Provider = { provide: 'UserService', useExisting: UserService };
 const $UserFollowingService: Provider = { provide: 'UserFollowingService', useExisting: UserFollowingService };
@@ -353,6 +355,7 @@ const $ApQuestionService: Provider = { provide: 'ApQuestionService', useExisting
 		SignupService,
 		WebAuthnService,
 		UserBlockingService,
+		UserReactionBlockingService,
 		CacheService,
 		UserService,
 		UserFollowingService,
@@ -500,6 +503,7 @@ const $ApQuestionService: Provider = { provide: 'ApQuestionService', useExisting
 		$SignupService,
 		$WebAuthnService,
 		$UserBlockingService,
+		$UserReactionBlockingService,
 		$CacheService,
 		$UserService,
 		$UserFollowingService,
@@ -648,6 +652,7 @@ const $ApQuestionService: Provider = { provide: 'ApQuestionService', useExisting
 		SignupService,
 		WebAuthnService,
 		UserBlockingService,
+		UserReactionBlockingService,
 		CacheService,
 		UserService,
 		UserFollowingService,
@@ -794,6 +799,7 @@ const $ApQuestionService: Provider = { provide: 'ApQuestionService', useExisting
 		$SignupService,
 		$WebAuthnService,
 		$UserBlockingService,
+		$UserReactionBlockingService,
 		$CacheService,
 		$UserService,
 		$UserFollowingService,

packages/backend/src/core/GlobalEventService.ts

@@ -223,6 +223,8 @@ export interface InternalEventTypes {
 	unfollow: { followerId: MiUser['id']; followeeId: MiUser['id']; };
 	blockingCreated: { blockerId: MiUser['id']; blockeeId: MiUser['id']; };
 	blockingDeleted: { blockerId: MiUser['id']; blockeeId: MiUser['id']; };
+	blockingReactionCreated: { blockerId: MiUser['id']; blockeeId: MiUser['id']; };
+	blockingReactionDeleted: { blockerId: MiUser['id']; blockeeId: MiUser['id']; };
 	policiesUpdated: MiRole['policies'];
 	roleCreated: MiRole;
 	roleDeleted: MiRole;

packages/backend/src/core/UserBlockingService.ts

@@ -73,6 +73,7 @@ export class UserBlockingService implements OnModuleInit {
 			blockerId: blocker.id,
 			blockee,
 			blockeeId: blockee.id,
+			isReactionBlock: false,
 		} as MiBlocking;
 
 		await this.blockingsRepository.insert(blocking);
@@ -160,6 +161,7 @@ export class UserBlockingService implements OnModuleInit {
 		const blocking = await this.blockingsRepository.findOneBy({
 			blockerId: blocker.id,
 			blockeeId: blockee.id,
+			isReactionBlock: false,
 		});
 
 		if (blocking == null) {
@@ -169,28 +171,23 @@ export class UserBlockingService implements OnModuleInit {
 
 		// Since we already have the blocker and blockee, we do not need to fetch
 		// them in the query above and can just manually insert them here.
-		blocking.blocker = blocker;
-		blocking.blockee = blockee;
+		// But we don't need to do this because we are not using them in this function.
+		// blocking.blocker = blocker;
+		// blocking.blockee = blockee;
 
 		await this.blockingsRepository.delete(blocking.id);
 
-		this.cacheService.userBlockingCache.refresh(blocker.id);
-		this.cacheService.userBlockedCache.refresh(blockee.id);
+		this.cacheService.userReactionBlockedCache.refresh(blocker.id);
+		this.cacheService.userReactionBlockedCache.refresh(blockee.id);
 
-		this.globalEventService.publishInternalEvent('blockingDeleted', {
+		this.globalEventService.publishInternalEvent('blockingReactionDeleted', {
 			blockerId: blocker.id,
 			blockeeId: blockee.id,
 		});
-
-		// deliver if remote bloking
-		if (this.userEntityService.isLocalUser(blocker) && this.userEntityService.isRemoteUser(blockee)) {
-			const content = this.apRendererService.addContext(this.apRendererService.renderUndo(this.apRendererService.renderBlock(blocking), blocker));
-			this.queueService.deliver(blocker, content, blockee.inbox, false);
-		}
 	}
 
 	@bindThis
 	public async checkBlocked(blockerId: MiUser['id'], blockeeId: MiUser['id']): Promise<boolean> {
-		return (await this.cacheService.userBlockingCache.fetch(blockerId)).has(blockeeId);
+		return (await this.cacheService.userReactionBlockingCache.fetch(blockerId)).has(blockeeId);
 	}
 }

packages/backend/src/core/UserReactionBlockingService.ts

@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: syuilo and misskey-project
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { IdService } from '@/core/IdService.js';
+import type { MiUser } from '@/models/User.js';
+import type { MiBlocking } from '@/models/Blocking.js';
+import { QueueService } from '@/core/QueueService.js';
+import { GlobalEventService } from '@/core/GlobalEventService.js';
+import { DI } from '@/di-symbols.js';
+import type { BlockingsRepository, UserListsRepository } from '@/models/_.js';
+import Logger from '@/logger.js';
+import { UserEntityService } from '@/core/entities/UserEntityService.js';
+import { ApRendererService } from '@/core/activitypub/ApRendererService.js';
+import { LoggerService } from '@/core/LoggerService.js';
+import { UserWebhookService } from '@/core/UserWebhookService.js';
+import { bindThis } from '@/decorators.js';
+import { CacheService } from '@/core/CacheService.js';
+import { UserFollowingService } from '@/core/UserFollowingService.js';
+
+@Injectable()
+export class UserReactionBlockingService {
+	private logger: Logger;
+	private userFollowingService: UserFollowingService;
+
+	constructor(
+		private moduleRef: ModuleRef,
+
+		@Inject(DI.blockingsRepository)
+		private blockingsRepository: BlockingsRepository,
+
+		@Inject(DI.userListsRepository)
+		private userListsRepository: UserListsRepository,
+
+		private cacheService: CacheService,
+		private userEntityService: UserEntityService,
+		private idService: IdService,
+		private queueService: QueueService,
+		private globalEventService: GlobalEventService,
+		private webhookService: UserWebhookService,
+		private apRendererService: ApRendererService,
+		private loggerService: LoggerService,
+	) {
+		this.logger = this.loggerService.getLogger('user-block');
+	}
+
+	@bindThis
+	public async block(blocker: MiUser, blockee: MiUser, silent = false) {
+		const blocking = {
+			id: this.idService.gen(),
+			blocker,
+			blockerId: blocker.id,
+			blockee,
+			blockeeId: blockee.id,
+			isReactionBlock: true,
+		} satisfies MiBlocking;
+
+		await this.blockingsRepository.insert(blocking);
+
+		this.cacheService.userReactionBlockingCache.refresh(blocker.id);
+		this.cacheService.userReactionBlockedCache.refresh(blockee.id);
+
+		this.globalEventService.publishInternalEvent('blockingReactionCreated', {
+			blockerId: blocker.id,
+			blockeeId: blockee.id,
+		});
+	}
+
+	@bindThis
+	public async unblock(blocker: MiUser, blockee: MiUser) {
+		const blocking = await this.blockingsRepository.findOneBy({
+			blockerId: blocker.id,
+			blockeeId: blockee.id,
+			isReactionBlock: true,
+		});
+
+		if (blocking == null) {
+			this.logger.warn('Unblock requested, but the target was not blocked.');
+			return;
+		}
+
+		// Since we already have the blocker and blockee, we do not need to fetch
+		// them in the query above and can just manually insert them here.
+		blocking.blocker = blocker;
+		blocking.blockee = blockee;
+
+		await this.blockingsRepository.delete(blocking.id);
+
+		this.cacheService.userBlockingCache.refresh(blocker.id);
+		this.cacheService.userBlockedCache.refresh(blockee.id);
+
+		this.globalEventService.publishInternalEvent('blockingDeleted', {
+			blockerId: blocker.id,
+			blockeeId: blockee.id,
+		});
+
+		// deliver if remote bloking
+		if (this.userEntityService.isLocalUser(blocker) && this.userEntityService.isRemoteUser(blockee)) {
+			const content = this.apRendererService.addContext(this.apRendererService.renderUndo(this.apRendererService.renderBlock(blocking), blocker));
+			this.queueService.deliver(blocker, content, blockee.inbox, false);
+		}
+	}
+
+	@bindThis
+	public async checkBlocked(blockerId: MiUser['id'], blockeeId: MiUser['id']): Promise<boolean> {
+		return (await this.cacheService.userBlockingCache.fetch(blockerId)).has(blockeeId);
+	}
+}