feat: impl fetch list members

pkg/accounts/testData/testData.ts

@@ -0,0 +1,44 @@
+import type { PartialAccount } from '../../intermodule/account.js';
+import { Account, type AccountID } from '../model/account.js';
+
+export const dummyAccount1 = Account.new({
+  id: '101' as AccountID,
+  bio: 'this is test user',
+  mail: 'john@example.com',
+  name: '@john@example.com',
+  nickname: 'John Doe',
+  passphraseHash: '',
+  role: 'normal',
+  silenced: 'normal',
+  status: 'active',
+  frozen: 'normal',
+  createdAt: new Date('2023-09-10T00:00:00Z'),
+});
+export const dummyAccount2 = Account.new({
+  id: '102' as AccountID,
+  bio: 'Hello world ✨',
+  mail: 'john@example.com',
+  name: '@johndoe@example.com',
+  nickname: '🌤 John',
+  passphraseHash: '',
+  role: 'normal',
+  silenced: 'normal',
+  status: 'active',
+  frozen: 'normal',
+  createdAt: new Date('2023-09-11T00:00:00Z'),
+});
+export const dummyAccounts = [dummyAccount1, dummyAccount2];
+
+export const partialAccount1: PartialAccount = {
+  id: dummyAccount1.getID(),
+  name: dummyAccount1.getName(),
+  nickname: dummyAccount1.getNickname(),
+  bio: dummyAccount1.getBio(),
+};
+export const partialAccount2: PartialAccount = {
+  id: dummyAccount2.getID(),
+  name: dummyAccount2.getName(),
+  nickname: dummyAccount2.getNickname(),
+  bio: dummyAccount2.getBio(),
+};
+export const partialAccounts = [partialAccount1, partialAccount2];

pkg/timeline/adaptor/controller/timeline.ts

@@ -8,26 +8,32 @@
 import type { AccountTimelineService } from '../../service/account.js';
 import type { CreateListService } from '../../service/createList.js';
 import type { DeleteListService } from '../../service/deleteList.js';
+import type { FetchListMemberService } from '../../service/fetchMember.js';
 import type {
   CreateListResponseSchema,
   GetAccountTimelineResponseSchema,
+  GetListMemberResponseSchema,
 } from '../validator/timeline.js';
 
 export class TimelineController {
   private readonly accountTimelineService: AccountTimelineService;
   private readonly accountModule: AccountModuleFacade;
   private readonly createListService: CreateListService;
   private readonly deleteListService: DeleteListService;
+  private readonly fetchMemberService: FetchListMemberService;
+
   constructor(args: {
     accountTimelineService: AccountTimelineService;
     accountModule: AccountModuleFacade;
     createListService: CreateListService;
     deleteListService: DeleteListService;
+    fetchMemberService: FetchListMemberService;
   }) {
     this.accountTimelineService = args.accountTimelineService;
     this.accountModule = args.accountModule;
     this.createListService = args.createListService;
     this.deleteListService = args.deleteListService;
+    this.fetchMemberService = args.fetchMemberService;
   }
 
   async getAccountTimeline(
@@ -122,4 +128,27 @@
     const res = await this.deleteListService.handle(id as ListID);
     return res;
   }
+
+  async getListMembers(
+    id: string,
+  ): Promise<
+    Result.Result<Error, z.infer<typeof GetListMemberResponseSchema>>
+  > {
+    const accounts = await this.fetchMemberService.handle(id as ListID);
+    if (Result.isErr(accounts)) {
+      return accounts;
+    }
+
+    const unwrapped = Result.unwrap(accounts);
+    const res = unwrapped.map((v) => {
+      return {
+        id: v.getID(),
+        name: v.getName(),
+        nickname: v.getNickname(),
+        avatar: '',
+      };
+    });
+
+    return Result.ok({ assignees: res });
+  }
 }

pkg/timeline/adaptor/validator/timeline.ts

@@ -67,3 +67,28 @@
     }),
   })
   .openapi('CreateListResponse');
+
+export const GetListMemberResponseSchema = z
+  .object({
+    assignees: z.array(
+      z.object({
+        id: z.string().openapi({
+          example: '30984308495',
+          description: 'Assignee account ID',
+        }),
+        name: z.string().openapi({
+          example: '@john@example.com',
+          description: 'Assignee account name',
+        }),
+        nickname: z.string().openapi({
+          example: 'John Doe',
+          description: 'Assignee nickname',
+        }),
+        avatar: z.string().url().openapi({
+          example: 'https://example.com/avatar.png',
+          description: 'avatar URL',
+        }),
+      }),
+    ),
+  })
+  .openapi('GetListMemberResponseSchema');

pkg/timeline/mod.ts

@@ -15,11 +15,13 @@
   CreateListRoute,
   DeleteListRoute,
   GetAccountTimelineRoute,
+  GetListMemberRoute,
   PushNoteToTimelineRoute,
 } from './router.js';
 import { AccountTimelineService } from './service/account.js';
 import { CreateListService } from './service/createList.js';
 import { DeleteListService } from './service/deleteList.js';
+import { FetchListMemberService } from './service/fetchMember.js';
 import { NoteVisibilityService } from './service/noteVisibility.js';
 import { PushTimelineService } from './service/push.js';
 
@@ -31,6 +33,7 @@
 const listRepository = new InMemoryListRepository();
 const timelineNotesCacheRepository = new InMemoryTimelineCacheRepository();
 const noteVisibilityService = new NoteVisibilityService(accountModule);
+
 const controller = new TimelineController({
   accountTimelineService: new AccountTimelineService({
     noteVisibilityService: noteVisibilityService,
@@ -39,6 +42,7 @@
   createListService: new CreateListService(idGenerator, listRepository),
   deleteListService: new DeleteListService(listRepository),
   accountModule,
+  fetchMemberService: new FetchListMemberService(listRepository, accountModule),
 });
 const pushTimelineService = new PushTimelineService(
   accountModule,
@@ -126,3 +130,15 @@
 
   return new Response(undefined, { status: 204 });
 });
+
+timeline.openapi(GetListMemberRoute, async (c) => {
+  const { id } = c.req.param();
+
+  const res = await controller.getListMembers(id);
+  if (Result.isErr(res)) {
+    return c.json({ error: res[1].message }, 404);
+  }
+
+  const unwrapped = Result.unwrap(res);
+  return c.json(unwrapped, 200);
+});

pkg/timeline/router.ts

@@ -5,6 +5,7 @@
   CreateListRequestSchema,
   CreateListResponseSchema,
   GetAccountTimelineResponseSchema,
+  GetListMemberResponseSchema,
 } from './adaptor/validator/timeline.js';
 
 export const GetAccountTimelineRoute = createRoute({
@@ -164,3 +165,27 @@
     },
   },
 });
+
+export const GetListMemberRoute = createRoute({
+  method: 'get',
+  tags: ['timeline'],
+  path: '/lists/:id/members',
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: GetListMemberResponseSchema,
+        },
+      },
+    },
+    404: {
+      content: {
+        'application/json': {
+          schema: CommonErrorResponseSchema,
+        },
+      },
+      description: 'LIST_NOTFOUND',
+    },
+  },
+});

pkg/timeline/service/fetchMember.test.ts

@@ -0,0 +1,37 @@
+import { Result } from '@mikuroxina/mini-fn';
+import { describe, expect, it, vi } from 'vitest';
+import type { AccountID } from '../../accounts/model/account.js';
+import { dummyAccounts } from '../../accounts/testData/testData.js';
+import { dummyAccountModuleFacade } from '../../intermodule/account.js';
+import { InMemoryListRepository } from '../adaptor/repository/dummy.js';
+import { List, type ListID } from '../model/list.js';
+import { FetchListMemberService } from './fetchMember.js';
+
+describe('FetchListMemberService', () => {
+  const dummyListData = List.new({
+    id: '1' as ListID,
+    title: 'List',
+    publicity: 'PRIVATE',
+    memberIds: ['11' as AccountID, '12' as AccountID],
+    ownerId: '1' as AccountID,
+    createdAt: new Date('2024-01-01T00:00:00.000Z'),
+  });
+  const repository = new InMemoryListRepository([dummyListData]);
+  const service = new FetchListMemberService(
+    repository,
+    dummyAccountModuleFacade,
+  );
+
+  it('should fetch list members', async () => {
+    vi.spyOn(dummyAccountModuleFacade, 'fetchAccounts').mockImplementation(
+      async () => {
+        return Result.ok(dummyAccounts);
+      },
+    );
+
+    const res = await service.handle('1' as ListID);
+
+    expect(Result.isOk(res)).toBe(true);
+    expect(Result.unwrap(res)).toStrictEqual(dummyAccounts);
+  });
+});

pkg/timeline/service/fetchMember.ts

@@ -0,0 +1,29 @@
+import { Result } from '@mikuroxina/mini-fn';
+import type {
+  Account,
+  AccountModuleFacade,
+} from '../../intermodule/account.js';
+import type { ListID } from '../model/list.js';
+import type { ListRepository } from '../model/repository.js';
+
+export class FetchListMemberService {
+  constructor(
+    private readonly listRepository: ListRepository,
+    private readonly accountModule: AccountModuleFacade,
+  ) {}
+
+  async handle(listID: ListID): Promise<Result.Result<Error, Account[]>> {
+    const list = await this.listRepository.fetchListMembers(listID);
+    if (Result.isErr(list)) {
+      return list;
+    }
+    const unwrappedAccountID = Result.unwrap(list);
+
+    const accounts = await this.accountModule.fetchAccounts(unwrappedAccountID);
+    if (Result.isErr(accounts)) {
+      return accounts;
+    }
+
+    return Result.ok(Result.unwrap(accounts));
+  }
+}

pkg/timeline/service/noteVisibility.test.ts

@@ -2,13 +2,13 @@ import { Result } from '@mikuroxina/mini-fn';
 import { describe, expect, it, vi } from 'vitest';
 
 import type { AccountID } from '../../accounts/model/account.js';
+import { partialAccount1 } from '../../accounts/testData/testData.js';
 import { dummyAccountModuleFacade } from '../../intermodule/account.js';
 import {
   dummyDirectNote,
   dummyFollowersNote,
   dummyHomeNote,
   dummyPublicNote,
-  partialAccount1,
 } from '../testData/testData.js';
 import { NoteVisibilityService } from './noteVisibility.js';
 

pkg/timeline/service/push.test.ts

@@ -1,9 +1,10 @@
 import { Result } from '@mikuroxina/mini-fn';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { partialAccount1 } from '../../accounts/testData/testData.js';
 import { dummyAccountModuleFacade } from '../../intermodule/account.js';
 import { InMemoryTimelineCacheRepository } from '../adaptor/repository/dummyCache.js';
-import { dummyPublicNote, partialAccount1 } from '../testData/testData.js';
+import { dummyPublicNote } from '../testData/testData.js';
 import { NoteVisibilityService } from './noteVisibility.js';
 import { PushTimelineService } from './push.js';
 

pkg/timeline/testData/testData.ts

@@ -3,8 +3,7 @@
  * */
 import { Option } from '@mikuroxina/mini-fn';
 
-import { Account, type AccountID } from '../../accounts/model/account.js';
-import type { PartialAccount } from '../../intermodule/account.js';
+import type { AccountID } from '../../accounts/model/account.js';
 import { Note, type NoteID } from '../../notes/model/note.js';
 
 export const dummyPublicNote = Note.new({
@@ -51,22 +50,3 @@ export const dummyDirectNote = Note.new({
   visibility: 'DIRECT',
   createdAt: new Date('2023/10/10 00:00:00'),
 });
-export const dummyAccount1 = Account.new({
-  id: '101' as AccountID,
-  bio: 'this is test user',
-  mail: 'john@example.com',
-  name: '@john@example.com',
-  nickname: 'John Doe',
-  passphraseHash: '',
-  role: 'normal',
-  silenced: 'normal',
-  status: 'active',
-  frozen: 'normal',
-  createdAt: new Date(),
-});
-export const partialAccount1: PartialAccount = {
-  id: dummyAccount1.getID(),
-  name: dummyAccount1.getName(),
-  nickname: dummyAccount1.getNickname(),
-  bio: dummyAccount1.getBio(),
-};