Refactored createGetAccountPostsHandler | Moved posts and liked post queries to AccountPostView (#544)

Ref https://linear.app/ghost/issue/AP-1024

- Moved posts and liked post queries from PostService to AccountPostView
- Added logic to fetch post for local and remote accounts to AccountPostView
- Refactored createGetAccountPostsHandler to use AccountPostView
- Added tests for new AccountPostView

Author: vershwal

src/account/account.entity.ts

@@ -3,6 +3,8 @@ import { BaseEntity } from '../core/base.entity';
 import { type CreatePostType, PostType } from '../post/post.entity';
 import type { Site } from '../site/site.service';
 
+export type PersistedAccount = Account & { id: number };
+
 export interface AccountData {
     id: number;
     uuid: string | null;

src/app.ts

@@ -114,6 +114,7 @@ import {
     handleCreateNote,
 } from './http/api';
 import { AccountFollowsView } from './http/api/views/account.follows.view';
+import { AccountPostsView } from './http/api/views/account.posts.view';
 import { createWebFingerHandler } from './http/handler/webfinger';
 import { spanWrapper } from './instrumentation';
 import { KnexKvStore } from './knex.kvstore';
@@ -272,6 +273,7 @@ const postService = new PostService(
 );
 
 const accountFollowsView = new AccountFollowsView(client, fedifyContextFactory);
+const accountPostsView = new AccountPostsView(client, fedifyContextFactory);
 const siteService = new SiteService(client, accountService, {
     getSiteSettings: getSiteSettings,
 });
@@ -998,13 +1000,19 @@ app.get(
     '/.ghost/activitypub/posts/:handle',
     requireRole(GhostRole.Owner, GhostRole.Administrator),
     spanWrapper(
-        createGetAccountPostsHandler(postService, accountRepository, fedify),
+        createGetAccountPostsHandler(
+            accountRepository,
+            accountPostsView,
+            fedifyContextFactory,
+        ),
     ),
 );
 app.get(
     '/.ghost/activitypub/posts/:handle/liked',
     requireRole(GhostRole.Owner, GhostRole.Administrator),
-    spanWrapper(createGetAccountLikedPostsHandler(accountService, postService)),
+    spanWrapper(
+        createGetAccountLikedPostsHandler(accountService, accountPostsView),
+    ),
 );
 app.get(
     '/.ghost/activitypub/account/:handle/follows/:type',

src/http/api/account.ts

@@ -1,13 +1,12 @@
 import type { Federation } from '@fedify/fedify';
-import type { Account } from 'account/account.entity';
+import type { Account, PersistedAccount } from 'account/account.entity';
 import type { KnexAccountRepository } from 'account/account.repository.knex';
 import type { AccountService } from 'account/account.service';
 import type { FedifyContextFactory } from 'activitypub/fedify-context.factory';
 import type { AppContext, ContextData } from 'app';
 import { exhaustiveCheck, getError, getValue, isError } from 'core/result';
 import { isHandle } from 'helpers/activitypub/actor';
 import { lookupAPIdByHandle } from 'lookup-helpers';
-import type { GetProfileDataResult, PostService } from 'post/post.service';
 import { z } from 'zod';
 import {
     getAccountDTOByHandle,
@@ -18,7 +17,10 @@ import type {
     AccountFollows,
     AccountFollowsView,
 } from './views/account.follows.view';
-
+import type {
+    AccountPosts,
+    AccountPostsView,
+} from './views/account.posts.view';
 /**
  * Default number of posts to return in a profile
  */
@@ -218,9 +220,9 @@ function validateRequestParams(ctx: AppContext) {
  * @param profileService Profile service instance
  */
 export function createGetAccountPostsHandler(
-    postService: PostService,
     accountRepository: KnexAccountRepository,
-    fedify: Federation<ContextData>,
+    accountPostsView: AccountPostsView,
+    fedifyContextFactory: FedifyContextFactory,
 ) {
     /**
      * Handle a request for a list of posts by an account
@@ -234,119 +236,86 @@ export function createGetAccountPostsHandler(
         }
 
         const logger = ctx.get('logger');
-        let account: Account | null = null;
-        const db = ctx.get('db');
-
-        const apCtx = fedify.createContext(ctx.req.raw as Request, {
-            db,
-            globaldb: ctx.get('globaldb'),
-            logger,
-        });
+        const site = ctx.get('site');
 
         const handle = ctx.req.param('handle');
         if (!handle) {
             return new Response(null, { status: 400 });
         }
 
-        const defaultAccount = await accountRepository.getBySite(
-            ctx.get('site'),
-        );
+        const currentContextAccount = (await accountRepository.getBySite(
+            site,
+        )) as PersistedAccount;
 
-        if (!defaultAccount || !defaultAccount.id) {
-            return new Response(null, { status: 400 });
-        }
+        let accountPosts: AccountPosts;
 
         // We are using the keyword 'me', if we want to get the posts of the current user
         if (handle === 'me') {
-            account = defaultAccount;
+            accountPosts = await accountPostsView.getPostsByAccount(
+                currentContextAccount.id,
+                currentContextAccount.id,
+                params.limit,
+                params.cursor,
+            );
         } else {
-            if (!isHandle(handle)) {
-                return new Response(null, { status: 400 });
-            }
+            const ctx = fedifyContextFactory.getFedifyContext();
+            const apId = await lookupAPIdByHandle(ctx, handle);
 
-            const apId = await lookupAPIdByHandle(apCtx, handle);
-            if (apId) {
-                account = await accountRepository.getByApId(new URL(apId));
+            if (!apId) {
+                return new Response(`AP ID not found for handle: ${handle}`, {
+                    status: 400,
+                });
             }
-        }
-
-        const result: GetProfileDataResult = {
-            results: [],
-            nextCursor: null,
-        };
 
-        try {
-            //If we found the account in our db and it's an internal account, do an internal lookup
-            if (account?.isInternal && account.id) {
-                const postResult = await postService.getPostsByAccount(
-                    account.id,
-                    defaultAccount.id,
-                    params.limit,
-                    params.cursor,
-                );
+            const account = (await accountRepository.getByApId(
+                new URL(apId),
+            )) as PersistedAccount;
 
-                result.results = postResult.results;
-                result.nextCursor = postResult.nextCursor;
-            } else {
-                //Otherwise, do a remote lookup to fetch the posts
-                const postResult = await postService.getPostsByRemoteLookUp(
-                    defaultAccount.id,
-                    defaultAccount.apId,
-                    handle,
-                    params.cursor || '',
-                );
-                if (postResult instanceof Error) {
-                    throw postResult;
-                }
-                if (isError(postResult)) {
-                    const error = getError(postResult);
-                    switch (error) {
-                        case 'invalid-next-parameter':
-                            logger.error('Invalid next parameter');
-                            return new Response(null, { status: 400 });
-                        case 'not-an-actor':
-                            logger.error(`Actor not found for ${handle}`);
-                            return new Response(null, { status: 404 });
-                        case 'error-getting-outbox':
-                            logger.error(`Error getting outbox for ${handle}`);
-                            return new Response(
-                                JSON.stringify({
-                                    posts: [],
-                                    next: null,
-                                }),
-                                { status: 200 },
-                            );
-                        case 'no-page-found':
-                            logger.error(
-                                `No page found in outbox for ${handle}`,
-                            );
-                            return new Response(
-                                JSON.stringify({
-                                    posts: [],
-                                    next: null,
-                                }),
-                                { status: 200 },
-                            );
-                        default:
-                            return exhaustiveCheck(error);
-                    }
+            const result = await accountPostsView.getPostsByApId(
+                new URL(apId),
+                account,
+                currentContextAccount,
+                params.limit,
+                params.cursor,
+            );
+            if (isError(result)) {
+                const error = getError(result);
+                switch (error) {
+                    case 'invalid-next-parameter':
+                        logger.error('Invalid next parameter');
+                        return new Response(null, { status: 400 });
+                    case 'not-an-actor':
+                        logger.error(`Actor not found for ${handle}`);
+                        return new Response(null, { status: 404 });
+                    case 'error-getting-outbox':
+                        logger.error(`Error getting outbox for ${handle}`);
+                        return new Response(
+                            JSON.stringify({
+                                posts: [],
+                                next: null,
+                            }),
+                            { status: 200 },
+                        );
+                    case 'no-page-found':
+                        logger.error(`No page found in outbox for ${handle}`);
+                        return new Response(
+                            JSON.stringify({
+                                posts: [],
+                                next: null,
+                            }),
+                            { status: 200 },
+                        );
+                    default:
+                        return exhaustiveCheck(error);
                 }
-                const posts = getValue(postResult);
-                result.results = posts.results;
-                result.nextCursor = posts.nextCursor;
             }
-        } catch (error) {
-            logger.error(`Error getting posts for ${handle}: {error}`, {
-                error,
-            });
-
-            return new Response(null, { status: 500 });
+            accountPosts = getValue(result);
         }
 
         return new Response(
             JSON.stringify({
-                posts: result.results,
-                next: result.nextCursor,
+                posts: accountPosts.results,
+                next: accountPosts.nextCursor,
             }),
             { status: 200 },
         );
@@ -361,7 +330,7 @@ export function createGetAccountPostsHandler(
  */
 export function createGetAccountLikedPostsHandler(
     accountService: AccountService,
-    postService: PostService,
+    accountPostsView: AccountPostsView,
 ) {
     /**
      * Handle a request for a list of posts liked by an account
@@ -383,7 +352,7 @@ export function createGetAccountLikedPostsHandler(
         }
 
         const { results, nextCursor } =
-            await postService.getPostsLikedByAccount(
+            await accountPostsView.getPostsLikedByAccount(
                 account.id,
                 params.limit,
                 params.cursor,