Refactored account retrieval to use AccountView

features/account.feature

@@ -20,8 +20,8 @@ Feature: Account API
 
   Scenario: Get non-existent account
     When an authenticated "get" request is made to "/.ghost/activitypub/account/@nonexistent@fake-external-activitypub.test"
-    Then the request is rejected with a 500
+    Then the request is rejected with a 404
 
   Scenario: Get account without authentication
     When an unauthenticated request is made to "/.ghost/activitypub/account/me"
-    Then the request is rejected with a 403 
+    Then the request is rejected with a 403

features/step_definitions/stepdefs.js

@@ -1519,6 +1519,10 @@ Then('the request is rejected', function () {
 });
 
 Then('the request is rejected with a {int}', function (statusCode) {
+    assert(
+        statusCode < 500,
+        `Expected to check for a client error, got a server error ${statusCode}`,
+    );
     assert(!this.response.ok);
     assert.equal(this.response.status, statusCode);
 });

src/app.ts

@@ -116,6 +116,7 @@ import {
 } from './http/api';
 import { AccountFollowsView } from './http/api/views/account.follows.view';
 import { AccountPostsView } from './http/api/views/account.posts.view';
+import { AccountView } from './http/api/views/account.view';
 import { createWebFingerHandler } from './http/handler/webfinger';
 import { spanWrapper } from './instrumentation';
 import { KnexKvStore } from './knex.kvstore';
@@ -287,6 +288,7 @@ const postService = new PostService(
     fedifyContextFactory,
 );
 
+const accountView = new AccountView(client, fedifyContextFactory);
 const accountFollowsView = new AccountFollowsView(client, fedifyContextFactory);
 const accountPostsView = new AccountPostsView(client, fedifyContextFactory);
 const siteService = new SiteService(client, accountService, {
@@ -1002,9 +1004,7 @@ app.get(
 app.get(
     '/.ghost/activitypub/account/:handle',
     requireRole(GhostRole.Owner, GhostRole.Administrator),
-    spanWrapper(
-        createGetAccountHandler(accountService, accountRepository, fedify),
-    ),
+    spanWrapper(createGetAccountHandler(accountView, accountRepository)),
 );
 app.put(
     '/.ghost/activitypub/account',

src/http/api/__snapshots__/views/AccountView.viewByApId.internal-no-context.json

@@ -0,0 +1,17 @@
+{
+  "attachment": [],
+  "avatarUrl": "Test site",
+  "bannerImageUrl": "",
+  "bio": "Test site",
+  "customFields": {},
+  "followedByMe": false,
+  "followerCount": 0,
+  "followingCount": 0,
+  "followsMe": false,
+  "handle": "@index@example.com",
+  "id": 1,
+  "likedCount": 0,
+  "name": "Test site",
+  "postCount": 0,
+  "url": "https://example.com",
+}

src/http/api/__snapshots__/views/AccountView.viewById.no-context.json

@@ -0,0 +1,17 @@
+{
+  "attachment": [],
+  "avatarUrl": "Test site",
+  "bannerImageUrl": "",
+  "bio": "Test site",
+  "customFields": {},
+  "followedByMe": false,
+  "followerCount": 0,
+  "followingCount": 0,
+  "followsMe": false,
+  "handle": "@index@example.com",
+  "id": 1,
+  "likedCount": 0,
+  "name": "Test site",
+  "postCount": 0,
+  "url": "https://example.com",
+}

src/http/api/account.ts

@@ -1,17 +1,12 @@
-import type { Federation } from '@fedify/fedify';
-import type { Account, PersistedAccount } from 'account/account.entity';
+import type { 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 type { AppContext } from 'app';
 import { exhaustiveCheck, getError, getValue, isError } from 'core/result';
 import { isHandle } from 'helpers/activitypub/actor';
 import { lookupAPIdByHandle } from 'lookup-helpers';
 import { z } from 'zod';
-import {
-    getAccountDTOByHandle,
-    getAccountDTOFromAccount,
-} from './helpers/account';
 import type { AccountDTO } from './types';
 import type {
     AccountFollows,
@@ -21,6 +16,8 @@ import type {
     AccountPosts,
     AccountPostsView,
 } from './views/account.posts.view';
+import type { AccountView } from './views/account.view';
+
 /**
  * Default number of posts to return in a profile
  */
@@ -31,78 +28,53 @@ const DEFAULT_POSTS_LIMIT = 20;
  */
 const MAX_POSTS_LIMIT = 100;
 
+/**
+ * Keyword to indicate a request is for the current user
+ */
+const CURRENT_USER_KEYWORD = 'me';
+
 /**
  * Create a handler to handle a request for an account
- *
- * @param accountService Account service instance
  */
 export function createGetAccountHandler(
-    accountService: AccountService,
+    accountView: AccountView,
     accountRepository: KnexAccountRepository,
-    fedify: Federation<ContextData>,
 ) {
     /**
      * Handle a request for an account
      *
      * @param ctx App context
      */
     return async function handleGetAccount(ctx: AppContext) {
-        const logger = ctx.get('logger');
-        const site = ctx.get('site');
-        let account: Account | null = null;
-        const db = ctx.get('db');
+        const handle = ctx.req.param('handle');
 
-        const apCtx = fedify.createContext(ctx.req.raw as Request, {
-            db,
-            globaldb: ctx.get('globaldb'),
-            logger,
-        });
+        if (handle !== CURRENT_USER_KEYWORD && !isHandle(handle)) {
+            return new Response(null, { status: 404 });
+        }
 
-        const defaultAccount = await accountRepository.getBySite(
+        const siteDefaultAccount = await accountRepository.getBySite(
             ctx.get('site'),
         );
 
-        const handle = ctx.req.param('handle');
-        // We are using the keyword 'me', if we want to get the account of teh current user
-        if (handle === 'me') {
-            account = defaultAccount;
-        } else {
-            if (!isHandle(handle)) {
-                return new Response(null, { status: 404 });
-            }
+        let accountDto: AccountDTO | null = null;
 
-            const apId = await lookupAPIdByHandle(apCtx, handle);
-            if (apId) {
-                account = await accountRepository.getByApId(new URL(apId));
-            }
-        }
-
-        let accountDto: AccountDTO;
+        const viewContext = {
+            requestUserAccount: siteDefaultAccount,
+        };
 
-        try {
-            //If we found the account in our db and it's an internal account, do an internal lookup
-            if (account?.isInternal) {
-                accountDto = await getAccountDTOFromAccount(
-                    account,
-                    defaultAccount,
-                    accountService,
-                );
-            } else {
-                //Otherwise, do a remote lookup to fetch the updated data
-                accountDto = await getAccountDTOByHandle(
-                    handle,
-                    apCtx,
-                    site,
-                    accountService,
-                );
-            }
-        } catch (error) {
-            logger.error('Error getting account: {error}', { error });
+        if (handle === CURRENT_USER_KEYWORD) {
+            accountDto = await accountView.viewById(
+                siteDefaultAccount.id!,
+                viewContext,
+            );
+        } else {
+            accountDto = await accountView.viewByHandle(handle, viewContext);
+        }
 
-            return new Response(null, { status: 500 });
+        if (accountDto === null) {
+            return new Response(null, { status: 404 });
         }
 
-        // Return response
         return new Response(JSON.stringify(accountDto), {
             headers: {
                 'Content-Type': 'application/json',