Fas 2 steg 5: Scan-to-scan-diff + konfliktlösning, samt buggfix depleted-transaktion i reconciliation

2026-08-07 01:30:31 +07:00
parent 218bc44d08
commit 4a4f448e1c
26 changed files with 10590 additions and 13 deletions
@@ -4,6 +4,7 @@ import { eq, inArray } from "drizzle-orm";
 import { buildServer } from "../src/server.js";
 import { loadConfig } from "../src/config.js";
 import { createDatabase, closeDatabase, schema } from "@app/database";
+import { computeBalance } from "@app/inventory-engine";

 describe("quick reconciliation", () => {
  const testDb = createDatabase(process.env.TEST_DATABASE_URL!);
@@ -123,4 +124,56 @@ describe("quick reconciliation", () => {
    expect(body.quantity).toBe(0.5);
    expect(body.verifiedByUser).toBe(true);
  });
+
+  it("transaction invariant holds for exists/depleted/uncertain", async () => {
+    const start = await app.inject({
+      method: "POST",
+      url: "/v1/reconciliations/start",
+      headers: { authorization: `Bearer ${token}` },
+      payload: {},
+    });
+    const { candidates } = JSON.parse(start.body) as { candidates: Array<{ itemId: string }> };
+    const itemId = candidates[0]!.itemId;
+
+    async function assertBalanceMatches(itemId: string) {
+      const [item] = await testDb.db
+        .select({ quantity: schema.inventoryItems.quantity })
+        .from(schema.inventoryItems)
+        .where(eq(schema.inventoryItems.id, itemId))
+        .limit(1);
+      const txs = await testDb.db
+        .select({ type: schema.inventoryTransactions.type, quantityDelta: schema.inventoryTransactions.quantityDelta, unit: schema.inventoryTransactions.unit })
+        .from(schema.inventoryTransactions)
+        .where(eq(schema.inventoryTransactions.inventoryItemId, itemId));
+      const balance = computeBalance(txs.map((tx) => ({ type: tx.type, quantityDelta: tx.quantityDelta, unit: tx.unit })));
+      expect(balance.balance).toBeCloseTo(item!.quantity, 5);
+    }
+
+    // exists med justering
+    await app.inject({
+      method: "POST",
+      url: `/v1/reconciliations/items/${itemId}/resolve`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: { action: "exists", quantity: 0.7 },
+    });
+    await assertBalanceMatches(itemId);
+
+    // depleted ska alltid skriva transaktion
+    await app.inject({
+      method: "POST",
+      url: `/v1/reconciliations/items/${itemId}/resolve`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: { action: "depleted" },
+    });
+    await assertBalanceMatches(itemId);
+
+    // uncertain med justering
+    await app.inject({
+      method: "POST",
+      url: `/v1/reconciliations/items/${itemId}/resolve`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: { action: "uncertain", quantity: 0.2 },
+    });
+    await assertBalanceMatches(itemId);
+  });
 });
@@ -0,0 +1,192 @@
+import "./setup-env.js";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+import { eq, inArray } from "drizzle-orm";
+import { buildServer } from "../src/server.js";
+import { loadConfig } from "../src/config.js";
+import { createDatabase, closeDatabase, schema } from "@app/database";
+
+describe("scan-to-scan-diff", () => {
+  const testDb = createDatabase(process.env.TEST_DATABASE_URL!);
+  const config = loadConfig();
+  let app: Awaited<ReturnType<typeof buildServer>>;
+  let token: string;
+  let householdId: string;
+  let scanJobId: string;
+  const email = "scan-diff-test@example.invalid";
+
+  async function cleanup() {
+    const existing = await testDb.db
+      .select({ id: schema.users.id })
+      .from(schema.users)
+      .where(inArray(schema.users.email, [email]));
+    for (const u of existing) {
+      await testDb.db.delete(schema.idempotencyKeys).where(eq(schema.idempotencyKeys.userId, u.id));
+      const memberships = await testDb.db
+        .select({ householdId: schema.householdMembers.householdId })
+        .from(schema.householdMembers)
+        .where(eq(schema.householdMembers.userId, u.id));
+      for (const m of memberships) {
+        const items = await testDb.db
+          .select({ id: schema.inventoryItems.id })
+          .from(schema.inventoryItems)
+          .where(eq(schema.inventoryItems.householdId, m.householdId));
+        for (const it of items) {
+          await testDb.db.delete(schema.inventoryTransactions).where(eq(schema.inventoryTransactions.inventoryItemId, it.id));
+          await testDb.db.delete(schema.inventoryConflicts).where(eq(schema.inventoryConflicts.inventoryItemId, it.id));
+        }
+        await testDb.db.delete(schema.inventoryItems).where(eq(schema.inventoryItems.householdId, m.householdId));
+        await testDb.db.delete(schema.inventoryConflicts).where(eq(schema.inventoryConflicts.householdId, m.householdId));
+        await testDb.db.delete(schema.storageLocations).where(eq(schema.storageLocations.householdId, m.householdId));
+        await testDb.db.delete(schema.householdMembers).where(eq(schema.householdMembers.householdId, m.householdId));
+        await testDb.db.delete(schema.households).where(eq(schema.households.id, m.householdId));
+      }
+      await testDb.db.delete(schema.scanJobs).where(eq(schema.scanJobs.userId, u.id));
+      await testDb.db.delete(schema.userPreferences).where(eq(schema.userPreferences.userId, u.id));
+      await testDb.db.delete(schema.users).where(eq(schema.users.id, u.id));
+    }
+  }
+
+  beforeAll(async () => {
+    await cleanup();
+    app = await buildServer(config);
+    await app.ready();
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/auth/register",
+      payload: { email, password: "Password123!", displayName: "Scan Diff Test" },
+    });
+    const body = JSON.parse(res.body) as { accessToken: string };
+    token = body.accessToken;
+
+    const quick = await app.inject({
+      method: "POST",
+      url: "/v1/onboarding/quick-start",
+      headers: { authorization: `Bearer ${token}` },
+      payload: { goals: ["less_waste"], precisionMode: "simple" },
+    });
+    householdId = (JSON.parse(quick.body) as { householdId: string }).householdId;
+
+    const [location] = await testDb.db
+      .select({ id: schema.storageLocations.id })
+      .from(schema.storageLocations)
+      .where(eq(schema.storageLocations.householdId, householdId))
+      .limit(1);
+
+    // Skapa två varor att diffa mot
+    await app.inject({
+      method: "POST",
+      url: "/v1/inventory/items",
+      headers: { authorization: `Bearer ${token}` },
+      payload: {
+        displayName: "Mjölk",
+        quantity: 1,
+        unit: "LITER",
+        storageLocationId: location!.id,
+      },
+    });
+    await app.inject({
+      method: "POST",
+      url: "/v1/inventory/items",
+      headers: { authorization: `Bearer ${token}` },
+      payload: {
+        displayName: "Yoghurt",
+        quantity: 2,
+        unit: "COUNT",
+        storageLocationId: location!.id,
+      },
+    });
+
+    // Skapa ett färdigt scan-jobb med resultat
+    const [job] = await testDb.db
+      .insert(schema.scanJobs)
+      .values({
+        userId: (JSON.parse(atob(token.split(".")[1]!)) as { sub: string }).sub,
+        householdId,
+        scanType: "fridge",
+        jobType: "ANALYZE_FRIDGE_IMAGE",
+        status: "completed",
+        result: [
+          { displayName: "Mjölk", quantity: 0.5, unit: "LITER", storageLocationId: location!.id, confidence: 0.9 },
+          { displayName: "Ost", quantity: 1, unit: "COUNT", storageLocationId: location!.id, confidence: 0.9 },
+        ],
+        modelVersion: "v1",
+        promptVersion: "p1",
+      })
+      .returning();
+    scanJobId = job!.id;
+  });
+
+  afterAll(async () => {
+    await cleanup();
+    await closeDatabase();
+    await app.close();
+  });
+
+  it("returns diff rows with model/prompt versions", async () => {
+    const res = await app.inject({
+      method: "POST",
+      url: `/v1/scans/${scanJobId}/diff`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: {},
+    });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body) as {
+      rows: Array<{ kind: string; displayName: string }>;
+      modelVersion: string;
+      promptVersion: string;
+    };
+    expect(body.modelVersion).toBe("v1");
+    expect(body.promptVersion).toBe("p1");
+    const kinds = body.rows.map((r) => r.kind);
+    expect(kinds).toContain("quantity_changed");
+    expect(kinds).toContain("new_item");
+    expect(kinds).toContain("vanished");
+  });
+
+  it("applies accepted diff rows idempotently", async () => {
+    const diff = await app.inject({
+      method: "POST",
+      url: `/v1/scans/${scanJobId}/diff`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: {},
+    });
+    const { rows } = JSON.parse(diff.body) as { rows: Array<{ kind: string; itemId?: string; previousItemId?: string; displayName: string; newQuantity?: number; newLocationId?: string; confidence: number }> };
+    const changed = rows.find((r) => r.kind === "quantity_changed")!;
+
+    const apply = await app.inject({
+      method: "POST",
+      url: `/v1/scans/${scanJobId}/diff/apply`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: {
+        idempotencyKey: "diff-apply-1",
+        rows: [
+          {
+            kind: "quantity_changed",
+            previousItemId: changed.previousItemId,
+            displayName: changed.displayName,
+            unit: "LITER",
+            newQuantity: changed.newQuantity,
+            confidence: changed.confidence,
+          },
+        ],
+      },
+    });
+    expect(apply.statusCode).toBe(200);
+    const applied = JSON.parse(apply.body) as { appliedItemIds: string[] };
+    expect(applied.appliedItemIds.length).toBeGreaterThan(0);
+
+    // Idempotency: samma nyckel ska ge samma svar
+    const apply2 = await app.inject({
+      method: "POST",
+      url: `/v1/scans/${scanJobId}/diff/apply`,
+      headers: { authorization: `Bearer ${token}` },
+      payload: {
+        idempotencyKey: "diff-apply-1",
+        rows: [],
+      },
+    });
+    expect(apply2.statusCode).toBe(200);
+    expect(JSON.parse(apply2.body)).toEqual(applied);
+  });
+});