Cached importJwk and data host data to improve cpu usage

ref https://linear.app/ghost/issue/BER-3241

Author: rmgpinto

src/dispatchers.ts

@@ -104,8 +104,17 @@ export const actorDispatcher = (hostDataContextLoader: HostDataContextLoader) =>
 export const keypairDispatcher = (
     accountService: AccountService,
     hostDataContextLoader: HostDataContextLoader,
-) =>
-    async function keypairDispatcher(ctx: FedifyContext, identifier: string) {
+) => {
+    const MAX_CACHE_SIZE = 1000;
+    const cryptoKeyCache = new Map<
+        number,
+        { publicKey: CryptoKey; privateKey: CryptoKey }
+    >();
+
+    return async function keypairDispatcher(
+        ctx: FedifyContext,
+        identifier: string,
+    ) {
         const hostData = await hostDataContextLoader.loadDataForHost(ctx.host);
 
         if (isError(hostData)) {
@@ -145,6 +154,11 @@ export const keypairDispatcher = (
 
         const { account } = getValue(hostData);
 
+        const cached = cryptoKeyCache.get(account.id);
+        if (cached) {
+            return [cached];
+        }
+
         const keyPair = await accountService.getKeyPair(account.id);
 
         if (isError(keyPair)) {
@@ -176,18 +190,22 @@ export const keypairDispatcher = (
         const { publicKey, privateKey } = getValue(keyPair);
 
         try {
-            return [
-                {
-                    publicKey: await importJwk(
-                        JSON.parse(publicKey) as JsonWebKey,
-                        'public',
-                    ),
-                    privateKey: await importJwk(
-                        JSON.parse(privateKey) as JsonWebKey,
-                        'private',
-                    ),
-                },
-            ];
+            const imported = {
+                publicKey: await importJwk(
+                    JSON.parse(publicKey) as JsonWebKey,
+                    'public',
+                ),
+                privateKey: await importJwk(
+                    JSON.parse(privateKey) as JsonWebKey,
+                    'private',
+                ),
+            };
+
+            if (cryptoKeyCache.size < MAX_CACHE_SIZE) {
+                cryptoKeyCache.set(account.id, imported);
+            }
+
+            return [imported];
         } catch (error) {
             ctx.data.logger.error(
                 'Could not parse keypair for {host} (identifier: {identifier}): {error}',
@@ -200,6 +218,7 @@ export const keypairDispatcher = (
             return [];
         }
     };
+};
 
 export function createAcceptHandler(accountService: AccountService) {
     return async function handleAccept(ctx: FedifyContext, accept: Accept) {

src/http/host-data-context-loader.ts

@@ -6,20 +6,55 @@ import type { Result } from '@/core/result';
 import { error, ok } from '@/core/result';
 import type { Site } from '@/site/site.service';
 
+type HostDataResult = Result<
+    { site: Site; account: Account },
+    'site-not-found' | 'account-not-found' | 'multiple-users-for-site'
+>;
+
+interface CacheEntry {
+    result: HostDataResult;
+    expiry: number;
+}
+
 export class HostDataContextLoader {
+    private static readonly CACHE_TTL_MS = 60_000;
+    private static readonly MAX_CACHE_SIZE = 1000;
+    private static readonly CACHE_ENABLED =
+        process.env.NODE_ENV === 'production';
+    private readonly cache = new Map<string, CacheEntry>();
+
     constructor(
         readonly db: Knex,
         readonly accountRepository: KnexAccountRepository,
     ) {}
 
-    async loadDataForHost(
-        host: string,
-    ): Promise<
-        Result<
-            { site: Site; account: Account },
-            'site-not-found' | 'account-not-found' | 'multiple-users-for-site'
-        >
-    > {
+    async loadDataForHost(host: string): Promise<HostDataResult> {
+        if (!HostDataContextLoader.CACHE_ENABLED) {
+            return this.queryDataForHost(host);
+        }
+
+        const now = Date.now();
+        const cached = this.cache.get(host);
+
+        if (cached && cached.expiry > now) {
+            return cached.result;
+        }
+
+        const result = await this.queryDataForHost(host);
+
+        if (this.cache.size >= HostDataContextLoader.MAX_CACHE_SIZE) {
+            this.cache.delete(this.cache.keys().next().value!);
+        }
+
+        this.cache.set(host, {
+            result,
+            expiry: now + HostDataContextLoader.CACHE_TTL_MS,
+        });
+
+        return result;
+    }
+
+    private async queryDataForHost(host: string): Promise<HostDataResult> {
         const results = await this.db('sites')
             .leftJoin('users', 'users.site_id', 'sites.id')
             .leftJoin('accounts', 'accounts.id', 'users.account_id')