feat: update getRecipes endpoint

apps/api/src/xrpc/blue.recipes.feed.getRecipes.ts

···
-import { db, desc, eq } from '@cookware/database';
+import { db, eq } from '@cookware/database';
 import { recipeTable } from '@cookware/database/schema';
-import { BlueRecipesFeedDefs, BlueRecipesFeedGetRecipes } from '@cookware/lexicons';
+import { BlueRecipesActorDefs, BlueRecipesFeedGetRecipes, BlueRecipesFeedRecipe } from '@cookware/lexicons';
 import { json, XRPCRouter } from '@atcute/xrpc-server';
-import { simpleFetchHandler, Client } from '@atcute/client';
-import { getAuthorInfo, parseDid } from '../util/api.js';
-import { AtprotoDid } from '@atcute/lexicons/syntax';
+import { parseDid } from '../util/api.js';
+import { AtprotoDid, ResourceUri } from '@atcute/lexicons/syntax';
 import { Logger } from 'pino';
+import { isLegacyBlob } from '@atcute/lexicons/interfaces';
 
 export const registerGetRecipes = (router: XRPCRouter, _logger: Logger) => {
   router.addQuery(BlueRecipesFeedGetRecipes.mainSchema, {
-    async handler({ params: { did } }) {
+    async handler({ params: { author, limit } }) {
       let foundDid: AtprotoDid | null = null;
-      if (did) foundDid = await parseDid(did);
+      if (author) foundDid = await parseDid(author);
 
       const recipes = await db.query.recipeTable.findMany({
-        columns: {
-          rkey: true,
-          title: true,
-          description: true,
-          time: true,
-          serves: true,
-          ingredientsCount: true,
-          stepsCount: true,
-          createdAt: true,
-          authorDid: true,
-          imageRef: true,
-          uri: true,
-        },
-        orderBy: [desc(recipeTable.createdAt)],
-        where: foundDid ? eq(recipeTable.authorDid, foundDid) : undefined,
-      });
-
-      const rpc = new Client({
-        handler: simpleFetchHandler({
-          service: 'https://public.api.bsky.app',
-        }),
+        orderBy: recipeTable.createdAt,
+        limit: limit,
+        where: foundDid ? eq(recipeTable.did, foundDid) : undefined,
       });
 
-      let authorInfo: BlueRecipesFeedDefs.AuthorInfo | null = null;
-      if (foundDid) {
-        authorInfo = await getAuthorInfo(foundDid, rpc);
-      };
-
-      const results = [];
-      const eachRecipe = async (r: typeof recipes[0]) => ({
-        author: authorInfo || await getAuthorInfo(r.authorDid, rpc),
-        rkey: r.rkey,
-        title: r.title,
-        time: r.time,
-        serves: r.serves ?? 1,
-        description: r.description || undefined,
-        ingredients: r.ingredientsCount as number,
-        steps: r.stepsCount as number,
-        imageUrl: r.imageRef
-          ? `https://cdn.bsky.app/img/feed_thumbnail/plain/${r.authorDid}/${r.imageRef}@jpeg`
-          : undefined,
-      });
-
-      for (const result of recipes) {
-        results.push(await eachRecipe(result));
-      }
-
       return json({
-        author: authorInfo || undefined,
-        recipes: results,
+        nextCursor: '',
+        recipes: recipes.map((recipe) => ({
+          author: {
+            $type: BlueRecipesActorDefs.profileViewBasicSchema.shape.$type.wrapped.expected,
+            did: recipe.did,
+            handle: 'hayden.moe',
+            createdAt: new Date().toISOString(),
+          },
+          cid: '',
+          indexedAt: new Date().toISOString(),
+          record: {
+            $type: BlueRecipesFeedRecipe.mainSchema.object.shape.$type.expected,
+            title: recipe.title,
+            description: recipe.description ?? undefined,
+            time: recipe.time ?? undefined,
+            serves: recipe.serves ?? undefined,
+            ingredients: recipe.ingredients as BlueRecipesFeedRecipe.Ingredient[],
+            steps: recipe.steps as BlueRecipesFeedRecipe.Step[],
+            image: isLegacyBlob(recipe.imageRef) ? undefined : recipe.imageRef ?? undefined,
+            createdAt: recipe.createdAt.toISOString(),
+          },
+          uri: recipe.uri as ResourceUri,
+        })),
       });
     }
   });

libs/lexicons/lexicons/feed/getRecipes.tsp

···
 import "@typelex/emitter";
+import "./defs.tsp";
 
 namespace blue.recipes.feed.getRecipes {
   /** Response model for fetching multiple recipes. */
···
     @minValue(1) @maxValue(100) limit?: integer = 50,
     cursor?: string,
   ): {
-    @required recipes: blue.recipes.feed.recipe.Main[];
+    @required recipes: blue.recipes.feed.defs.RecipeView[];
     @required nextCursor: string;
   };
 }

libs/lexicons/lib/types/blue/recipes/feed/getRecipes.ts

···
 import type {} from "@atcute/lexicons";
 import * as v from "@atcute/lexicons/validations";
 import type {} from "@atcute/lexicons/ambient";
-import * as BlueRecipesFeedRecipe from "./recipe.js";
+import * as BlueRecipesFeedDefs from "./defs.js";
 
 const _mainSchema = /*#__PURE__*/ v.query("blue.recipes.feed.getRecipes", {
   params: /*#__PURE__*/ v.object({
···
     schema: /*#__PURE__*/ v.object({
       nextCursor: /*#__PURE__*/ v.string(),
       get recipes() {
-        return /*#__PURE__*/ v.array(BlueRecipesFeedRecipe.mainSchema);
+        return /*#__PURE__*/ v.array(BlueRecipesFeedDefs.recipeViewSchema);
       },
     }),
   },