refactor: intermodule, use direct function calls

pkg/intermodule/adaptor/account.ts

@@ -0,0 +1,76 @@
+import { Result } from '@mikuroxina/mini-fn';
+import type { Account, AccountID } from '../../accounts/model/account.js';
+import type { FetchService } from '../../accounts/service/fetch.js';
+import type { FetchFollowService } from '../../accounts/service/fetchFollow.js';
+import type {
+  AccountModuleInterface,
+  PartialAccount,
+} from '../interfaces/account.js';
+
+export class AccountModule implements AccountModuleInterface {
+  constructor(
+    private readonly fetchService: FetchService,
+    private readonly fetchFollowService: FetchFollowService,
+  ) {}
+
+  async fetchAccount(id: AccountID): Promise<Result.Result<Error, Account>> {
+    const res = await this.fetchService.fetchAccountByID(id);
+    if (Result.isErr(res)) {
+      return res;
+    }
+
+    return res;
+  }
+
+  async fetchFollowings(
+    id: AccountID,
+  ): Promise<Result.Result<Error, PartialAccount[]>> {
+    const res = await this.fetchFollowService.fetchFollowingsByID(id);
+    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): PartialAccount => {
+          return {
+            id: v[1].getID(),
+            name: v[1].getName(),
+            nickname: v[1].getNickname(),
+            bio: v[1].getBio(),
+          };
+        }),
+    );
+  }
+
+  async fetchFollowers(
+    id: AccountID,
+  ): Promise<Result.Result<Error, PartialAccount[]>> {
+    const res = await this.fetchFollowService.fetchFollowersByID(id);
+    if (Result.isErr(res)) {
+      return res;
+    }
+
+    const accounts = await Promise.all(
+      res[1].map((v) => this.fetchService.fetchAccountByID(v.getFromID())),
+    );
+
+    return Result.ok(
+      accounts
+        .filter((v) => Result.isOk(v))
+        .map((v): PartialAccount => {
+          return {
+            id: v[1].getID(),
+            name: v[1].getName(),
+            nickname: v[1].getNickname(),
+            bio: v[1].getBio(),
+          };
+        }),
+    );
+  }
+}

pkg/intermodule/adaptor/timeline.ts

@@ -0,0 +1,20 @@
+import { Result } from '@mikuroxina/mini-fn';
+import type { Note } from '../../notes/model/note.js';
+import type { PushTimelineService } from '../../timeline/service/push.js';
+
+export class TimelineModule {
+  constructor(private readonly pushTimelineService: PushTimelineService) {}
+
+  /*
+   * @description Push note to timeline
+   * @param note to be pushed
+   * */
+  async pushNoteToTimeline(note: Note): Promise<Result.Result<Error, void>> {
+    const res = await this.pushTimelineService.handle(note);
+    if (Result.isErr(res)) {
+      return res;
+    }
+
+    return Result.ok(undefined);
+  }
+}

pkg/intermodule/interfaces/account.ts

@@ -0,0 +1,23 @@
+import type { Result } from '@mikuroxina/mini-fn';
+import type {
+  Account,
+  AccountID,
+  AccountName,
+} from '../../accounts/model/account.js';
+
+export interface PartialAccount {
+  id: AccountID;
+  name: AccountName;
+  nickname: string;
+  bio: string;
+}
+
+export interface AccountModuleInterface {
+  fetchAccount(id: AccountID): Promise<Result.Result<Error, Account>>;
+  fetchFollowings(
+    id: AccountID,
+  ): Promise<Result.Result<Error, PartialAccount[]>>;
+  fetchFollowers(
+    id: AccountID,
+  ): Promise<Result.Result<Error, PartialAccount[]>>;
+}

pkg/intermodule/interfaces/timeline.ts

@@ -0,0 +1,10 @@
+import type { Result } from '@mikuroxina/mini-fn';
+import type { Note } from '../../notes/model/note.js';
+
+export interface TimelineModuleInterface {
+  /*
+   * @description Push note to timeline
+   * @param note to be pushed
+   * */
+  pushNoteToTimeline(note: Note): Promise<Result.Result<Error, void>>;
+}

pkg/notes/adaptor/controller/note.ts

@@ -3,7 +3,7 @@ import { Option, Result } from '@mikuroxina/mini-fn';
 
 import type { AccountID } from '../../../accounts/model/account.js';
 import type { MediumID } from '../../../drive/model/medium.js';
-import type { AccountModule } from '../../../intermodule/account.js';
+import type { AccountModuleInterface } from '../../../intermodule/interfaces/account.js';
 import type { NoteID, NoteVisibility } from '../../model/note.js';
 import type { CreateService } from '../../service/create.js';
 import type { FetchService } from '../../service/fetch.js';
@@ -19,7 +19,7 @@ export class NoteController {
     private readonly createService: CreateService,
     private readonly fetchService: FetchService,
     private readonly renoteService: RenoteService,
-    private readonly accountModule: AccountModule,
+    private readonly accountModule: AccountModuleInterface,
   ) {}
 
   async createNote(args: {

pkg/notes/mod.ts

@@ -1,16 +1,27 @@
 import { OpenAPIHono } from '@hono/zod-openapi';
 import { Cat, Ether, Promise, Result } from '@mikuroxina/mini-fn';
 
+import {
+  InMemoryAccountRepository,
+  newFollowRepo,
+} from '../accounts/adaptor/repository/dummy.js';
+import {
+  PrismaAccountRepository,
+  prismaFollowRepo,
+} from '../accounts/adaptor/repository/prisma.js';
 import type { AccountID } from '../accounts/model/account.js';
+import { accountRepoSymbol } from '../accounts/model/repository.js';
 import { authenticateToken } from '../accounts/service/authenticationTokenService.js';
+import { fetch } from '../accounts/service/fetch.js';
+import { fetchFollow } from '../accounts/service/fetchFollow.js';
 import {
   type AuthMiddlewareVariable,
   authenticateMiddleware,
 } from '../adaptors/authenticateMiddleware.js';
 import { prismaClient } from '../adaptors/prisma.js';
 import { SnowflakeIDGenerator } from '../id/mod.js';
 import type { ID } from '../id/type.js';
-import { AccountModule } from '../intermodule/account.js';
+import { AccountModule } from '../intermodule/adaptor/account.js';
 import { BookmarkController } from './adaptor/controller/bookmark.js';
 import { NoteController } from './adaptor/controller/note.js';
 import {
@@ -68,7 +79,29 @@ const AuthMiddleware = await Ether.runEtherT(
 );
 
 // Account
-const accountModule = new AccountModule();
+const accountRepoObject = isProduction
+  ? new PrismaAccountRepository(prismaClient)
+  : new InMemoryAccountRepository([]);
+const accountRepository = Ether.newEther(
+  accountRepoSymbol,
+  () => accountRepoObject,
+);
+
+const accountFollowRepository = isProduction
+  ? prismaFollowRepo(prismaClient)
+  : newFollowRepo();
+
+// const accountFetchService = new AccountFetchService(accountRepoObject);
+// const accountFetchFollowservice = new FetchFollowService();
+
+const accountModule = new AccountModule(
+  Ether.runEther(Cat.cat(fetch).feed(Ether.compose(accountRepository)).value),
+  Ether.runEther(
+    Cat.cat(fetchFollow)
+      .feed(Ether.compose(accountFollowRepository))
+      .feed(Ether.compose(accountRepository)).value,
+  ),
+);
 
 // Note
 const createService = new CreateService(

pkg/notes/service/fetch.test.ts

@@ -1,9 +1,14 @@
 import { Option, Result } from '@mikuroxina/mini-fn';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
-import { InMemoryAccountRepository } from '../../accounts/adaptor/repository/dummy.js';
+import {
+  InMemoryAccountFollowRepository,
+  InMemoryAccountRepository,
+} from '../../accounts/adaptor/repository/dummy.js';
 import { Account, type AccountID } from '../../accounts/model/account.js';
-import { AccountModule } from '../../intermodule/account.js';
+import { FetchService as AccountFetchService } from '../../accounts/service/fetch.js';
+import { FetchFollowService } from '../../accounts/service/fetchFollow.js';
+import { AccountModule } from '../../intermodule/adaptor/account.js';
 import { InMemoryNoteRepository } from '../adaptor/repository/dummy.js';
 import { Note, type NoteID } from '../model/note.js';
 import { FetchService } from './fetch.js';
@@ -85,7 +90,11 @@ const accountRepository = new InMemoryAccountRepository([
   testAccount,
   frozenAccount,
 ]);
-const accountModule = new AccountModule();
+const accountFollowRepository = new InMemoryAccountFollowRepository();
+const accountModule = new AccountModule(
+  new AccountFetchService(accountRepository),
+  new FetchFollowService(accountFollowRepository, accountRepository),
+);
 const service = new FetchService(repository, accountModule);
 
 describe('FetchService', () => {

pkg/notes/service/fetch.ts

@@ -1,13 +1,13 @@
 import { Option, Result } from '@mikuroxina/mini-fn';
 
-import type { AccountModule } from '../../intermodule/account.js';
+import type { AccountModuleInterface } from '../../intermodule/interfaces/account.js';
 import type { Note, NoteID } from '../model/note.js';
 import type { NoteRepository } from '../model/repository.js';
 
 export class FetchService {
   constructor(
     private readonly noteRepository: NoteRepository,
-    private readonly accountModule: AccountModule,
+    private readonly accountModule: AccountModuleInterface,
   ) {}
 
   async fetchNoteByID(noteID: NoteID): Promise<Option.Option<Note>> {