Reduced number of database queries in dispatchers (#1512)

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

- in [dispatchers.ts](https://github.com/TryGhost/ActivityPub/blob/main/src/dispatchers.ts), we currently make 3 database queries to load the host site, account and user
- with this change, we will make a single database query to load all the necessary host data
- note: in `keypairDispatcher`, we do an additional database query to retrieve the public/private key pair, as a tradeoff between safety and performance gains. We don't want to expose the public/private key pair to the Account entity, as there is a risk to inadvertently expose the private key - instead, we chose to do an additional database query

Author: sagzy

src/account/account.repository.knex.ts

@@ -372,6 +372,24 @@ export class KnexAccountRepository {
         return this.mapRowToAccountEntity(accountRow);
     }
 
+    async getKeyPair(
+        accountId: number,
+    ): Promise<{ publicKey: string | null; privateKey: string | null } | null> {
+        const row = await this.db('accounts')
+            .select('ap_public_key', 'ap_private_key')
+            .where({ id: accountId })
+            .first();
+
+        if (!row) {
+            return null;
+        }
+
+        return {
+            publicKey: row.ap_public_key,
+            privateKey: row.ap_private_key,
+        };
+    }
+
     private async mapRowToAccountEntity(row: AccountRow): Promise<Account> {
         if (!row.uuid) {
             row.uuid = randomUUID();

src/account/account.service.integration.test.ts

@@ -1397,4 +1397,35 @@ describe('AccountService', () => {
             expect(backoff).toBeNull();
         });
     });
+
+    describe('getKeyPair', () => {
+        it('returns keypair with both keys for an internal account', async () => {
+            const [account] = await fixtureManager.createInternalAccount();
+
+            const result = await service.getKeyPair(account.id);
+
+            expect(result).toStrictEqual([
+                null,
+                {
+                    publicKey: expect.any(String),
+                    privateKey: expect.any(String),
+                },
+            ]);
+        });
+
+        it('returns key-pair-not-found error for an external account', async () => {
+            // An external account does not have a private key
+            const account = await fixtureManager.createExternalAccount();
+
+            const result = await service.getKeyPair(account.id);
+
+            expect(result).toStrictEqual(['key-pair-not-found', null]);
+        });
+
+        it('returns account-not-found error when account does not exist', async () => {
+            const result = await service.getKeyPair(999999);
+
+            expect(result).toStrictEqual(['account-not-found', null]);
+        });
+    });
 });

src/account/account.service.ts

@@ -867,4 +867,28 @@ export class AccountService {
             backoffSeconds: backoff.backoff_seconds,
         };
     }
+
+    async getKeyPair(
+        accountId: number,
+    ): Promise<
+        Result<
+            { publicKey: string; privateKey: string },
+            'account-not-found' | 'key-pair-not-found'
+        >
+    > {
+        const account = await this.accountRepository.getKeyPair(accountId);
+
+        if (!account) {
+            return error('account-not-found');
+        }
+
+        if (!account.publicKey || !account.privateKey) {
+            return error('key-pair-not-found');
+        }
+
+        return ok({
+            publicKey: account.publicKey,
+            privateKey: account.privateKey,
+        });
+    }
 }