Fas 3 steg 3a: cooking_sessions-tabell + lifecycle-endpoints + timeout-jobb, gamla /cook kvar som kortkommando

2026-08-07 03:14:13 +07:00
parent 4a4f448e1c
commit e9fb4a17d4
17 changed files with 10619 additions and 196 deletions
@@ -0,0 +1,198 @@
+import type { FastifyInstance } from "fastify";
+import { and, eq, lt } from "drizzle-orm";
+import { schema, markMilestone } from "@app/database";
+import {
+  cookingSessionStartInputSchema,
+  cookingSessionCompleteInputSchema,
+  idParamSchema,
+} from "@app/validation";
+import { errors, parse } from "../lib/errors.js";
+import { requireActiveHousehold, requireMembership } from "../lib/helpers.js";
+import {
+  cookingSessionStarted,
+  cookingSessionCompleted,
+  cookingSessionCancelled,
+} from "@app/analytics";
+import { trackProductAnalytics } from "../lib/helpers.js";
+import { completeCookingSessionCore } from "../lib/cooking.js";
+import { z } from "zod";
+
+/**
+ * Cooking Sessions (Fas 3 §6).
+ *
+ * - PLANNED reserverar aldrig lager.
+ * - STARTED har 24 h på sig att complete/cancel (§20 timeout).
+ * - COMPLETED/CANCELLED är terminala.
+ * - Gamla POST /v1/recipes/:id/cook finns kvar som kortkommando.
+ */
+export async function cookingSessionRoutes(app: FastifyInstance) {
+  const auth = { preHandler: [app.authenticate] };
+
+  /** Skapa ny session. Status planned om startNow saknas, annars started. */
+  app.post("/v1/recipes/:id/cook/start", auth, async (req, reply) => {
+    const { id } = parse(idParamSchema, req.params);
+    const input = parse(cookingSessionStartInputSchema, req.body);
+    const householdId = await requireActiveHousehold(app.db, req.userId);
+    await requireMembership(app.db, householdId, req.userId);
+
+    const [recipe] = await app.db
+      .select({ id: schema.recipes.id, portions: schema.recipes.portions })
+      .from(schema.recipes)
+      .where(eq(schema.recipes.id, id))
+      .limit(1);
+    if (!recipe) throw errors.notFound("Receptet finns inte.");
+
+    const now = new Date();
+    const status = input.startNow ? "started" : "planned";
+
+    const [session] = await app.db
+      .insert(schema.cookingSessions)
+      .values({
+        recipeId: id,
+        householdId,
+        startedByUserId: req.userId,
+        status,
+        plannedPortions: input.portions ?? recipe.portions,
+        plannedMealType: input.mealType ?? "dinner",
+        startedAt: input.startNow ? now : null,
+      })
+      .returning();
+
+    await trackProductAnalytics(
+      app.db,
+      req.userId,
+      cookingSessionStarted({
+        householdId,
+        properties: {
+          cookingSessionId: session!.id,
+          recipeId: id,
+          status,
+          plannedPortions: input.portions ?? recipe.portions,
+        },
+      }),
+    );
+
+    return reply.status(201).send({ session: session });
+  });
+
+  /** Starta en planned session. */
+  app.post("/v1/cooking-sessions/:id/start", auth, async (req) => {
+    const { id } = parse(idParamSchema, req.params);
+    const session = await getOwnedSession(app, id, req.userId);
+    if (session.status !== "planned") throw errors.conflict("Sessionen är inte planerad.");
+
+    const [updated] = await app.db
+      .update(schema.cookingSessions)
+      .set({ status: "started", startedAt: new Date(), updatedAt: new Date() })
+      .where(eq(schema.cookingSessions.id, id))
+      .returning();
+
+    await trackProductAnalytics(
+      app.db,
+      req.userId,
+      cookingSessionStarted({
+        householdId: session.householdId,
+        properties: { cookingSessionId: id, recipeId: session.recipeId, status: "started" },
+      }),
+    );
+
+    return { session: updated };
+  });
+
+  /** Avbryt session utan att röra lagret. */
+  app.post("/v1/cooking-sessions/:id/cancel", auth, async (req) => {
+    const params = z.object({ id: z.uuid() }).parse(req.params);
+    const body = z.object({ reason: z.string().max(200).optional() }).parse(req.body ?? {});
+    const session = await getOwnedSession(app, params.id, req.userId);
+    if (session.status === "completed" || session.status === "cancelled") {
+      throw errors.conflict("Sessionen är redan avslutad.");
+    }
+
+    const [updated] = await app.db
+      .update(schema.cookingSessions)
+      .set({
+        status: "cancelled",
+        cancelledAt: new Date(),
+        cancelReason: body.reason ?? null,
+        updatedAt: new Date(),
+      })
+      .where(eq(schema.cookingSessions.id, params.id))
+      .returning();
+
+    await trackProductAnalytics(
+      app.db,
+      req.userId,
+      cookingSessionCancelled({
+        householdId: session.householdId,
+        properties: { cookingSessionId: params.id, recipeId: session.recipeId },
+      }),
+    );
+
+    return { session: updated };
+  });
+
+  /**
+   * Complete en session.
+   * I steg 3a: anropar samma logik som gamla /cook, men länkar allt till cookingSessionId.
+   */
+  app.post("/v1/cooking-sessions/:id/complete", auth, async (req) => {
+    const { id } = parse(idParamSchema, req.params);
+    const input = parse(cookingSessionCompleteInputSchema, req.body);
+    const session = await getOwnedSession(app, id, req.userId);
+    if (session.status !== "started") {
+      throw errors.conflict("Sessionen måste vara startad för att avslutas.");
+    }
+
+    const result = await completeCookingSessionCore(app, session, req.userId, input, req.correlationId);
+
+    const [updated] = await app.db
+      .select()
+      .from(schema.cookingSessions)
+      .where(eq(schema.cookingSessions.id, id))
+      .limit(1);
+
+    await trackProductAnalytics(
+      app.db,
+      req.userId,
+      cookingSessionCompleted({
+        householdId: session.householdId,
+        properties: {
+          cookingSessionId: id,
+          recipeId: session.recipeId,
+          portionsCooked: session.plannedPortions,
+          mealBoxPortions: input.mealBoxPortions ?? 0,
+        },
+      }),
+    );
+
+    return { ...result, session: updated };
+  });
+
+  /** Lista hushållets aktiva sessioner. */
+  app.get("/v1/cooking-sessions", auth, async (req) => {
+    const householdId = await requireActiveHousehold(app.db, req.userId);
+    await requireMembership(app.db, householdId, req.userId);
+    const sessions = await app.db
+      .select()
+      .from(schema.cookingSessions)
+      .where(
+        and(
+          eq(schema.cookingSessions.householdId, householdId),
+          eq(schema.cookingSessions.status, "started"),
+        ),
+      )
+      .orderBy(schema.cookingSessions.startedAt);
+    return { sessions };
+  });
+}
+
+async function getOwnedSession(app: FastifyInstance, sessionId: string, userId: string) {
+  const [session] = await app.db
+    .select()
+    .from(schema.cookingSessions)
+    .where(eq(schema.cookingSessions.id, sessionId))
+    .limit(1);
+  if (!session) throw errors.notFound("Sessionen finns inte.");
+  await requireMembership(app.db, session.householdId, userId);
+  return session;
+}
@@ -32,6 +32,7 @@ import {
  todayIso,
 } from "../lib/helpers.js";
 import { requireFeature } from "../lib/entitlements.js";
+import { completeCookingSessionCore } from "../lib/cooking.js";

 /** Recept: sök, detalj, betyg, favoriter, "jag har lagat", substitutioner, användarrecept. */
 export async function recipeRoutes(app: FastifyInstance) {
@@ -415,204 +416,26 @@ export async function recipeRoutes(app: FastifyInstance) {
  app.post("/v1/recipes/:id/cook", auth, async (req) => {
    const { id } = parse(idParamSchema, req.params);
    const input = parse(cookRecipeInputSchema, req.body);
-    const recipe = await loadFullRecipe(app, id);
+    await loadFullRecipe(app, id);
    const householdId = await requireActiveHousehold(app.db, req.userId);
-    const date = input.date ?? todayIso();

-    // 1. Dra lager enligt FEFO (spec §17: prioritera utgångsdatum)
-    const deductions: Array<{ itemId: string; quantity: number; unit: string; name: string }> = [];
-    if (input.deductInventory) {
-      const factor = input.portionsCooked / recipe.portions;
-      const overrides = new Map(input.inventoryOverrides.map((o) => [o.canonicalIngredientId, o]));
-
-      for (const ing of recipe.ingredients) {
-        if (ing.optional) continue;
-        const override = overrides.get(ing.canonicalIngredientId);
-        const requiredQty = override ? override.quantityUsed : ing.quantity * factor;
-        const requiredUnit = override ? override.unit : ing.unit;
-        if (requiredQty <= 0) continue;
-
-        const stock = await app.db
-          .select()
-          .from(schema.inventoryItems)
-          .where(
-            and(
-              eq(schema.inventoryItems.householdId, householdId),
-              eq(schema.inventoryItems.canonicalIngredientId, ing.canonicalIngredientId),
-              isNull(schema.inventoryItems.depletedAt),
-              gt(schema.inventoryItems.quantity, 0),
-            ),
-          );
-        if (stock.length === 0) continue;
-
-        const [info] = await app.db
-          .select()
-          .from(schema.canonicalIngredients)
-          .where(eq(schema.canonicalIngredients.id, ing.canonicalIngredientId))
-          .limit(1);
-
-        const allocation = allocateFefo(
-          requiredQty,
-          requiredUnit,
-          stock.map((s) => ({
-            id: s.id,
-            canonicalIngredientId: s.canonicalIngredientId,
-            quantity: s.quantity,
-            unit: s.unit,
-            bestBeforeDate: s.bestBeforeDate,
-            useByDate: s.useByDate,
-            openedAt: s.openedAt,
-            frozenAt: s.frozenAt,
-            thawedAt: s.thawedAt,
-            purchasedAt: s.purchasedAt,
-          })),
-          { densityGPerMl: info?.densityGPerMl, gramsPerPiece: info?.gramsPerPiece },
-        );
-
-        for (const alloc of allocation.allocations) {
-          const item = stock.find((s) => s.id === alloc.itemId)!;
-          const newQty = Math.max(0, Math.round((item.quantity - alloc.quantity) * 1000) / 1000);
-          await app.db.insert(schema.inventoryTransactions).values({
-            householdId,
-            inventoryItemId: alloc.itemId,
-            type: "cook_use",
-            quantityDelta: -(item.quantity - newQty),
-            unit: item.unit,
-            refType: "recipe_cook",
-            refId: id,
-            actorUserId: req.userId,
-          });
-          await app.db
-            .update(schema.inventoryItems)
-            .set({
-              quantity: newQty,
-              depletedAt: newQty <= 0 ? new Date() : null,
-              updatedAt: new Date(),
-            })
-            .where(eq(schema.inventoryItems.id, alloc.itemId));
-          deductions.push({
-            itemId: alloc.itemId,
-            quantity: alloc.quantity,
-            unit: alloc.unit,
-            name: item.displayName,
-          });
-        }
-      }
-    }
-
-    // 2. Logga måltid per ätare med portionsandel (spec §7: individuellt)
-    const eaters =
-      input.eaters.length > 0 ? input.eaters : [{ userId: req.userId, portionFraction: 1 }];
-    const mealIds: string[] = [];
-    for (const eater of eaters) {
-      const nutrition = scaleNutrition(recipe.nutritionPerPortion, eater.portionFraction);
-      const [meal] = await app.db
-        .insert(schema.meals)
-        .values({
-          userId: eater.userId,
-          householdId,
-          date,
-          mealType: input.mealType,
-          source: "cooked_recipe",
-          recipeId: id,
-          titleSv: recipe.titleSv,
-          portionFraction: eater.portionFraction,
-          nutrition,
-          nutritionIsEstimate: false,
-        })
-        .returning();
-      mealIds.push(meal!.id);
-      await emitEvent(app.db, {
-        type: "MEAL_LOGGED",
-        payload: {
-          mealId: meal!.id,
-          mealType: input.mealType,
-          kcal: nutrition.kcal,
-          source: "cooked_recipe",
-        },
-        userId: eater.userId,
-        householdId,
-        correlationId: req.correlationId,
-      });
-    }
-
-    // 3. Matlådor (spec §24)
-    let mealBoxId: string | null = null;
-    if (input.mealBoxPortions > 0) {
-      const locationId =
-        input.mealBoxStorageLocationId ??
-        (
-          await app.db
-            .select({ id: schema.storageLocations.id })
-            .from(schema.storageLocations)
-            .where(
-              and(
-                eq(schema.storageLocations.householdId, householdId),
-                eq(schema.storageLocations.type, input.mealBoxFrozen ? "freezer" : "fridge"),
-              ),
-            )
-            .limit(1)
-        )[0]?.id;
-      if (!locationId) throw errors.badRequest("Ingen förvaringsplats för matlådor hittades.");
-
-      const useByDays = input.mealBoxFrozen ? 90 : 3;
-      const recommendedUseBy = new Date(Date.now() + useByDays * 86_400_000)
-        .toISOString()
-        .slice(0, 10);
-      const [box] = await app.db
-        .insert(schema.mealBoxes)
-        .values({
-          householdId,
-          recipeId: id,
-          titleSv: recipe.titleSv,
-          portions: input.mealBoxPortions,
-          portionsRemaining: input.mealBoxPortions,
-          nutritionPerPortion: recipe.nutritionPerPortion,
-          cookedAt: date,
-          storageLocationId: locationId,
-          frozen: input.mealBoxFrozen,
-          recommendedUseBy,
-        })
-        .returning();
-      mealBoxId = box!.id;
-      await emitEvent(app.db, {
-        type: "MEAL_BOX_CREATED",
-        payload: { mealBoxId: box!.id, portions: input.mealBoxPortions },
-        userId: req.userId,
-        householdId,
-        correlationId: req.correlationId,
-      });
-    }
-
-    // 4. Statistik + event
-    await app.db.insert(schema.recipeCooks).values({
-      recipeId: id,
-      userId: req.userId,
-      householdId,
-      portionsCooked: input.portionsCooked,
-    });
-    await app.db
-      .update(schema.recipes)
-      .set({ cookCount: sql`${schema.recipes.cookCount} + 1` })
-      .where(eq(schema.recipes.id, id));
-    await emitEvent(app.db, {
-      type: "RECIPE_COOKED",
-      payload: {
+    // Bakåtkompatibel shortcut: skapa session + complete direkt.
+    const [session] = await app.db
+      .insert(schema.cookingSessions)
+      .values({
        recipeId: id,
-        portions: input.portionsCooked,
-        mealBoxPortions: input.mealBoxPortions,
-      },
-      userId: req.userId,
-      householdId,
-      correlationId: req.correlationId,
-    });
+        householdId,
+        startedByUserId: req.userId,
+        status: "started",
+        plannedPortions: input.portionsCooked,
+        plannedMealType: input.mealType,
+        startedAt: new Date(),
+      })
+      .returning();

-    await markMilestone(app.db, householdId, "firstCookingSessionCompletedAt");
-    if (input.deductInventory && deductions.length > 0) {
-      await markMilestone(app.db, householdId, "inventoryUpdatedAfterCookingAt");
-    }
+    const result = await completeCookingSessionCore(app, session!, req.userId, input, req.correlationId);

-    return { ok: true, mealIds, mealBoxId, inventoryDeductions: deductions };
+    return { sessionId: session!.id, ...result };
  });

  /** Substitutionsförslag för en ingrediens (spec §20). */
@@ -997,7 +820,7 @@ export async function recipeRoutes(app: FastifyInstance) {
  });
 }

-async function loadFullRecipe(app: FastifyInstance, id: string) {
+export async function loadFullRecipe(app: FastifyInstance, id: string) {
  const [recipe] = await app.db
    .select()
    .from(schema.recipes)