feat: アカウントの複数一括取得の実装 (#588)

pkg/accounts/adaptor/repository/dummy.test.ts

@@ -0,0 +1,55 @@
+import { Result } from '@mikuroxina/mini-fn';
+import { describe, expect, it } from 'vitest';
+import { Account, type AccountID } from '../../model/account.js';
+import { InMemoryAccountRepository } from './dummy.js';
+
+describe('InMemoryAccountRepository', () => {
+  const dummyInput: Account[] = [
+    Account.new({
+      id: '1' as AccountID,
+      name: '@john@example.com',
+      mail: 'johndoe@example.com',
+      nickname: 'John Doe',
+      bio: 'Hello, World!',
+      role: 'normal',
+      frozen: 'normal',
+      silenced: 'normal',
+      status: 'active',
+      createdAt: new Date('2023-09-10T12:00:00Z'),
+    }),
+    Account.new({
+      id: '2' as AccountID,
+      name: '@alice@example.com',
+      mail: 'alice@example.com',
+      nickname: 'Alice',
+      bio: 'Hello, World!',
+      role: 'normal',
+      frozen: 'normal',
+      silenced: 'normal',
+      status: 'active',
+      createdAt: new Date('2023-09-11T12:00:00Z'),
+    }),
+    Account.new({
+      id: '3' as AccountID,
+      name: '@bob@example.com',
+      mail: 'bob@example.com',
+      nickname: 'bob',
+      bio: 'Hello, World!',
+      role: 'normal',
+      frozen: 'normal',
+      silenced: 'normal',
+      status: 'active',
+      createdAt: new Date('2023-09-12T12:00:00Z'),
+    }),
+  ];
+  const repository = new InMemoryAccountRepository(dummyInput);
+
+  it('should fetch many accounts by id', async () => {
+    const result = await repository.findManyByID([
+      '1' as AccountID,
+      '2' as AccountID,
+    ]);
+    expect(Result.isOk(result)).toBe(true);
+    expect(Result.unwrap(result)).toStrictEqual([dummyInput[0], dummyInput[1]]);
+  });
+});

pkg/accounts/adaptor/repository/dummy.ts

@@ -26,8 +26,9 @@ export class InMemoryAccountRepository implements AccountRepository {
     return Promise.resolve(Result.ok(undefined));
   }
 
-  reset(): void {
+  reset(data: Account[] = []): void {
     this.data.clear();
+    data.map((v) => this.data.add(v));
   }
 
   findByID(id: AccountID): Promise<Option.Option<Account>> {
@@ -47,6 +48,14 @@ export class InMemoryAccountRepository implements AccountRepository {
     return Promise.resolve(Option.some(account));
   }
 
+  findManyByID(
+    id: readonly AccountID[],
+  ): Promise<Result.Result<Error, Account[]>> {
+    const set = new Set(id);
+    const accounts = Array.from(this.data).filter((a) => set.has(a.getID()));
+    return Promise.resolve(Result.ok(accounts));
+  }
+
   findByMail(mail: string): Promise<Option.Option<Account>> {
     const account = Array.from(this.data).find((a) => a.getMail() === mail);
     if (!account) {

pkg/accounts/adaptor/repository/prisma.ts

@@ -55,6 +55,20 @@ export class PrismaAccountRepository implements AccountRepository {
     return Option.some(this.fromPrismaArgs(res));
   }
 
+  async findManyByID(
+    id: readonly AccountID[],
+  ): Promise<Result.Result<Error, Account[]>> {
+    const res = await this.prisma.account.findMany({
+      where: {
+        id: {
+          in: id as AccountID[],
+        },
+      },
+    });
+
+    return Result.ok(res.map((a) => this.fromPrismaArgs(a)));
+  }
+
   async findByMail(mail: string): Promise<Option.Option<Account>> {
     const res = await this.prisma.account.findUnique({
       where: {

pkg/accounts/model/repository.ts

@@ -9,6 +9,9 @@ export interface AccountRepository {
   create(account: Account): Promise<Result.Result<Error, void>>;
   findByName(name: string): Promise<Option.Option<Account>>;
   findByID(id: AccountID): Promise<Option.Option<Account>>;
+  findManyByID(
+    id: readonly AccountID[],
+  ): Promise<Result.Result<Error, Account[]>>;
   findByMail(mail: string): Promise<Option.Option<Account>>;
   edit(account: Account): Promise<Result.Result<Error, void>>;
 }

pkg/accounts/service/fetch.test.ts

@@ -5,8 +5,7 @@ import { InMemoryAccountRepository } from '../adaptor/repository/dummy.js';
 import { Account, type AccountID } from '../model/account.js';
 import { FetchService } from './fetch.js';
 
-const repository = new InMemoryAccountRepository();
-await repository.create(
+const testAccounts = [
   Account.new({
     id: '1' as AccountID,
     name: '@john@example.com',
@@ -18,13 +17,38 @@ await repository.create(
     frozen: 'normal',
     silenced: 'normal',
     status: 'notActivated',
-    createdAt: new Date(),
+    createdAt: new Date('2023-09-10T12:00:00Z'),
   }),
-);
+  Account.new({
+    id: '2' as AccountID,
+    name: '@alice@example.com',
+    mail: 'alice@example.com',
+    nickname: 'Alice',
+    bio: 'Hello, World!',
+    role: 'normal',
+    frozen: 'normal',
+    silenced: 'normal',
+    status: 'active',
+    createdAt: new Date('2023-09-11T12:00:00Z'),
+  }),
+  Account.new({
+    id: '3' as AccountID,
+    name: '@bob@example.com',
+    mail: 'bob@example.com',
+    nickname: 'bob',
+    bio: 'Hello, World!',
+    role: 'normal',
+    frozen: 'normal',
+    silenced: 'normal',
+    status: 'active',
+    createdAt: new Date('2023-09-12T12:00:00Z'),
+  }),
+];
+const repository = new InMemoryAccountRepository(testAccounts);
 const fetchService = new FetchService(repository);
 
 describe('FetchService', () => {
-  afterEach(() => repository.reset());
+  afterEach(() => repository.reset(testAccounts));
 
   it('fetch account info', async () => {
     const account = await fetchService.fetchAccount('@john@example.com');
@@ -68,15 +92,25 @@ describe('FetchService', () => {
         frozen: 'normal',
         silenced: 'normal',
         status: 'notActivated',
-        createdAt: new Date(),
+        createdAt: new Date('2023-09-10T12:00:00.000Z'),
       }),
     );
   });
 
   it("fetch account by ID doesn't exist", async () => {
-    // `2` is not registered.
-    const account = await fetchService.fetchAccountByID('2' as AccountID);
+    // `20` is not registered.
+    const account = await fetchService.fetchAccountByID('20' as AccountID);
 
     expect(Result.isErr(account)).toBe(true);
   });
+
+  it('should fetch many account by ID', async () => {
+    const accounts = await fetchService.fetchManyAccountsByID([
+      '2' as AccountID,
+      '3' as AccountID,
+    ]);
+
+    expect(Result.isOk(accounts)).toBe(true);
+    expect(Result.unwrap(accounts).length).toBe(2);
+  });
 });

pkg/accounts/service/fetch.ts

@@ -33,6 +33,12 @@ export class FetchService {
     const res = await this.accountRepository.findByID(id);
     return Option.okOr(new Error('AccountNotFoundError'))(res);
   }
+
+  async fetchManyAccountsByID(
+    id: AccountID[],
+  ): Promise<Result.Result<Error, Account[]>> {
+    return await this.accountRepository.findManyByID(id);
+  }
 }
 
 export const fetchSymbol = Ether.newEtherSymbol<FetchService>();

pkg/intermodule/account.ts

@@ -39,6 +39,12 @@ export class AccountModuleFacade {
     return await this.fetchService.fetchAccountByID(id);
   }
 
+  async fetchAccounts(
+    id: AccountID[],
+  ): Promise<Result.Result<Error, Account[]>> {
+    return await this.fetchService.fetchManyAccountsByID(id);
+  }
+
   async fetchFollowings(
     id: AccountID,
   ): Promise<Result.Result<Error, PartialAccount[]>> {