feat: impl public timeline for all public notes (#1168)

laminne · web-flow · commit 2e5b9b7ce140 · 2025-08-31T23:49:51.000+09:00
diff --git a/pkg/timeline/adaptor/controller/timeline.ts b/pkg/timeline/adaptor/controller/timeline.ts
@@ -19,6 +19,7 @@ import type { FetchListService } from '../../service/fetchList.js';
 import type { FetchListMemberService } from '../../service/fetchMember.js';
 import type { HomeTimelineService } from '../../service/home.js';
 import type { ListTimelineService } from '../../service/list.js';
+import type { PublicTimelineService } from '../../service/public.js';
 import type { RemoveListMemberService } from '../../service/removeMember.js';
 import type {
   CreateListResponseSchema,
@@ -30,6 +31,7 @@ import type {
   GetHomeTimelineResponseSchema,
   GetListMemberResponseSchema,
   GetListTimelineResponseSchema,
+  GetPublicTimelineResponseSchema,
 } from '../validator/timeline.js';
 
 export class TimelineController {
@@ -47,6 +49,7 @@ export class TimelineController {
   private readonly removeListMemberService: RemoveListMemberService;
   private readonly fetchBookmarkTimelineService: FetchBookmarkService;
   private readonly fetchConversationService: FetchConversationService;
+  private readonly publicTimelineService: PublicTimelineService;
 
   constructor(args: {
     accountTimelineService: AccountTimelineService;
@@ -63,6 +66,7 @@ export class TimelineController {
     removeListMemberService: RemoveListMemberService;
     fetchBookmarkTimelineService: FetchBookmarkService;
     fetchConversationService: FetchConversationService;
+    publicTimelineService: PublicTimelineService;
   }) {
     this.accountTimelineService = args.accountTimelineService;
     this.accountModule = args.accountModule;
@@ -78,6 +82,7 @@ export class TimelineController {
     this.removeListMemberService = args.removeListMemberService;
     this.fetchBookmarkTimelineService = args.fetchBookmarkTimelineService;
     this.fetchConversationService = args.fetchConversationService;
+    this.publicTimelineService = args.publicTimelineService;
   }
 
   private async getNoteAdditionalData(notes: readonly Note[]): Promise<
@@ -625,4 +630,66 @@ export class TimelineController {
       }),
     );
   }
+
+  async getPublicTimeline(
+    hasAttachment: boolean,
+    noNsfw: boolean,
+    beforeId?: string,
+    afterId?: string,
+  ): Promise<
+    Result.Result<Error, z.infer<typeof GetPublicTimelineResponseSchema>>
+  > {
+    const res = await this.publicTimelineService.fetchPublicTimeline({
+      hasAttachment,
+      noNsfw,
+      beforeId: beforeId as NoteID | undefined,
+      afterID: afterId as NoteID | undefined,
+    });
+    if (Result.isErr(res)) {
+      return res;
+    }
+    const publicNotes = Result.unwrap(res);
+
+    const noteAdditionalDataRes = await this.getNoteAdditionalData(publicNotes);
+    if (Result.isErr(noteAdditionalDataRes)) {
+      return noteAdditionalDataRes;
+    }
+    const noteAdditionalData = Result.unwrap(noteAdditionalDataRes);
+
+    const result = noteAdditionalData.map((v) => {
+      return {
+        id: v.note.getID(),
+        content: v.note.getContent(),
+        contents_warning_comment: v.note.getCwComment(),
+        visibility: v.note.getVisibility(),
+        created_at: v.note.getCreatedAt().toUTCString(),
+        reactions: v.reactions.map((reaction) => ({
+          emoji: reaction.getEmoji(),
+          reacted_by: reaction.getAccountID(),
+        })),
+        attachment_files: v.attachments.map((file) => ({
+          id: file.getId(),
+          name: file.getName(),
+          author_id: file.getAuthorId(),
+          hash: file.getHash(),
+          mime: file.getMime(),
+          nsfw: file.isNsfw(),
+          url: file.getUrl(),
+          thumbnail: file.getThumbnailUrl(),
+        })),
+        author: {
+          id: v.author.getID(),
+          name: v.author.getName(),
+          display_name: v.author.getNickname(),
+          bio: v.author.getBio(),
+          avatar: v.avatar,
+          header: v.header,
+          followed_count: v.followCount.followed,
+          following_count: v.followCount.following,
+        },
+      };
+    });
+
+    return Result.ok(result);
+  }
 }
diff --git a/pkg/timeline/adaptor/repository/dummy.ts b/pkg/timeline/adaptor/repository/dummy.ts
@@ -19,6 +19,7 @@ import {
   conversationRepoSymbol,
   type FetchAccountTimelineFilter,
   type FetchConversationNotesFilter,
+  type FetchHomeTimelineFilter,
   type ListRepository,
   listRepoSymbol,
   type TimelineRepository,
@@ -103,6 +104,47 @@ export class InMemoryTimelineRepository implements TimelineRepository {
     return Result.ok(filtered);
   }
 
+  async getPublicTimeline(
+    filter: FetchHomeTimelineFilter,
+  ): Promise<Result.Result<Error, Note[]>> {
+    if (filter.afterID && filter.beforeId) {
+      return Result.err(
+        new TimelineInvalidFilterRangeError(
+          'beforeID and afterID cannot be specified at the same time',
+          { cause: null },
+        ),
+      );
+    }
+
+    const publicNotes = [...this.data.values()]
+      .filter((note) => note.getVisibility() === 'PUBLIC')
+      .sort((a, b) => b.getCreatedAt().getTime() - a.getCreatedAt().getTime());
+
+    // ToDo: filter hasAttachment, noNSFW
+
+    if (filter.afterID) {
+      const afterIndex = publicNotes.findIndex(
+        (note) => note.getID() === filter.afterID,
+      );
+
+      if (afterIndex === -1) {
+        return Result.ok(publicNotes.slice(0, 20));
+      }
+      const startIndex = Math.max(0, afterIndex - 20);
+      return Result.ok(publicNotes.slice(startIndex, afterIndex));
+    }
+
+    if (filter.beforeId) {
+      const beforeIndex = publicNotes.findLastIndex(
+        (note) => note.getID() === filter.beforeId,
+      );
+
+      return Result.ok(publicNotes.slice(beforeIndex + 1, beforeIndex + 21));
+    }
+
+    return Result.ok(publicNotes.slice(0, 20));
+  }
+
   async fetchListTimeline(
     noteId: readonly NoteID[],
   ): Promise<Result.Result<Error, Note[]>> {
diff --git a/pkg/timeline/adaptor/repository/prisma.ts b/pkg/timeline/adaptor/repository/prisma.ts
@@ -23,6 +23,7 @@ import {
   conversationRepoSymbol,
   type FetchAccountTimelineFilter,
   type FetchConversationNotesFilter,
+  type FetchHomeTimelineFilter,
   type ListRepository,
   listRepoSymbol,
   type TimelineRepository,
@@ -33,6 +34,34 @@ export class PrismaTimelineRepository implements TimelineRepository {
   private readonly TIMELINE_NOTE_LIMIT = 20;
   constructor(private readonly prisma: PrismaClient) {}
 
+  private buildCursorFilter(
+    filter: Pick<FetchHomeTimelineFilter, 'beforeId' | 'afterID'>,
+    limit: number = this.TIMELINE_NOTE_LIMIT,
+  ) {
+    return {
+      orderBy: {
+        createdAt: filter.afterID ? 'asc' : 'desc',
+      } as const,
+      ...(filter.beforeId
+        ? {
+            cursor: {
+              id: filter.beforeId,
+            },
+            skip: 1,
+          }
+        : {}),
+      ...(filter.afterID
+        ? {
+            cursor: {
+              id: filter.afterID,
+            },
+            skip: 1,
+          }
+        : {}),
+      take: limit,
+    };
+  }
+
   private deserialize(
     data: Prisma.PromiseReturnType<typeof this.prisma.note.findMany & {}>,
   ): Note[] {
@@ -87,27 +116,7 @@ export class PrismaTimelineRepository implements TimelineRepository {
       where: {
         authorId: accountId,
       },
-      orderBy: {
-        createdAt: filter.afterID ? 'asc' : 'desc',
-      },
-      ...(filter.beforeId
-        ? {
-            cursor: {
-              id: filter.beforeId,
-            },
-            // NOTE: Not include specified record
-            skip: 1,
-          }
-        : {}),
-      ...(filter.afterID
-        ? {
-            cursor: {
-              id: filter.afterID,
-            },
-            skip: 1,
-          }
-        : {}),
-      take: this.TIMELINE_NOTE_LIMIT,
+      ...this.buildCursorFilter(filter),
     });
 
     return Result.ok(this.deserialize(accountNotes));
@@ -130,6 +139,29 @@ export class PrismaTimelineRepository implements TimelineRepository {
     return Result.ok(this.deserialize(homeNotes));
   }
 
+  async getPublicTimeline(
+    filter: FetchHomeTimelineFilter,
+  ): Promise<Result.Result<Error, Note[]>> {
+    if (filter.afterID && filter.beforeId) {
+      return Result.err(
+        new TimelineInvalidFilterRangeError(
+          'beforeID and afterID cannot be specified at the same time',
+          { cause: null },
+        ),
+      );
+    }
+
+    const publicNotes = await this.prisma.note.findMany({
+      where: {
+        visibility: 0, // NOTE: PUBLIC
+        deletedAt: null,
+      },
+      ...this.buildCursorFilter(filter),
+    });
+
+    return Result.ok(this.deserialize(publicNotes));
+  }
+
   async fetchListTimeline(
     noteIDs: readonly NoteID[],
   ): Promise<Result.Result<Error, Note[]>> {
diff --git a/pkg/timeline/adaptor/validator/timeline.ts b/pkg/timeline/adaptor/validator/timeline.ts
@@ -49,6 +49,10 @@ export const GetAccountTimelineResponseSchema = z
 
 export const GetHomeTimelineResponseSchema = z.array(TimelineNoteBaseSchema);
 
+export const GetPublicTimelineResponseSchema = z
+  .array(TimelineNoteBaseSchema)
+  .openapi('GetPublicTimelineResponse');
+
 export const GetListTimelineResponseSchema = z
   .array(
     z.object({
diff --git a/pkg/timeline/mod.ts b/pkg/timeline/mod.ts
@@ -53,6 +53,7 @@ import {
   GetHomeTimelineRoute,
   GetListMemberRoute,
   GetListTimelineRoute,
+  GetPublicTimelineRoute,
 } from './router.js';
 import { accountTimeline } from './service/account.js';
 import { appendListMember } from './service/appendMember.js';
@@ -66,6 +67,7 @@ import { fetchListMember } from './service/fetchMember.js';
 import { homeTimeline } from './service/home.js';
 import { listTimeline } from './service/list.js';
 import { noteVisibility } from './service/noteVisibility.js';
+import { publicTimeline } from './service/public.js';
 import { removeListMember } from './service/removeMember.js';
 
 const isProduction = process.env.NODE_ENV === 'production';
@@ -155,6 +157,9 @@ const controller = new TimelineController({
     Cat.cat(fetchConversation).feed(Ether.compose(conversationRepository))
       .value,
   ),
+  publicTimelineService: Ether.runEther(
+    Cat.cat(publicTimeline).feed(Ether.compose(timelineRepository)).value,
+  ),
 });
 
 export const timeline = new OpenAPIHono<{
@@ -500,3 +505,26 @@ timeline.openapi(GetConversationRoute, async (c) => {
 
   return c.json(res[1], 200);
 });
+
+timeline.openapi(GetPublicTimelineRoute, async (c) => {
+  const { has_attachment, no_nsfw, before_id, after_id } = c.req.valid('query');
+  const res = await controller.getPublicTimeline(
+    has_attachment,
+    no_nsfw,
+    before_id,
+    after_id,
+  );
+  if (Result.isErr(res)) {
+    const error = Result.unwrapErr(res);
+    timelineModuleLogger.warn(error);
+
+    if (error instanceof TimelineNoMoreNotesError) {
+      return c.json({ error: 'NOTHING_LEFT' as const }, 404);
+    }
+
+    timelineModuleLogger.error('Uncaught error', error);
+    return c.json({ error: 'INTERNAL_ERROR' as const }, 500);
+  }
+
+  return c.json(Result.unwrap(res), 200);
+});
diff --git a/pkg/timeline/model/repository.ts b/pkg/timeline/model/repository.ts
@@ -45,6 +45,15 @@ export interface TimelineRepository {
     noteIDs: readonly NoteID[],
   ): Promise<Result.Result<Error, Note[]>>;
 
+  /**
+   * @description Fetch public timeline
+   * @param filter Filter for fetching notes
+   * @return {@link Note}[] list of public Notes, sorted by CreatedAt descending
+   * */
+  getPublicTimeline(
+    filter: FetchHomeTimelineFilter,
+  ): Promise<Result.Result<Error, Note[]>>;
+
   /**
    * @description Fetch list timeline
    * @param noteId IDs of the notes to be fetched
diff --git a/pkg/timeline/router.ts b/pkg/timeline/router.ts
@@ -21,6 +21,7 @@ import {
   GetHomeTimelineResponseSchema,
   GetListMemberResponseSchema,
   GetListTimelineResponseSchema,
+  GetPublicTimelineResponseSchema,
 } from './adaptor/validator/timeline.js'; /* NOTE: query params must use z.string() \
  cf. https://zenn.dev/loglass/articles/c237d89e238d42 (Japanese)\
  cf. https://github.com/honojs/middleware/issues/200#issuecomment-1773428171 (GitHub Issue)
@@ -90,6 +91,45 @@ export const GetHomeTimelineRoute = createRoute({
   },
 });
 
+export const GetPublicTimelineRoute = createRoute({
+  method: 'get',
+  tags: ['timeline'],
+  path: '/v0/timeline/public',
+  request: {
+    query: timelineFilterQuerySchema,
+  },
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: GetPublicTimelineResponseSchema,
+        },
+      },
+    },
+    404: {
+      description: 'Nothing left',
+      content: {
+        'application/json': {
+          schema: z.object({
+            error: NothingLeft,
+          }),
+        },
+      },
+    },
+    500: {
+      description: 'Internal error',
+      content: {
+        'application/json': {
+          schema: z.object({
+            error: TimelineInternalError,
+          }),
+        },
+      },
+    },
+  },
+});
+
 export const GetAccountTimelineRoute = createRoute({
   method: 'get',
   tags: ['timeline'],
diff --git a/pkg/timeline/service/public.test.ts b/pkg/timeline/service/public.test.ts
diff --git a/pkg/timeline/service/public.ts b/pkg/timeline/service/public.ts
diff --git a/resources/schema.json b/resources/schema.json
