feat(meal-plan): weekly planner, pantry, shopping lists, nutrition tracking

AI-generated weekly meal plans with pantry-awareness. Manual entry per slot. Pantry inventory management. Auto-generated shopping lists from meal plan. Weekly nutrition bar chart vs daily goals. Nutrition goals settings.
2026-07-01 08:10:39 +02:00
parent 9d02a69250
commit 3636ab27ae
23 changed files with 1791 additions and 0 deletions
@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, mealPlans, mealPlanEntries, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ weekStart: string; entryId: string }> };
+
+export async function DELETE(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart, entryId } = await params;
+
+  const plan = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, session!.user.id), eq(mealPlans.weekStart, weekStart)),
+  });
+  if (!plan) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  await db.delete(mealPlanEntries).where(
+    and(eq(mealPlanEntries.id, entryId), eq(mealPlanEntries.mealPlanId, plan.id))
+  );
+
+  return new NextResponse(null, { status: 204 });
+}
@@ -0,0 +1,61 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, mealPlans, mealPlanEntries, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { dispatchWebhook } from "@/lib/webhooks";
+
+type Params = { params: Promise<{ weekStart: string }> };
+
+const Schema = z.object({
+  day: z.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"]),
+  mealType: z.enum(["breakfast", "lunch", "dinner", "snack"]),
+  recipeId: z.string().optional(),
+  servings: z.number().int().min(1).max(100).default(2),
+  note: z.string().max(500).optional(),
+});
+
+async function getOrCreatePlan(userId: string, weekStart: string) {
+  const existing = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, userId), eq(mealPlans.weekStart, weekStart)),
+  });
+  if (existing) return existing;
+
+  const id = crypto.randomUUID();
+  await db.insert(mealPlans).values({ id, userId, weekStart });
+  return { id, userId, weekStart };
+}
+
+export async function POST(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart } = await params;
+
+  const body = await req.json() as unknown;
+  const parsed = Schema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  const plan = await getOrCreatePlan(session!.user.id, weekStart);
+
+  // Remove existing entry for same day+mealType before inserting
+  await db.delete(mealPlanEntries).where(
+    and(
+      eq(mealPlanEntries.mealPlanId, plan.id),
+      eq(mealPlanEntries.day, parsed.data.day),
+      eq(mealPlanEntries.mealType, parsed.data.mealType)
+    )
+  );
+
+  const entryId = crypto.randomUUID();
+  await db.insert(mealPlanEntries).values({
+    id: entryId,
+    mealPlanId: plan.id,
+    day: parsed.data.day,
+    mealType: parsed.data.mealType,
+    recipeId: parsed.data.recipeId,
+    servings: parsed.data.servings,
+    note: parsed.data.note,
+  });
+
+  void dispatchWebhook(session!.user.id, "meal_plan.updated", { weekStart, day: parsed.data.day, mealType: parsed.data.mealType });
+  return NextResponse.json({ id: entryId }, { status: 201 });
+}
@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, mealPlans, mealPlanEntries, recipes, userNutritionGoals, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ weekStart: string }> };
+
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const { weekStart } = await params;
+  const userId = session!.user.id;
+
+  // Find the meal plan for this week
+  const plan = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, userId), eq(mealPlans.weekStart, weekStart)),
+  });
+
+  const totals = { calories: 0, protein: 0, carbs: 0, fat: 0 };
+
+  if (plan) {
+    // Fetch all entries with their recipes
+    const entries = await db.query.mealPlanEntries.findMany({
+      where: eq(mealPlanEntries.mealPlanId, plan.id),
+      with: {
+        recipe: {
+          columns: {
+            id: true,
+            baseServings: true,
+            nutritionData: true,
+          },
+        },
+      },
+    });
+
+    for (const entry of entries) {
+      const recipe = entry.recipe;
+      if (!recipe || !recipe.nutritionData?.perServing) continue;
+
+      const { calories, proteinG, carbsG, fatG } = recipe.nutritionData.perServing;
+      const servings = entry.servings ?? recipe.baseServings;
+
+      totals.calories += Math.round(calories * servings);
+      totals.protein += Math.round(proteinG * servings);
+      totals.carbs += Math.round(carbsG * servings);
+      totals.fat += Math.round(fatG * servings);
+    }
+  }
+
+  // Fetch user's nutrition goals
+  const goals = await db.query.userNutritionGoals.findFirst({
+    where: eq(userNutritionGoals.userId, userId),
+  });
+
+  const goalsData = goals
+    ? {
+        caloriesKcal: goals.caloriesKcal,
+        proteinG: goals.proteinG,
+        carbsG: goals.carbsG,
+        fatG: goals.fatG,
+      }
+    : null;
+
+  // Calculate coverage percentages
+  const coverage = {
+    calories:
+      goalsData?.caloriesKcal
+        ? Math.round((totals.calories / goalsData.caloriesKcal) * 100)
+        : 0,
+    protein:
+      goalsData?.proteinG
+        ? Math.round((totals.protein / goalsData.proteinG) * 100)
+        : 0,
+    carbs:
+      goalsData?.carbsG
+        ? Math.round((totals.carbs / goalsData.carbsG) * 100)
+        : 0,
+    fat:
+      goalsData?.fatG
+        ? Math.round((totals.fat / goalsData.fatG) * 100)
+        : 0,
+  };
+
+  return NextResponse.json({ totals, goals: goalsData, coverage });
+}
@@ -0,0 +1,43 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, mealPlans, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ weekStart: string }> };
+
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart } = await params;
+
+  const plan = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, session!.user.id), eq(mealPlans.weekStart, weekStart)),
+    with: {
+      entries: {
+        with: {
+          recipe: {
+            with: { photos: true },
+          },
+        },
+      },
+    },
+  });
+
+  if (!plan) return NextResponse.json({ weekStart, entries: [] });
+  return NextResponse.json(plan);
+}
+
+export async function POST(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart } = await params;
+
+  const existing = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, session!.user.id), eq(mealPlans.weekStart, weekStart)),
+  });
+
+  if (existing) return NextResponse.json(existing);
+
+  const id = crypto.randomUUID();
+  await db.insert(mealPlans).values({ id, userId: session!.user.id, weekStart });
+  return NextResponse.json({ id, weekStart }, { status: 201 });
+}
@@ -0,0 +1,43 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, pantryItems, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function PUT(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  const item = await db.query.pantryItems.findFirst({ where: and(eq(pantryItems.id, id), eq(pantryItems.userId, session!.user.id)) });
+  if (!item) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const body = await req.json() as unknown;
+  const parsed = z.object({
+    rawName: z.string().min(1).max(200).optional(),
+    quantity: z.string().nullable().optional(),
+    unit: z.string().nullable().optional(),
+    expiresAt: z.string().datetime().nullable().optional(),
+  }).safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  const data = parsed.data;
+  await db.update(pantryItems).set({
+    ...(data.rawName && { rawName: data.rawName }),
+    ...(data.quantity !== undefined && { quantity: data.quantity ?? undefined }),
+    ...(data.unit !== undefined && { unit: data.unit ?? undefined }),
+    ...(data.expiresAt !== undefined && { expiresAt: data.expiresAt ? new Date(data.expiresAt) : undefined }),
+  }).where(eq(pantryItems.id, id));
+
+  return NextResponse.json({ updated: true });
+}
+
+export async function DELETE(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  await db.delete(pantryItems).where(and(eq(pantryItems.id, id), eq(pantryItems.userId, session!.user.id)));
+  return new NextResponse(null, { status: 204 });
+}
@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, pantryItems, eq } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+const Schema = z.object({
+  items: z.array(z.object({
+    rawName: z.string().min(1).max(200),
+    quantity: z.string().optional(),
+    unit: z.string().optional(),
+  })).min(1),
+});
+
+export async function POST(req: NextRequest) {
+  const { session, response } = await requireSession();
+  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" }, { status: 400 });
+
+  const userId = session!.user.id;
+  const existing = await db.query.pantryItems.findMany({
+    where: eq(pantryItems.userId, userId),
+  });
+
+  for (const incoming of parsed.data.items) {
+    const key = incoming.rawName.toLowerCase();
+    const match = existing.find(
+      (e) => e.rawName.toLowerCase() === key && (e.unit ?? "") === (incoming.unit ?? "")
+    );
+
+    if (match) {
+      const existingQty = match.quantity ? parseFloat(match.quantity) : null;
+      const incomingQty = incoming.quantity ? parseFloat(incoming.quantity) : null;
+      if (existingQty !== null && incomingQty !== null && !isNaN(existingQty) && !isNaN(incomingQty)) {
+        const merged = existingQty + incomingQty;
+        await db.update(pantryItems)
+          .set({ quantity: String(merged) })
+          .where(eq(pantryItems.id, match.id));
+      }
+      // if quantities aren't numeric, leave as-is (item already exists)
+    } else {
+      await db.insert(pantryItems).values({
+        id: crypto.randomUUID(),
+        userId,
+        rawName: incoming.rawName,
+        quantity: incoming.quantity,
+        unit: incoming.unit,
+      });
+    }
+  }
+
+  return NextResponse.json({ ok: true });
+}
@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, pantryItems, eq, desc } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+const Schema = z.object({
+  rawName: z.string().min(1).max(200),
+  quantity: z.string().optional(),
+  unit: z.string().optional(),
+  expiresAt: z.string().datetime().optional(),
+});
+
+export async function GET(_req: NextRequest) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const items = await db.query.pantryItems.findMany({
+    where: eq(pantryItems.userId, session!.user.id),
+    orderBy: desc(pantryItems.createdAt),
+  });
+
+  return NextResponse.json(items);
+}
+
+export async function POST(req: NextRequest) {
+  const { session, response } = await requireSession();
+  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" }, { status: 400 });
+
+  const id = crypto.randomUUID();
+  await db.insert(pantryItems).values({
+    id,
+    userId: session!.user.id,
+    rawName: parsed.data.rawName,
+    quantity: parsed.data.quantity,
+    unit: parsed.data.unit,
+    expiresAt: parsed.data.expiresAt ? new Date(parsed.data.expiresAt) : undefined,
+  });
+
+  return NextResponse.json({ id }, { status: 201 });
+}
@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, shoppingLists, shoppingListItems, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ id: string; itemId: string }> };
+
+export async function PUT(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id, itemId } = await params;
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const body = await req.json() as { checked?: boolean };
+  await db.update(shoppingListItems)
+    .set({ checked: body.checked ?? false })
+    .where(and(eq(shoppingListItems.id, itemId), eq(shoppingListItems.listId, id)));
+
+  return NextResponse.json({ updated: true });
+}
@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, shoppingLists, shoppingListItems, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+const AddItemsSchema = z.object({
+  items: z.array(z.object({
+    rawName: z.string().min(1),
+    quantity: z.string().optional(),
+    unit: z.string().optional(),
+    aisle: z.string().optional(),
+  })).min(1),
+});
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function POST(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const body = await req.json() as unknown;
+  const parsed = AddItemsSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  await db.insert(shoppingListItems).values(
+    parsed.data.items.map((item) => ({
+      id: crypto.randomUUID(),
+      listId: id,
+      rawName: item.rawName,
+      quantity: item.quantity,
+      unit: item.unit,
+      aisle: item.aisle,
+      checked: false,
+    }))
+  );
+
+  return NextResponse.json({ ok: true }, { status: 201 });
+}
@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, shoppingLists, shoppingListItems, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { dispatchWebhook } from "@/lib/webhooks";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+    with: { items: { orderBy: (t, { asc }) => [asc(t.aisle), asc(t.rawName)] } },
+  });
+
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  return NextResponse.json(list);
+}
+
+const PatchSchema = z.object({ completed: z.boolean() });
+
+export async function PATCH(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const body = PatchSchema.safeParse(await req.json());
+  if (!body.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  if (body.data.completed) {
+    // Mark all items as checked
+    await db.update(shoppingListItems).set({ checked: true }).where(eq(shoppingListItems.listId, id));
+    void dispatchWebhook(session!.user.id, "shopping_list.completed", { id, name: list.name });
+  }
+
+  return NextResponse.json({ updated: true });
+}
+
+export async function DELETE(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  await db.delete(shoppingLists).where(and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)));
+  return new NextResponse(null, { status: 204 });
+}
@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, shoppingLists, shoppingListItems, mealPlans, mealPlanEntries, recipeIngredients, eq, and, desc, inArray } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+const CreateSchema = z.object({
+  name: z.string().min(1).max(100),
+  items: z.array(z.object({
+    rawName: z.string().min(1),
+    quantity: z.string().optional(),
+    unit: z.string().optional(),
+    aisle: z.string().optional(),
+  })).optional(),
+  fromMealPlanWeek: z.string().optional(),
+});
+
+export async function GET(_req: NextRequest) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const lists = await db.query.shoppingLists.findMany({
+    where: eq(shoppingLists.userId, session!.user.id),
+    orderBy: desc(shoppingLists.createdAt),
+    with: { items: { orderBy: (t, { asc }) => asc(t.aisle) } },
+  });
+
+  return NextResponse.json(lists);
+}
+
+export async function POST(req: NextRequest) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const body = await req.json() as unknown;
+  const parsed = CreateSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  const data = parsed.data;
+  const listId = crypto.randomUUID();
+
+  let items: Array<{ rawName: string; quantity?: string; unit?: string; aisle?: string }> = data.items ?? [];
+
+  if (data.fromMealPlanWeek) {
+    const plan = await db.query.mealPlans.findFirst({
+      where: and(eq(mealPlans.userId, session!.user.id), eq(mealPlans.weekStart, data.fromMealPlanWeek)),
+      with: { entries: true },
+    });
+
+    if (plan) {
+      const recipeIds = plan.entries.map((e) => e.recipeId).filter(Boolean) as string[];
+      if (recipeIds.length > 0) {
+        const ings = await db.query.recipeIngredients.findMany({
+          where: inArray(recipeIngredients.recipeId, recipeIds),
+        });
+
+        // Simple merge by rawName (case-insensitive)
+        const merged = new Map<string, { rawName: string; quantity?: string; unit?: string }>();
+        for (const ing of ings) {
+          const key = ing.rawName.toLowerCase();
+          if (!merged.has(key)) {
+            merged.set(key, { rawName: ing.rawName, quantity: ing.quantity ?? undefined, unit: ing.unit ?? undefined });
+          }
+        }
+        items = Array.from(merged.values());
+      }
+    }
+  }
+
+  await db.insert(shoppingLists).values({
+    id: listId,
+    userId: session!.user.id,
+    name: data.name,
+    generatedAt: data.fromMealPlanWeek ? new Date() : undefined,
+  });
+
+  if (items.length > 0) {
+    await db.insert(shoppingListItems).values(
+      items.map((item) => ({
+        id: crypto.randomUUID(),
+        listId,
+        rawName: item.rawName,
+        quantity: item.quantity,
+        unit: item.unit,
+        aisle: item.aisle,
+        checked: false,
+      }))
+    );
+  }
+
+  return NextResponse.json({ id: listId }, { status: 201 });
+}