feat: add getActorFavs, update getTimeline to support following feed

__generated__/index.ts

···
 import * as SocialGrainFeedGetTimeline from './types/social/grain/feed/getTimeline.ts'
 import * as SocialGrainActorGetProfile from './types/social/grain/actor/getProfile.ts'
 import * as SocialGrainActorSearchActors from './types/social/grain/actor/searchActors.ts'
+import * as SocialGrainActorGetActorFavs from './types/social/grain/actor/getActorFavs.ts'
 
 export const APP_BSKY_GRAPH = {
   DefsModlist: 'app.bsky.graph.defs#modlist',
···
     >,
   ) {
     const nsid = 'social.grain.actor.searchActors' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorFavs<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainActorGetActorFavs.Handler<ExtractAuth<AV>>,
+      SocialGrainActorGetActorFavs.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.actor.getActorFavs' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 }

__generated__/lexicons.ts

···
             },
           },
         },
-        errors: [
-          {
-            name: 'BlockedActor',
-          },
-          {
-            name: 'BlockedByActor',
-          },
-        ],
       },
     },
   },
···
       },
     },
   },
+  SocialGrainActorGetActorFavs: {
+    lexicon: 1,
+    id: 'social.grain.actor.getActorFavs',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          "Get a view of an actor's favorite galleries. Does not require auth.",
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['items'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              items: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.gallery.defs#galleryView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainActorProfile: {
     lexicon: 1,
     id: 'social.grain.actor.profile',
···
   SocialGrainActorDefs: 'social.grain.actor.defs',
   SocialGrainActorGetProfile: 'social.grain.actor.getProfile',
   SocialGrainActorSearchActors: 'social.grain.actor.searchActors',
+  SocialGrainActorGetActorFavs: 'social.grain.actor.getActorFavs',
   SocialGrainActorProfile: 'social.grain.actor.profile',
   SocialGrainPhotoDefs: 'social.grain.photo.defs',
   SocialGrainPhotoExif: 'social.grain.photo.exif',

__generated__/types/social/grain/actor/getActorFavs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+import type * as SocialGrainGalleryDefs from "../gallery/defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.actor.getActorFavs";
+
+export interface QueryParams {
+  actor: string;
+  limit: number;
+  cursor?: string;
+}
+
+export type InputSchema = undefined;
+
+export interface OutputSchema {
+  cursor?: string;
+  items: SocialGrainGalleryDefs.GalleryView[];
+}
+
+export type HandlerInput = undefined;
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/gallery/getActorGalleries.ts

···
 export interface HandlerError {
   status: number;
   message?: string;
-  error?: "BlockedActor" | "BlockedByActor";
 }
 
 export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;

lexicons/social/grain/actor/getActorFavs.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.actor.getActorFavs",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a view of an actor's favorite galleries. Does not require auth.",
+      "parameters": {
+        "type": "params",
+        "required": ["actor"],
+        "properties": {
+          "actor": { "type": "string", "format": "at-identifier" },
+          "limit": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 100,
+            "default": 50
+          },
+          "cursor": { "type": "string" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["items"],
+          "properties": {
+            "cursor": { "type": "string" },
+            "items": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "social.grain.gallery.defs#galleryView"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/getActorGalleries.json

···
             }
           }
         }
-      },
-      "errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]
+      }
     }
   }
 }

src/api/mod.ts

···
 import { ProfileView } from "$lexicon/types/social/grain/actor/defs.ts";
 import {
+  OutputSchema as GetActorFavsOutputSchema,
+  QueryParams as GetActorFavsQueryParams,
+} from "$lexicon/types/social/grain/actor/getActorFavs.ts";
+import {
   OutputSchema as GetProfileOutputSchema,
   QueryParams as GetProfileQueryParams,
 } from "$lexicon/types/social/grain/actor/getProfile.ts";
···
 } from "$lexicon/types/social/grain/actor/searchActors.ts";
 import {
   OutputSchema as GetTimelineOutputSchema,
+  QueryParams as GetTimelineQueryParams,
 } from "$lexicon/types/social/grain/feed/getTimeline.ts";
 import {
   OutputSchema as GetActorGalleriesOutputSchema,
···
 import { BffMiddleware, route } from "@bigmoves/bff";
 import {
   getActorGalleries,
+  getActorGalleryFavs,
   getActorProfileDetailed,
   searchActors,
 } from "../lib/actor.ts";
···
 import { getGalleryComments } from "../modules/comments.tsx";
 
 export const middlewares: BffMiddleware[] = [
-  route("/oauth/session", (_req, _params, ctx) => {
+  route("/oauth/session", async (_req, _params, ctx) => {
     if (!ctx.currentUser) {
       return ctx.json("Unauthorized", 401);
     }
···
     const galleries = getActorGalleries(actor, ctx);
     return ctx.json({ items: galleries } as GetActorGalleriesOutputSchema);
   }),
+  route("/xrpc/social.grain.actor.getActorFavs", (req, _params, ctx) => {
+    const url = new URL(req.url);
+    const { actor } = getActorFavsQueryParams(url);
+    const galleries = getActorGalleryFavs(actor, ctx);
+    return ctx.json({ items: galleries } as GetActorFavsOutputSchema);
+  }),
   route("/xrpc/social.grain.gallery.getGallery", (req, _params, ctx) => {
     const url = new URL(req.url);
     const { uri } = getGalleryQueryParams(url);
···
     const comments = getGalleryComments(uri, ctx);
     return ctx.json({ gallery, comments } as GetGalleryThreadOutputSchema);
   }),
-  route("/xrpc/social.grain.feed.getTimeline", async (_req, _params, ctx) => {
-    // const url = new URL(req.url);
-    // const { algorithm, limit, cursor } = getTimelineQueryParams(url);
+  route("/xrpc/social.grain.feed.getTimeline", async (req, _params, ctx) => {
+    const url = new URL(req.url);
+    const { algorithm } = getTimelineQueryParams(url);
     const items = await getTimeline(
       ctx,
-      "timeline",
+      algorithm === "following" ? "following" : "timeline",
       "grain",
     );
     return ctx.json(
···
   return { actor, limit, cursor };
 }
 
+function getActorFavsQueryParams(url: URL): GetActorFavsQueryParams {
+  const actor = url.searchParams.get("actor");
+  if (!actor) throw new BadRequestError("Missing actor parameter");
+  const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+  if (isNaN(limit) || limit <= 0) {
+    throw new BadRequestError("Invalid limit parameter");
+  }
+  const cursor = url.searchParams.get("cursor") ?? undefined;
+  return { actor, limit, cursor };
+}
+
 function getGalleryQueryParams(url: URL): GetGalleryQueryParams {
   const uri = url.searchParams.get("uri");
   if (!uri) throw new BadRequestError("Missing uri parameter");
···
 //   return { limit, cursor };
 // }
 
-// function getTimelineQueryParams(url: URL): GetTimelineQueryParams {
-//   const algorithm = url.searchParams.get("algorithm") ?? undefined;
-//   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
-//   if (isNaN(limit) || limit <= 0) {
-//     throw new BadRequestError("Invalid limit parameter");
-//   }
-//   const cursor = url.searchParams.get("cursor") ?? undefined;
-//   return { algorithm, limit, cursor };
-// }
+function getTimelineQueryParams(url: URL): GetTimelineQueryParams {
+  const algorithm = url.searchParams.get("algorithm") ?? undefined;
+  const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+  if (isNaN(limit) || limit <= 0) {
+    throw new BadRequestError("Invalid limit parameter");
+  }
+  const cursor = url.searchParams.get("cursor") ?? undefined;
+  return { algorithm, limit, cursor };
+}