feat: Account Timeline

pkg/accounts/adaptor/controller/account.ts

@@ -6,6 +6,7 @@
 import type { AuthenticateService } from '../../service/authenticate.js';
 import type { EditService } from '../../service/edit.js';
 import type { FetchService } from '../../service/fetch.js';
+import type { FetchFollowService } from '../../service/fetchFollow.js';
 import type { FollowService } from '../../service/follow.js';
 import type { FreezeService } from '../../service/freeze.js';
 import type { RegisterService } from '../../service/register.js';
@@ -15,6 +16,8 @@
 import type { VerifyAccountTokenService } from '../../service/verifyToken.js';
 import {
   type CreateAccountResponseSchema,
+  type GetAccountFollowerSchema,
+  type GetAccountFollowingSchema,
   type GetAccountResponseSchema,
   type LoginResponseSchema,
   type UpdateAccountResponseSchema,
@@ -30,6 +33,7 @@
   private readonly silenceService: SilenceService;
   private readonly followService: FollowService;
   private readonly unFollowService: UnfollowService;
+  private readonly fetchFollowService: FetchFollowService;
   private readonly resendTokenService: ResendVerifyTokenService;
 
   constructor(args: {
@@ -42,6 +46,7 @@
     silenceService: SilenceService;
     followService: FollowService;
     unFollowService: UnfollowService;
+    fetchFollowService: FetchFollowService;
     resendTokenService: ResendVerifyTokenService;
   }) {
     this.registerService = args.registerService;
@@ -53,6 +58,7 @@
     this.silenceService = args.silenceService;
     this.followService = args.followService;
     this.unFollowService = args.unFollowService;
+    this.fetchFollowService = args.fetchFollowService;
     this.resendTokenService = args.resendTokenService;
   }
 
@@ -285,4 +291,86 @@
 
     return Result.ok(undefined);
   }
+
+  async fetchFollowing(
+    id: string,
+  ): Promise<Result.Result<Error, z.infer<typeof GetAccountFollowingSchema>>> {
+    const res = await this.fetchFollowService.fetchFollowingsByID(
+      id as ID<AccountID>,
+    );
+    if (Result.isErr(res)) {
+      return res;
+    }
+    const accounts = await Promise.all(
+      res[1].map((v) => this.fetchService.fetchAccountByID(v.getTargetID())),
+    );
+    return Result.ok(
+      accounts
+        .filter((v) => Result.isOk(v))
+        .map((v) => {
+          const unwrapped = Result.unwrap(v);
+          // ToDo: make optional some fields
+          return {
+            id: unwrapped.getID(),
+            email: unwrapped.getMail(),
+            name: unwrapped.getName(),
+            nickname: unwrapped.getNickname(),
+            bio: unwrapped.getBio(),
+            // ToDo: fill the following fields
+            avatar: '',
+            header: '',
+            followed_count: 0,
+            following_count: 0,
+            note_count: 0,
+            created_at: unwrapped.getCreatedAt(),
+            role: unwrapped.getRole(),
+            frozen: unwrapped.getFrozen(),
+            status: unwrapped.getStatus(),
+            silenced: unwrapped.getSilenced(),
+          };
+        }),
+    );
+  }
+
+  async fetchFollower(
+    id: string,
+  ): Promise<Result.Result<Error, z.infer<typeof GetAccountFollowerSchema>>> {
+    const res = await this.fetchFollowService.fetchFollowersByID(
+      id as ID<AccountID>,
+    );
+    if (Result.isErr(res)) {
+      return Result.err(res[1]);
+    }
+    const accounts = await Promise.all(
+      res[1].map(
+        async (v) => await this.fetchService.fetchAccountByID(v.getFromID()),
+      ),
+    );
+    return Result.ok(
+      accounts
+        .filter((v) => Result.isOk(v))
+        .map((v) => {
+          const unwrapped = Result.unwrap(v);
+          // ToDo: make optional some fields
+          return {
+            id: unwrapped.getID(),
+            email: unwrapped.getMail(),
+            name: unwrapped.getName(),
+            nickname: unwrapped.getNickname(),
+            bio: unwrapped.getBio(),
+            // ToDo: fill the following fields
+            avatar: '',
+            header: '',
+            followed_count: 0,
+            following_count: 0,
+            note_count: 0,
+            created_at: unwrapped.getCreatedAt(),
+            role: unwrapped.getRole(),
+            frozen: unwrapped.getFrozen(),
+            status: unwrapped.getStatus(),
+            silenced: unwrapped.getSilenced(),
+          };
+        }),
+    );
+  }
 }

pkg/accounts/adaptor/validator/schema.ts

@@ -257,3 +257,10 @@ export const GetAccountResponseSchema = z
 export const FollowAccountResponseSchema = z
   .object({})
   .openapi('FollowAccountResponse');
+
+export const GetAccountFollowingSchema = z
+  .array(GetAccountResponseSchema)
+  .openapi('GetAccountFollowingResponse');
+export const GetAccountFollowerSchema = z
+  .array(GetAccountResponseSchema)
+  .openapi('GetAccountFollowerResponse');

pkg/accounts/mod.ts

@@ -23,6 +23,8 @@
   CreateAccountRoute,
   FollowAccountRoute,
   FreezeAccountRoute,
+  GetAccountFollowerRoute,
+  GetAccountFollowingRoute,
   GetAccountRoute,
   LoginRoute,
   RefreshRoute,
@@ -39,6 +41,7 @@
 import { edit } from './service/edit.js';
 import { etag } from './service/etagService.js';
 import { fetch } from './service/fetch.js';
+import { fetchFollow } from './service/fetchFollow.js';
 import { follow } from './service/follow.js';
 import { freeze } from './service/freeze.js';
 import { register } from './service/register.js';
@@ -134,6 +137,11 @@
       .feed(Ether.compose(verifyAccountTokenService))
       .feed(Ether.compose(dummy)).value,
   ),
+  fetchFollowService: Ether.runEther(
+    Cat.cat(fetchFollow)
+      .feed(Ether.compose(accountFollowRepository))
+      .feed(Ether.compose(accountRepository)).value,
+  ),
 });
 
 // ToDo: load secret from config file
@@ -151,7 +159,10 @@
   },
 });
 
-export type AccountModuleHandlerType = typeof GetAccountHandler;
+export type AccountModuleHandlerType =
+  | typeof GetAccountHandler
+  | typeof getAccountFollowingRoute
+  | typeof getAccountFollowerRoute;
 
 accounts.post('/accounts', CaptchaMiddleware.handle());
 accounts.openapi(CreateAccountRoute, async (c) => {
@@ -313,3 +324,56 @@
 
   return new Response(null, { status: 204 });
 });
+
+const getAccountFollowingRoute = accounts.openapi(
+  GetAccountFollowingRoute,
+  async (c) => {
+    const id = c.req.param('id');
+    const res = await controller.fetchFollowing(id);
+    if (Result.isErr(res)) {
+      return c.json({ error: res[1].message }, { status: 400 });
+    }
+    const unwrap = Result.unwrap(res);
+    return c.json(
+      unwrap.map((v) => {
+        return {
+          id: v.id,
+          name: v.name,
+          nickname: v.nickname,
+          bio: v.bio,
+          avatar: '',
+          header: '',
+          followed_count: v.followed_count,
+          following_count: v.following_count,
+          note_count: v.note_count,
+        };
+      }),
+    );
+  },
+);
+const getAccountFollowerRoute = accounts.openapi(
+  GetAccountFollowerRoute,
+  async (c) => {
+    const id = c.req.param('id');
+    const res = await controller.fetchFollower(id);
+    if (Result.isErr(res)) {
+      return c.json({ error: res[1].message }, { status: 400 });
+    }
+    const unwrap = Result.unwrap(res);
+    return c.json(
+      unwrap.map((v) => {
+        return {
+          id: v.id,
+          name: v.name,
+          nickname: v.nickname,
+          bio: v.bio,
+          avatar: '',
+          header: '',
+          followed_count: v.followed_count,
+          following_count: v.following_count,
+          note_count: v.note_count,
+        };
+      }),
+    );
+  },
+);

pkg/accounts/router.ts

@@ -5,6 +5,7 @@ import {
   CreateAccountRequestSchema,
   CreateAccountResponseSchema,
   FollowAccountResponseSchema,
+  GetAccountFollowingSchema,
   GetAccountResponseSchema,
   LoginRequestSchema,
   LoginResponseSchema,
@@ -589,3 +590,68 @@ export const UnFollowAccountRoute = createRoute({
     },
   },
 });
+
+export const GetAccountFollowingRoute = createRoute({
+  method: 'get',
+  tags: ['accounts'],
+  path: '/accounts/:id/following',
+  request: {
+    params: z.object({
+      id: z.string().min(3).max(64).openapi({
+        example: 'example_man',
+        description:
+          'Characters must be [A-Za-z0-9-.] The first and last characters must be [A-Za-z0-9-.]',
+      }),
+    }),
+  },
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: GetAccountFollowingSchema,
+        },
+      },
+    },
+    404: {
+      description: 'Not Found',
+      content: {
+        'application/json': {
+          schema: CommonErrorResponseSchema,
+        },
+      },
+    },
+  },
+});
+export const GetAccountFollowerRoute = createRoute({
+  method: 'get',
+  tags: ['accounts'],
+  path: '/accounts/:id/follower',
+  request: {
+    params: z.object({
+      id: z.string().min(3).max(64).openapi({
+        example: 'example_man',
+        description:
+          'Characters must be [A-Za-z0-9-.] The first and last characters must be [A-Za-z0-9-.]',
+      }),
+    }),
+  },
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: GetAccountFollowingSchema,
+        },
+      },
+    },
+    404: {
+      description: 'Not Found',
+      content: {
+        'application/json': {
+          schema: CommonErrorResponseSchema,
+        },
+      },
+    },
+  },
+});

pkg/intermodule/account.ts

@@ -13,6 +13,13 @@
 } from '../accounts/model/account.js';
 import type { ID } from '../id/type.js';
 
+export interface PartialAccount {
+  id: ID<AccountID>;
+  name: AccountName;
+  nickname: string;
+  bio: string;
+}
+
 export class AccountModule {
   // NOTE: This is a temporary solution to use hono client
   // ToDo: base url should be configurable
@@ -54,4 +61,56 @@
 
     return Result.ok(account);
   }
+
+  async fetchFollowings(
+    id: ID<AccountID>,
+  ): Promise<Result.Result<Error, PartialAccount[]>> {
+    const res = await this.client.accounts[':id'].following.$get({
+      param: { id },
+    });
+    if (!res.ok) {
+      return Result.err(new Error('Failed to fetch followings'));
+    }
+
+    const body = await res.json();
+    if ('error' in body) {
+      return Result.err(new Error(body.error));
+    }
+    return Result.ok(
+      body.map((v): PartialAccount => {
+        return {
+          id: v.id as ID<AccountID>,
+          name: v.name as AccountName,
+          nickname: v.nickname,
+          bio: v.bio,
+        };
+      }),
+    );
+  }
+
+  async fetchFollowers(
+    id: ID<AccountID>,
+  ): Promise<Result.Result<Error, PartialAccount[]>> {
+    const res = await this.client.accounts[':id'].follower.$get({
+      param: { id },
+    });
+    if (!res.ok) {
+      return Result.err(new Error('Failed to fetch followers'));
+    }
+
+    const body = await res.json();
+    if ('error' in body) {
+      return Result.err(new Error(body.error));
+    }
+    return Result.ok(
+      body.map((v): PartialAccount => {
+        return {
+          id: v.id as ID<AccountID>,
+          name: v.name as AccountName,
+          nickname: v.nickname,
+          bio: v.bio,
+        };
+      }),
+    );
+  }
 }