merge: Cache note translations in Redis (!1027)

View MR for information: https://activitypub.software/TransFem-org/Sharkey/-/merge_requests/1027

Approved-by: dakkar <dakkar@thenautilus.net>
Approved-by: Marie <github@yuugi.dev>

packages/backend/src/core/CacheService.ts

@@ -6,7 +6,7 @@
 import { Inject, Injectable } from '@nestjs/common';
 import * as Redis from 'ioredis';
 import { IsNull } from 'typeorm';
-import type { BlockingsRepository, FollowingsRepository, MutingsRepository, RenoteMutingsRepository, MiUserProfile, UserProfilesRepository, UsersRepository, MiFollowing } from '@/models/_.js';
+import type { BlockingsRepository, FollowingsRepository, MutingsRepository, RenoteMutingsRepository, MiUserProfile, UserProfilesRepository, UsersRepository, MiFollowing, MiNote } from '@/models/_.js';
 import { MemoryKVCache, RedisKVCache } from '@/misc/cache.js';
 import type { MiLocalUser, MiUser } from '@/models/User.js';
 import { DI } from '@/di-symbols.js';
@@ -22,6 +22,17 @@ export interface FollowStats {
 	remoteFollowers: number;
 }
 
+export interface CachedTranslation {
+	sourceLang: string | undefined;
+	text: string | undefined;
+}
+
+interface CachedTranslationEntity {
+	l?: string;
+	t?: string;
+	u?: number;
+}
+
 @Injectable()
 export class CacheService implements OnApplicationShutdown {
 	public userByIdCache: MemoryKVCache<MiUser>;
@@ -35,6 +46,7 @@ export class CacheService implements OnApplicationShutdown {
 	public renoteMutingsCache: RedisKVCache<Set<string>>;
 	public userFollowingsCache: RedisKVCache<Record<string, Pick<MiFollowing, 'withReplies'> | undefined>>;
 	private readonly userFollowStatsCache = new MemoryKVCache<FollowStats>(1000 * 60 * 10); // 10 minutes
+	private readonly translationsCache: RedisKVCache<CachedTranslationEntity>;
 
 	constructor(
 		@Inject(DI.redis)
@@ -124,6 +136,11 @@ export class CacheService implements OnApplicationShutdown {
 			fromRedisConverter: (value) => JSON.parse(value),
 		});
 
+		this.translationsCache = new RedisKVCache<CachedTranslationEntity>(this.redisClient, 'translations', {
+			lifetime: 1000 * 60 * 60 * 24 * 7, // 1 week,
+			memoryCacheLifetime: 1000 * 60, // 1 minute
+		});
+
 		// NOTE: チャンネルのフォロー状況キャッシュはChannelFollowingServiceで行っている
 
 		this.redisForSub.on('message', this.onMessage);
@@ -253,6 +270,34 @@ export class CacheService implements OnApplicationShutdown {
 		});
 	}
 
+	@bindThis
+	public 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
+	public 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(),
+		});
+	}
+
 	@bindThis
 	public dispose(): void {
 		this.redisForSub.off('message', this.onMessage);

packages/backend/src/misc/cache.ts

@@ -19,16 +19,16 @@ export class RedisKVCache<T> {
 		opts: {
 			lifetime: RedisKVCache<T>['lifetime'];
 			memoryCacheLifetime: number;
-			fetcher: RedisKVCache<T>['fetcher'];
+			fetcher?: RedisKVCache<T>['fetcher'];
-			toRedisConverter: RedisKVCache<T>['toRedisConverter'];
+			toRedisConverter?: RedisKVCache<T>['toRedisConverter'];
-			fromRedisConverter: RedisKVCache<T>['fromRedisConverter'];
+			fromRedisConverter?: RedisKVCache<T>['fromRedisConverter'];
 		},
 	) {
 		this.lifetime = opts.lifetime;
 		this.memoryCache = new MemoryKVCache(opts.memoryCacheLifetime);
-		this.fetcher = opts.fetcher;
+		this.fetcher = opts.fetcher ?? (() => { throw new Error('fetch not supported - use get/set directly'); });
-		this.toRedisConverter = opts.toRedisConverter;
+		this.toRedisConverter = opts.toRedisConverter ?? ((value) => JSON.stringify(value));
-		this.fromRedisConverter = opts.fromRedisConverter;
+		this.fromRedisConverter = opts.fromRedisConverter ?? ((value) => JSON.parse(value));
 	}
 
 	@bindThis

packages/backend/src/models/Note.ts

@@ -264,3 +264,7 @@ export type IMentionedRemoteUsers = {
 	username: string;
 	host: string;
 }[];
+
+export function hasText(note: MiNote): note is MiNote & { text: string } {
+	return note.text != null;
+}

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

@@ -10,22 +10,28 @@ import { NoteEntityService } from '@/core/entities/NoteEntityService.js';
 import { HttpRequestService } from '@/core/HttpRequestService.js';
 import { GetterService } from '@/server/api/GetterService.js';
 import { RoleService } from '@/core/RoleService.js';
-import { ApiError } from '../../error.js';
+import type { MiMeta, MiNote } from '@/models/_.js';
-import { MiMeta } 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 { ApiError } from '../../error.js';
 
 export const meta = {
 	tags: ['notes'],
 
+	// TODO allow unauthenticated if default template allows?
+	//   Maybe a value 'optional' that allows unauthenticated OR a token w/ appropriate role.
+	//   This will allow unauthenticated requests without leaking post data to restricted clients.
 	requireCredential: true,
 	kind: 'read:account',
 
 	res: {
 		type: 'object',
-		optional: true, nullable: false,
+		optional: false, nullable: false,
 		properties: {
-			sourceLang: { type: 'string' },
+			sourceLang: { type: 'string', optional: true, nullable: false },
-			text: { type: 'string' },
+			text: { type: 'string', optional: true, nullable: false },
 		},
 	},
 
@@ -45,6 +51,11 @@ export const meta = {
 			code: 'CANNOT_TRANSLATE_INVISIBLE_NOTE',
 			id: 'ea29f2ca-c368-43b3-aaf1-5ac3e74bbe5d',
 		},
+		translationFailed: {
+			message: 'Failed to translate note. Please try again later or contact an administrator for assistance.',
+			code: 'TRANSLATION_FAILED',
+			id: '4e7a1a4f-521c-4ba2-b10a-69e5e2987b2f',
+		},
 	},
 
 	// 10 calls per 5 seconds
@@ -73,6 +84,8 @@ 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,
 	) {
 		super(meta, paramDef, async (ps, me) => {
 			const policies = await this.roleService.getUserPolicies(me.id);
@@ -89,8 +102,8 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 				throw new ApiError(meta.errors.cannotTranslateInvisibleNote);
 			}
 
-			if (note.text == null) {
+			if (!hasText(note)) {
-				return;
+				return {};
 			}
 
 			const canDeeplFree = this.serverSettings.deeplFreeMode && !!this.serverSettings.deeplFreeInstance;
@@ -101,13 +114,33 @@ 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);
+			if (!response) {
+				this.loggerService.logger.debug(`Fetching new translation for note=${note.id} lang=${targetLang}`);
+				response = await this.fetchTranslation(note, targetLang);
+				if (!response) {
+					throw new ApiError(meta.errors.translationFailed);
+				}
+
+				await this.cacheService.setCachedTranslation(note, targetLang, response);
+			}
+			return response;
+		});
+	}
+
+	private async fetchTranslation(note: MiNote & { text: string }, targetLang: string) {
+		// Load-bearing try/catch - removing this will shift indentation and cause ~80 lines of upstream merge conflicts
+		try {
+			// Ignore deeplFreeInstance unless deeplFreeMode is set
+			const deeplFreeInstance = this.serverSettings.deeplFreeMode ? this.serverSettings.deeplFreeInstance : null;
+
 			// DeepL/DeepLX handling
-			if (canDeepl) {
+			if (this.serverSettings.deeplAuthKey || deeplFreeInstance) {
 				const params = new URLSearchParams();
 				if (this.serverSettings.deeplAuthKey) params.append('auth_key', this.serverSettings.deeplAuthKey);
 				params.append('text', note.text);
 				params.append('target_lang', targetLang);
-				const endpoint = canDeeplFree ? this.serverSettings.deeplFreeInstance as string : this.serverSettings.deeplIsPro ? 'https://api.deepl.com/v2/translate' : 'https://api-free.deepl.com/v2/translate';
+				const endpoint = deeplFreeInstance ?? this.serverSettings.deeplIsPro ? 'https://api.deepl.com/v2/translate' : 'https://api-free.deepl.com/v2/translate';
 
 				const res = await this.httpRequestService.send(endpoint, {
 					method: 'POST',
@@ -152,8 +185,8 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 			}
 
 			// LibreTranslate handling
-			if (canLibre) {
+			if (this.serverSettings.libreTranslateURL) {
-				const res = await this.httpRequestService.send(this.serverSettings.libreTranslateURL as string, {
+				const res = await this.httpRequestService.send(this.serverSettings.libreTranslateURL, {
 					method: 'POST',
 					headers: {
 						'Content-Type': 'application/json',
@@ -184,8 +217,10 @@ export default class extends Endpoint<typeof meta, typeof paramDef> { // eslint-
 					text: json.translatedText,
 				};
 			}
+		} catch (e) {
+			this.loggerService.logger.error('Unhandled error from translation API: ', { e });
+		}
 
-			return;
+		return null;
-		});
 	}
 }

packages/frontend/src/utility/get-note-menu.ts

@@ -293,12 +293,12 @@ export function getNoteMenu(props: {
 	async function translate(): Promise<void> {
 		if (props.translation.value != null) return;
 		props.translating.value = true;
-		const res = await misskeyApi('notes/translate', {
+		props.translation.value = await misskeyApi('notes/translate', {
 			noteId: appearNote.id,
 			targetLang: miLocalStorage.getItem('lang') ?? navigator.language,
-		});
+		}).finally(() => {
 			props.translating.value = false;
-		props.translation.value = res;
+		});
 	}
 
 	const menuItems: MenuItem[] = [];

packages/misskey-js/src/autogen/types.ts

@@ -28711,15 +28711,11 @@ export type operations = {
       200: {
         content: {
           'application/json': {
-            sourceLang: string;
+            sourceLang?: string;
-            text: string;
+            text?: string;
           };
         };
       };
-      /** @description OK (without any results) */
-      204: {
-        content: never;
-      };
       /** @description Client error */
       400: {
         content: {