feat: generate a complete themed meal from a collection (v0.52.0)

New "Generate meal" button on any owned collection — pick a theme (free
text) and 2-6 courses (starter/main/side/dessert/drink), one generateObject
call produces a coherent recipe per course (shared cuisine/style, matching
flavors across courses) and all of them get saved as real recipes and
added to that collection in one action.

Follows the meal-plan generation route's established pattern: single
withAiQuota charge for the whole generation, then a pre-flight loop
charging the tier's recipe limit once per generated recipe (rolled back
on a partial breach) before the insert transaction runs. Recipes are
tagged with their course name for later filtering; visibility defaults to
private like every other AI-generated recipe.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

apps/web/app/(app)/collections/[id]/page.tsx

@@ -9,6 +9,7 @@ import { RecipeCard } from "@/components/recipe/recipe-card";
 import { CollectionRecipesGrid } from "@/components/collections/collection-recipes-grid";
 import { ForkCollectionButton } from "@/components/collections/fork-collection-button";
 import { ShareCollectionButton } from "@/components/collections/share-collection-button";
+import { GenerateMealDialog } from "@/components/collections/generate-meal-dialog";
 import { buttonVariants } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
 import { ExportMarkdownButton } from "@/components/shared/export-markdown-button";
@@ -65,6 +66,7 @@ export default async function CollectionPage({ params }: Params) {
               />
             </>
           )}
+          {isOwner && <GenerateMealDialog collectionId={id} />}
           {isOwner && <ShareCollectionButton collectionId={id} />}
           {!isOwner && col.isPublic && (
             <ForkCollectionButton collectionId={id} />

apps/web/app/api/v1/ai/generate-meal/route.ts

@@ -0,0 +1,133 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, recipes, recipeIngredients, recipeSteps, collections, collectionRecipes, eq, and } from "@epicure/db";
+import { requireSessionOrApiKey } from "@/lib/api-auth";
+import { applyRateLimit } from "@/lib/rate-limit";
+import { getDefaultProviderWithKey } from "@/lib/ai/resolve-user-key";
+import { withAiQuota, resolveAiConfigOrError } from "@/lib/ai/ai-error";
+import { checkAndIncrementTierLimit, incrementUsage, TierLimitError } from "@/lib/tiers";
+import { generateMeal, MEAL_COURSES } from "@/lib/ai/features/generate-meal";
+import { getUserPrivateBio } from "@/lib/ai/user-bio";
+
+const Schema = z.object({
+  collectionId: z.string().min(1),
+  theme: z.string().min(1).max(200),
+  courses: z.array(z.enum(MEAL_COURSES)).min(2).max(6).refine((c) => new Set(c).size === c.length, "Duplicate courses"),
+  servings: z.number().int().min(1).max(20).default(4),
+  dietaryPrefs: z.string().max(200).optional(),
+  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+});
+
+export async function POST(req: NextRequest) {
+  const { session, response } = await requireSessionOrApiKey(req);
+  if (response) return response;
+
+  const body = await req.json() as unknown;
+  const parsed = Schema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ error: "Validation error", issues: parsed.error.issues }, { status: 400 });
+  }
+
+  const userId = session!.user.id;
+  const tier = session!.user.tier as "free" | "pro" | "family";
+  const { collectionId, theme, courses, servings, dietaryPrefs, difficulty } = parsed.data;
+
+  const collection = await db.query.collections.findFirst({
+    where: and(eq(collections.id, collectionId), eq(collections.userId, userId)),
+  });
+  if (!collection) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const limited = await applyRateLimit(`rl:ai:${userId}`, 3, 60);
+  if (limited) return limited;
+
+  const locale = (session!.user as { locale?: string }).locale ?? "en";
+  const [configResult, privateBio] = await Promise.all([
+    resolveAiConfigOrError(() => getDefaultProviderWithKey(userId, "mealPlan")),
+    getUserPrivateBio(userId),
+  ]);
+  if (!configResult.ok) return configResult.response;
+  const config = configResult.data;
+
+  const result = await withAiQuota(userId, tier, () =>
+    generateMeal(
+      { theme, courses, servings, dietaryPrefs, difficulty },
+      { ...config, userContext: privateBio ?? undefined },
+      locale
+    ), { skipQuota: config.isByok }
+  );
+  if (!result.ok) return result.response;
+  const meal = result.data;
+
+  // Each recipe in the meal creates a real recipe row — charge the recipe
+  // limit for all of them before inserting anything, refunding on breach
+  // so a rejected meal doesn't consume quota (same pattern as meal-plan
+  // generation).
+  let chargedRecipes = 0;
+  try {
+    for (let i = 0; i < meal.recipes.length; i++) {
+      await checkAndIncrementTierLimit(userId, tier, "recipe");
+      chargedRecipes++;
+    }
+  } catch (err) {
+    if (err instanceof TierLimitError) {
+      if (chargedRecipes > 0) await incrementUsage(userId, "recipe", -chargedRecipes);
+      return NextResponse.json({ error: "Recipe limit reached for your tier" }, { status: 403 });
+    }
+    throw err;
+  }
+
+  const created: Array<{ id: string; title: string; course: string }> = [];
+
+  await db.transaction(async (tx) => {
+    for (const recipe of meal.recipes) {
+      const recipeId = crypto.randomUUID();
+      await tx.insert(recipes).values({
+        id: recipeId,
+        authorId: userId,
+        title: recipe.title,
+        description: recipe.description,
+        baseServings: recipe.baseServings,
+        recipeType: recipe.recipeType,
+        visibility: "private",
+        aiGenerated: true,
+        difficulty: recipe.difficulty ?? null,
+        prepMins: recipe.prepMins ?? null,
+        cookMins: recipe.cookMins ?? null,
+        dietaryTags: recipe.dietaryTags ?? {},
+        tags: [recipe.course],
+      });
+
+      if (recipe.ingredients.length > 0) {
+        await tx.insert(recipeIngredients).values(
+          recipe.ingredients.map((ing, i) => ({
+            id: crypto.randomUUID(),
+            recipeId,
+            rawName: ing.rawName,
+            quantity: ing.quantity != null ? String(ing.quantity) : null,
+            unit: ing.unit ?? null,
+            note: ing.note ?? null,
+            order: i,
+          }))
+        );
+      }
+
+      if (recipe.steps.length > 0) {
+        await tx.insert(recipeSteps).values(
+          recipe.steps.map((step, i) => ({
+            id: crypto.randomUUID(),
+            recipeId,
+            instruction: step.instruction,
+            timerSeconds: step.timerSeconds ?? null,
+            order: i,
+          }))
+        );
+      }
+
+      await tx.insert(collectionRecipes).values({ collectionId, recipeId }).onConflictDoNothing();
+
+      created.push({ id: recipeId, title: recipe.title, course: recipe.course });
+    }
+  });
+
+  return NextResponse.json({ collectionId, recipes: created });
+}