feat: implement API of timeline

main.ts

@@ -1,10 +1,14 @@
 import { serve } from '@hono/node-server';
 import { apiReference } from '@scalar/hono-api-reference';
 import { Hono } from 'hono';
+// installs polyfill into global
+import * as ihp from 'iterator-helpers-polyfill';
 
 import { accounts } from './pkg/accounts/mod.js';
 import { noteHandlers } from './pkg/notes/mod.js';
 
+ihp.installIntoGlobal();
+
 const app = new Hono();
 
 /*

package.json

@@ -37,6 +37,7 @@
     "@scalar/hono-api-reference": "^0.4.0",
     "argon2": "^0.40.0",
     "hono": "^3.12.10",
+    "iterator-helpers-polyfill": "^2.3.3",
     "jose": "^5.2.1",
     "prisma": "^5.9.1",
     "typescript": "^5.3.3"
@@ -53,8 +54,8 @@
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-vitest": "^0.3.21",
-    "globals": "^15.0.0",
     "glob": "^10.3.10",
+    "globals": "^15.0.0",
     "ignore": "^5.3.1",
     "kleur": "^4.1.5",
     "lefthook": "^1.6.1",

pkg/accounts/service/fetchAccountFollow.ts

@@ -0,0 +1,41 @@
+import { Option } from '@mikuroxina/mini-fn';
+
+import type { AccountID, AccountName } from '../../accounts/model/account.js';
+import type { ID } from '../../id/type.js';
+import type {
+  AccountFollowRepository,
+  AccountRepository,
+} from '../model/repository.js';
+
+export class FetchAccountFollowService {
+  constructor(
+    private readonly accountFollowRepository: AccountFollowRepository,
+    private readonly accountRepository: AccountRepository,
+  ) {}
+
+  async fetchFollowsByID(id: ID<AccountID>) /* inferred */ {
+    return this.accountFollowRepository.fetchAllFollowers(id);
+  }
+
+  async fetchFollowsByName(name: AccountName) /* inferred */ {
+    const id = await this.accountRepository
+      .findByName(name)
+      .then((o) => Option.unwrap(o))
+      .then((a) => a.getID());
+
+    return this.fetchFollowsByID(id);
+  }
+
+  async fetchFollowersByID(id: ID<AccountID>) /* inferred */ {
+    return this.accountFollowRepository.fetchAllFollowing(id);
+  }
+
+  async fetchFollowersByName(name: AccountName) /* inferred */ {
+    const id = await this.accountRepository
+      .findByName(name)
+      .then((o) => Option.unwrap(o))
+      .then((a) => a.getID());
+
+    return this.fetchFollowersByID(id);
+  }
+}

pkg/notes/adaptor/repository/dummy.ts

@@ -3,7 +3,9 @@ import { Option, Result } from '@mikuroxina/mini-fn';
 import type { AccountID } from '../../../accounts/model/account.js';
 import type { ID } from '../../../id/type.js';
 import { type Note, type NoteID } from '../../model/note.js';
-import type { NoteRepository } from '../../model/repository.js';
+import type { NoteRepository, NoteFilter } from '../../model/repository.js';
+
+const NOTES_LIMIT = /* hard-coded */ 20;
 
 export class InMemoryNoteRepository implements NoteRepository {
   private readonly notes: Map<ID<NoteID>, Note>;
@@ -17,6 +19,53 @@ export class InMemoryNoteRepository implements NoteRepository {
     return Result.ok(undefined);
   }
 
+  async getFiltered(
+    filters: NoteFilter[],
+  ): Promise<Result.Result<Error, Note[]>> {
+    let notes = this.notes.values();
+    for (const f of filters) {
+      switch (f.type) {
+        case 'author':
+          notes = notes.filter((n) => {
+            return f.any.find((v) => v === n.getAuthorID()) !== undefined;
+          });
+          break;
+
+        case 'attachment':
+          notes = notes.filter(() => {
+            return /* hard-coded */ 0 > f.more;
+          });
+          break;
+
+        case 'cw':
+          notes = notes.filter((n) => {
+            return n.getCwComment() === f.is;
+          });
+          break;
+
+        case 'created':
+          notes = notes.filter((n) => {
+            return n.getCreatedAt() < f.less;
+          });
+          break;
+
+        case 'updated':
+          notes = notes.filter((n) => {
+            return Option.map((v: Date) => v < f.less)(n.getUpdatedAt());
+          });
+          break;
+
+        case 'deleted':
+          notes = notes.filter((n) => {
+            return Option.isSome(n.getDeletedAt()) === f.has;
+          });
+          break;
+      }
+    }
+
+    return Result.ok(notes.take(NOTES_LIMIT).toArray());
+  }
+
   async deleteByID(id: ID<NoteID>): Promise<Result.Result<Error, void>> {
     const target = await this.findByID(id);
     if (Option.isNone(target)) {

pkg/notes/model/repository.ts

@@ -6,10 +6,19 @@ import type { Note, NoteID } from './note.js';
 
 export interface NoteRepository {
   create(note: Note): Promise<Result.Result<Error, void>>;
+  getFiltered(filters: NoteFilter[]): Promise<Result.Result<Error, Note[]>>;
   findByAuthorID(
     authorID: ID<AccountID>,
     limit: number,
   ): Promise<Option.Option<Note[]>>;
   findByID(id: ID<NoteID>): Promise<Option.Option<Note>>;
   deleteByID(id: ID<NoteID>): Promise<Result.Result<Error, void>>;
 }
+
+export type NoteFilter =
+  | { type: 'author'; any: ID<AccountID>[] }
+  | { type: 'attachment'; more: number }
+  | { type: 'cw'; is: string }
+  | { type: 'created'; less: Date }
+  | { type: 'updated'; less: Date }
+  | { type: 'deleted'; has: boolean };

pkg/notes/service/fetch.ts

@@ -1,16 +1,30 @@
 import { Option, Result } from '@mikuroxina/mini-fn';
 
+import type { AccountID } from '../../accounts/model/account.js';
 import type { ID } from '../../id/type.js';
 import type { AccountModule } from '../../intermodule/account.js';
 import { type Note, type NoteID } from '../model/note.js';
-import type { NoteRepository } from '../model/repository.js';
+import type { NoteRepository, NoteFilter } from '../model/repository.js';
+
+export type Filter =
+  | { type: 'user'; any: ID<AccountID>[] }
+  | { type: 'attachment'; has: boolean }
+  | { type: 'nsfw'; is: boolean }
+  | { type: 'before'; less: Date }
+  | { type: 'deleted'; is: boolean };
 
 export class FetchNoteService {
   constructor(
     private readonly noteRepository: NoteRepository,
     private readonly accountModule: AccountModule,
   ) {}
 
+  async fetchNotesWithFilters(
+    filters: NoteFilter[],
+  ): Promise<Result.Result<Error, Note[]>> {
+    return this.noteRepository.getFiltered(filters);
+  }
+
   async fetchNoteByID(noteID: ID<NoteID>): Promise<Option.Option<Note>> {
     const note = await this.noteRepository.findByID(noteID);
     if (Option.isNone(note)) {

pkg/timeline/adaptor/controller/timeline.ts

@@ -0,0 +1,122 @@
+import { z } from '@hono/zod-openapi';
+import { Option, Result } from '@mikuroxina/mini-fn';
+
+import type {
+  AccountID,
+  AccountName,
+} from '../../../accounts/model/account.js';
+import type { FetchAccountService } from '../../../accounts/service/fetchAccount.js';
+import type { FetchAccountFollowService } from '../../../accounts/service/fetchAccountFollow.js';
+import type { ID } from '../../../id/type.js';
+import type { NoteFilter } from '../../../notes/model/repository.js';
+import type { FetchNoteService } from '../../../notes/service/fetch.js';
+import type { NoteSchema } from '../validator/schema.js';
+
+export class TimelineController {
+  constructor(
+    private readonly fetchAccountService: FetchAccountService,
+    private readonly fetchAccountFollowService: FetchAccountFollowService,
+    private readonly fetchNoteService: FetchNoteService,
+  ) {}
+
+  async getTimeline({
+    target,
+    hasAttachment,
+    isNsfw,
+    beforeID,
+  }: {
+    target?: string;
+    hasAttachment?: boolean;
+    isNsfw?: boolean;
+    beforeID?: string;
+  }): Promise<Result.Result<Error, z.infer<typeof NoteSchema>[]>> {
+    const filters: NoteFilter[] = [];
+
+    if (target !== undefined) {
+      const resFollows = isID<AccountID>(target)
+        ? await this.fetchAccountFollowService.fetchFollowsByID(target)
+        : isAccountName(target)
+          ? await this.fetchAccountFollowService.fetchFollowsByName(target)
+          : panic();
+
+      if (Result.isErr(resFollows)) {
+        return resFollows;
+      }
+
+      filters.push({
+        type: 'author',
+        any: resFollows[1].map((af) => af.getTargetID()),
+      });
+    }
+
+    if (hasAttachment !== undefined) {
+      filters.push({ type: 'attachment', more: hasAttachment ? 0 : -1 });
+    }
+
+    if (isNsfw !== undefined) {
+      filters.push({ type: 'cw', is: 'nsfw' });
+    }
+
+    if (beforeID !== undefined && isID<AccountID>(beforeID)) {
+      const beforeNote = await this.fetchNoteService
+        .fetchNoteByID(beforeID)
+        .then((o) => Option.unwrap(o));
+
+      filters.push({ type: 'created', less: beforeNote.getCreatedAt() });
+    }
+
+    const resNotes = await this.fetchNoteService.fetchNotesWithFilters(filters);
+    if (Result.isErr(resNotes)) {
+      return resNotes;
+    }
+
+    const notes = [];
+    for (const n of resNotes[1]) {
+      const resAccount = await this.fetchAccountService.fetchAccountByID(
+        n.getAuthorID(),
+      );
+
+      if (Result.isErr(resAccount)) {
+        return resAccount;
+      }
+
+      const a = resAccount[1];
+
+      notes.push({
+        id: n.getID(),
+        content: n.getContent(),
+        contents_warning_comment: n.getCwComment(),
+        send_to: n.getSendTo()[1],
+        visibility: n.getVisibility(),
+        created_at: n.getCreatedAt().toUTCString(),
+        author: {
+          id: a.getID(),
+          name: a.getName(),
+          display_name: a.getNickname(),
+          bio: a.getBio(),
+          avatar: '',
+          header: '',
+          followed_count: 0,
+          following_count: 0,
+        },
+      });
+    }
+
+    return Result.ok(notes);
+  }
+}
+
+const isID = <T>(s: string): s is ID<T> => {
+  return z
+    .string()
+    .regex(/^\d{64}$/)
+    .safeParse(s).success;
+};
+
+const isAccountName = (s: string): s is AccountName => {
+  return /@\w+@\w+/.test(s);
+};
+
+const panic = () => {
+  throw new Error('panic!');
+};

pkg/timeline/adaptor/validator/schema.ts

@@ -0,0 +1,23 @@
+import { z } from '@hono/zod-openapi';
+
+// TODO: もっとどうにかならんのか
+import { GetNoteResponseSchema } from '../../../notes/adaptor/validator/schema.js';
+
+export const NoteSchema = GetNoteResponseSchema;
+
+// TODO: 逃げてる
+export const CommonErrorResponseSchema = z.object({
+  error: z
+    .enum([
+      'INVALID_TIMELINE_TYPE',
+      'YOU_ARE_BLOCKED',
+      'NOTHING_LEFT',
+      'ACCOUNT_NOT_FOUND',
+    ])
+    .or(z.string())
+    .openapi({
+      description: 'Error code',
+    }),
+});
+
+export const GetTimelineResponseSchema = NoteSchema.array();