fix list and instance caching, manage all CacheService caches, and fix list "with replies" setting

packages/backend/src/server/api/endpoints/notes/translate.ts

@@ -12,11 +12,12 @@ import { GetterService } from '@/server/api/GetterService.js';
 import { RoleService } from '@/core/RoleService.js';
 import type { MiMeta, MiNote } from '@/models/_.js';
 import { DI } from '@/di-symbols.js';
-import { CacheService } from '@/core/CacheService.js';
 import { hasText } from '@/models/Note.js';
 import { ApiLoggerService } from '@/server/api/ApiLoggerService.js';
 import { NoteVisibilityService } from '@/core/NoteVisibilityService.js';
-import { ApiError } from '../../error.js';
+import { CacheManagementService, type ManagedRedisKVCache } from '@/core/CacheManagementService.js';
+import { ApiError } from '@/server/api/error.js';
+import { bindThis } from '@/decorators.js';
 
 export const meta = {
 	tags: ['notes'],
@@ -75,6 +76,8 @@ export const paramDef = {
 
 @Injectable()
 export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-disable-line import/no-default-export
+	private readonly translationsCache: ManagedRedisKVCache<CachedTranslationEntity>;
+
 	constructor(
 		@Inject(DI.meta)
 		private serverSettings: MiMeta,
@@ -83,9 +86,10 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 		private getterService: GetterService,
 		private httpRequestService: HttpRequestService,
 		private roleService: RoleService,
-		private readonly cacheService: CacheService,
 		private readonly loggerService: ApiLoggerService,
 		private readonly noteVisibilityService: NoteVisibilityService,
+
+		cacheManagementService: CacheManagementService,
 	) {
 		super(meta, paramDef, async (ps, me) => {
 			const note = await this.getterService.getNote(ps.noteId).catch(err => {
@@ -110,7 +114,7 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 			let targetLang = ps.targetLang;
 			if (targetLang.includes('-')) targetLang = targetLang.split('-')[0];
 
-			let response = await this.cacheService.getCachedTranslation(note, targetLang);
+			let response = await this.getCachedTranslation(note, targetLang);
 			if (!response) {
 				this.loggerService.logger.debug(`Fetching new translation for note=${note.id} lang=${targetLang}`);
 				response = await this.fetchTranslation(note, targetLang);
@@ -118,10 +122,15 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 					throw new ApiError(meta.errors.translationFailed);
 				}
 
-				await this.cacheService.setCachedTranslation(note, targetLang, response);
+				await this.setCachedTranslation(note, targetLang, response);
 			}
 			return response;
 		});
+
+		this.translationsCache = cacheManagementService.createRedisKVCache<CachedTranslationEntity>('translations', {
+			lifetime: 1000 * 60 * 60 * 24 * 7, // 1 week,
+			memoryCacheLifetime: 1000 * 60, // 1 minute
+		});
 	}
 
 	private async fetchTranslation(note: MiNote & { text: string }, targetLang: string) {
@@ -219,4 +228,43 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 
 		return null;
 	}
+
+	@bindThis
+	private async getCachedTranslation(note: MiNote, targetLang: string): Promise<CachedTranslation | null> {
+		const cacheKey = `${note.id}@${targetLang}`;
+
+		// Use cached translation, if present and up-to-date
+		const cached = await this.translationsCache.get(cacheKey);
+		if (cached && cached.u === note.updatedAt?.valueOf()) {
+			return {
+				sourceLang: cached.l,
+				text: cached.t,
+			};
+		}
+
+		// No cache entry :(
+		return null;
+	}
+
+	@bindThis
+	private async setCachedTranslation(note: MiNote, targetLang: string, translation: CachedTranslation): Promise<void> {
+		const cacheKey = `${note.id}@${targetLang}`;
+
+		await this.translationsCache.set(cacheKey, {
+			l: translation.sourceLang,
+			t: translation.text,
+			u: note.updatedAt?.valueOf(),
+		});
+	}
+}
+
+interface CachedTranslation {
+	sourceLang: string | undefined;
+	text: string | undefined;
+}
+
+interface CachedTranslationEntity {
+	l?: string;
+	t?: string;
+	u?: number;
 }

packages/backend/src/server/api/endpoints/users/lists/push.ts

@@ -9,6 +9,7 @@ import type { UserListsRepository, UserListMembershipsRepository, BlockingsRepos
 import { Endpoint } from '@/server/api/endpoint-base.js';
 import { GetterService } from '@/server/api/GetterService.js';
 import { UserListService } from '@/core/UserListService.js';
+import { CacheService } from '@/core/CacheService.js';
 import { DI } from '@/di-symbols.js';
 import { ApiError } from '../../../error.js';
 
@@ -84,44 +85,34 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 
 		private getterService: GetterService,
 		private userListService: UserListService,
+		private readonly cacheService: CacheService,
 	) {
 		super(meta, paramDef, async (ps, me) => {
-			// Fetch the list
-			const userList = await this.userListsRepository.findOneBy({
-				id: ps.listId,
-				userId: me.id,
-			});
+			const [user, blockings, userList, exist] = await Promise.all([
+				this.cacheService.findOptionalUserById(ps.userId),
+				this.cacheService.userBlockingCache.fetch(ps.userId),
+				this.userListsRepository.findOneBy({
+					id: ps.listId,
+					userId: me.id,
+				}),
+				this.cacheService.listUserMembershipsCache.fetch(ps.listId).then(ms => ms.has(ps.userId)),
+			]);
 
 			if (userList == null) {
 				throw new ApiError(meta.errors.noSuchList);
 			}
 
-			// Fetch the user
-			const user = await this.getterService.getUser(ps.userId).catch(err => {
-				if (err.id === '15348ddd-432d-49c2-8a5a-8069753becff') throw new ApiError(meta.errors.noSuchUser);
-				throw err;
-			});
+			if (!user) {
+				throw new ApiError(meta.errors.noSuchUser);
+			}
 
-			// Check blocking
 			if (user.id !== me.id) {
-				const blockExist = await this.blockingsRepository.exists({
-					where: {
-						blockerId: user.id,
-						blockeeId: me.id,
-					},
-				});
+				const blockExist = blockings.has(me.id);
 				if (blockExist) {
 					throw new ApiError(meta.errors.youHaveBeenBlocked);
 				}
 			}
 
-			const exist = await this.userListMembershipsRepository.exists({
-				where: {
-					userListId: userList.id,
-					userId: user.id,
-				},
-			});
-
 			if (exist) {
 				throw new ApiError(meta.errors.alreadyAdded);
 			}

packages/backend/src/server/api/stream/channels/user-list.ts

@@ -19,8 +19,6 @@ class UserListChannel extends Channel {
 	public static requireCredential = true as const;
 	public static kind = 'read:account';
 	private listId: string;
-	private membershipsMap: Record<string, Pick<MiUserListMembership, 'withReplies'> | undefined> = {};
-	private listUsersClock: NodeJS.Timeout;
 	private withFiles: boolean;
 	private withRenotes: boolean;
 
@@ -57,27 +55,6 @@ class UserListChannel extends Channel {
 		this.subscriber?.on(`userListStream:${this.listId}`, this.send);
 
 		this.subscriber?.on('notesStream', this.onNote);
-
-		this.updateListUsers();
-		this.listUsersClock = setInterval(this.updateListUsers, 5000);
-	}
-
-	@bindThis
-	private async updateListUsers() {
-		const memberships = await this.userListMembershipsRepository.find({
-			where: {
-				userListId: this.listId,
-			},
-			select: ['userId'],
-		});
-
-		const membershipsMap: Record<string, Pick<MiUserListMembership, 'withReplies'> | undefined> = {};
-		for (const membership of memberships) {
-			membershipsMap[membership.userId] = {
-				withReplies: membership.withReplies,
-			};
-		}
-		this.membershipsMap = membershipsMap;
 	}
 
 	@bindThis
@@ -87,9 +64,10 @@ class UserListChannel extends Channel {
 
 		if (this.withFiles && (note.fileIds == null || note.fileIds.length === 0)) return;
 
-		if (!Object.hasOwn(this.membershipsMap, note.userId)) return;
+		const memberships = await this.cacheService.listUserMembershipsCache.fetch(this.listId);
+		if (!memberships.has(note.userId)) return;
 
-		const { accessible, silence } = await this.checkNoteVisibility(note, { includeReplies: true });
+		const { accessible, silence } = await this.checkNoteVisibility(note, { includeReplies: true, listContext: this.listId });
 		if (!accessible || silence) return;
 		if (!this.withRenotes && isPackedPureRenote(note)) return;
 
@@ -102,8 +80,6 @@ class UserListChannel extends Channel {
 		// Unsubscribe events
 		this.subscriber?.off(`userListStream:${this.listId}`, this.send);
 		this.subscriber?.off('notesStream', this.onNote);
-
-		clearInterval(this.listUsersClock);
 	}
 }