@flowselections/floriday-verkoop-module 1.0.54 → 1.0.56

package/dist-lib/lib/cart-replan.functions.js

@@ -6,6 +6,7 @@
 import { createServerFn } from "@tanstack/react-start";
 import { z } from "zod";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { resolveOrderRow } from "./order-row.server";
 import { CART_PLANNER_VERSION, planCarts, } from "./cart-planner";
 import { resolveBufferForOrderInternal } from "./order-buffers.functions";
 export async function replanBufferInternal(bufferId) {
@@ -159,18 +160,14 @@ export async function replanScopeInternal(scope) {
     for (const it of items ?? []) {
         itemToOrder.set(it.id, it.order_id);
     }
-    // Bestaande karren in de scope tellen (voor waarschuwing) en wissen.
     // Nummering én delete-scope liggen altijd op bufferniveau als de order een
-    // buffer heeft; order-scope is uitsluitend terugval.
+    // buffer heeft; order-scope is uitsluitend terugval. Wissen én wegschrijven
+    // gebeuren verderop in ÉÉN transactie via public.replace_order_carts, zodat
+    // een mislukte replan de bestaande indeling laat staan.
     if (!bufferId) {
         console.warn("[cart-replan] geen buffer voor order %s — nummering en delete vallen terug op order-scope", soloOrderId);
     }
-    const cartScope = (q) => bufferId ? q.eq("buffer_id", bufferId) : q.eq("order_id", soloOrderId);
-    const { data: existingCarts } = await cartScope(supabaseAdmin.from("order_carts").select("id, source"));
-    const replacedManualCount = (existingCarts ?? []).filter((c) => c.source === "manual").length;
-    const { error: delErr } = await cartScope(supabaseAdmin.from("order_carts").delete());
-    if (delErr)
-        throw new Error(delErr.message);
+    let replacedManualCount = 0;
     // De karindeling wordt hier altijd zelf gerekend. custom_fields.floriday_packing
     // levert alleen de belading-VELDEN (pieces_per_package / packages_per_layer /
     // layers_per_load_carrier) — de mirror schrijft nooit een voorgekauwde
@@ -277,8 +274,10 @@ export async function replanScopeInternal(scope) {
             }
         }
     }
-    let cartsCreated = 0;
-    for (const { cart, profile } of plannedCarts) {
+    // Payload voor public.replace_order_carts. LET OP: de sleutels hieronder
+    // moeten gelijk lopen met de sleutellijsten in die SQL-functie; ontbreekt er
+    // één, dan gooit de database een fout in plaats van stil NULL te schrijven.
+    const cartPayload = plannedCarts.map(({ cart, profile }) => {
         // Bepaal cart.order_id: null bij mix van orders, anders die ene order.
         const orderIdsOnCart = new Set();
         for (const i of cart.items) {
@@ -287,9 +286,7 @@ export async function replanScopeInternal(scope) {
                 orderIdsOnCart.add(oid);
         }
         const singleOrderId = orderIdsOnCart.size === 1 ? [...orderIdsOnCart][0] : null;
-        const { data: inserted, error: cErr } = await supabaseAdmin
-            .from("order_carts")
-            .insert({
+        return {
             order_id: singleOrderId,
             buffer_id: bufferId,
             cart_number: cart.cart_number,
@@ -303,14 +300,7 @@ export async function replanScopeInternal(scope) {
             carrier_type_id: profile.id,
             max_layers: profile.layers_per_carrier ?? null,
             algorithm_version: CART_PLANNER_VERSION,
-        })
-            .select("id")
-            .single();
-        if (cErr)
-            throw new Error(cErr.message);
-        if (cart.items.length > 0) {
-            const rows = cart.items.map((i) => ({
-                cart_id: inserted.id,
+            items: cart.items.map((i) => ({
                 order_item_id: i.order_item_id,
                 product_id: i.product_id,
                 product_name: i.product_name,
@@ -320,14 +310,28 @@ export async function replanScopeInternal(scope) {
                 layers_per_cart: i.layers_per_cart,
                 layer_fraction: i.layer_fraction,
                 layer_share_pct: i.layer_share_pct,
-            }));
-            const { error: iErr } = await supabaseAdmin
-                .from("order_cart_items")
-                .insert(rows);
-            if (iErr)
-                throw new Error(iErr.message);
-        }
-        cartsCreated++;
+            })),
+        };
+    });
+    // Delete + inserts in één transactie: faalt er iets, dan blijft de oude
+    // karindeling staan in plaats van een lege buffer achter te laten.
+    const { data: replaceRes, error: replaceErr } = await supabaseAdmin.rpc("replace_order_carts", {
+        p_buffer_id: bufferId,
+        p_order_id: bufferId ? null : soloOrderId,
+        p_carts: cartPayload,
+    });
+    if (replaceErr)
+        throw new Error(replaceErr.message);
+    const cartsCreated = Number(replaceRes?.carts_written ?? 0);
+    const itemsWritten = Number(replaceRes?.items_written ?? 0);
+    replacedManualCount = Number(replaceRes?.replaced_manual_count ?? 0);
+    // Controleer dat de database daadwerkelijk heeft weggeschreven wat de
+    // planner opleverde. Nul karren mag, maar alleen als de planner er ook nul
+    // opleverde — niet als gevolg van een fout.
+    const expectedItems = cartPayload.reduce((n, c) => n + c.items.length, 0);
+    if (cartsCreated !== cartPayload.length || itemsWritten !== expectedItems) {
+        throw new Error(`Karindeling niet volledig weggeschreven: ${cartsCreated}/${cartPayload.length} karren, ` +
+            `${itemsWritten}/${expectedItems} artikelen.`);
     }
     return {
         ok: true,
@@ -360,8 +364,12 @@ export async function replanOrderCartsFromCron(orderId) {
 }
 export const replanOrderCarts = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
-    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
-    .handler(async ({ data }) => replanOrderInternal(data.orderId));
+    .inputValidator((input) => z.object({ orderId: z.string().min(1) }).parse(input))
+    .handler(async ({ data, context }) => {
+    // DTO-id kan een Floriday salesOrderId zijn.
+    const order = await resolveOrderRow(context.supabase, data.orderId);
+    return replanOrderInternal(order.id);
+});
 // ─── Queue drain (aangeroepen door pg_cron elke minuut) ─────────────────────
 export async function drainCartReplanQueue(limit = 50) {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
@@ -406,65 +414,79 @@ export async function drainCartReplanQueue(limit = 50) {
 // logistics_plan_queue). De UI berekent NIETS zelf: hij toont wat er staat.
 export const listOrderCarts = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
-    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .inputValidator((input) => z.object({ orderId: z.string().min(1) }).parse(input))
     .handler(async ({ data, context }) => {
-    const { data: order } = await context.supabase
+    // Elke query faalt HARD. "Geen karren" en "kon niet laden" zijn twee
+    // verschillende dingen; stilzwijgend een lege array teruggeven verbergt
+    // fouten (RLS, kolomnaam, embed) als "nog geen karindeling".
+    const fail = (what, error) => {
+        throw new Error(`Karindeling laden mislukt (${what}): ${error?.message ?? "onbekende fout"}`);
+    };
+    // De DTO-id is voor Floriday-orders het salesOrderId, niet orders.id.
+    // resolveOrderRow doet de twee-staps-lookup + botsingswaarschuwing.
+    const orderRow = await resolveOrderRow(context.supabase, data.orderId);
+    const dbOrderId = orderRow.id;
+    const bufferId = orderRow.buffer_id;
+    const lockRes = await context.supabase
         .from("orders")
-        .select("buffer_id, plan_locked_at")
-        .eq("id", data.orderId)
+        .select("plan_locked_at")
+        .eq("id", dbOrderId)
         .maybeSingle();
-    const bufferId = order?.buffer_id;
-    const planLockedAt = order?.plan_locked_at ?? null;
+    if (lockRes.error)
+        fail("plan-lock lezen", lockRes.error);
+    const planLockedAt = lockRes.data?.plan_locked_at ?? null;
     const select = "id, order_id, buffer_id, cart_number, source, is_complete, occupancy_pct, total_layers_used, algorithm_version, carrier_type, max_layers, notes, order_cart_items(id, order_item_id, product_id, product_name, crates, plants_per_crate, crates_per_layer, layers_per_cart, layer_fraction, layer_share_pct)";
     const base = context.supabase.from("order_carts").select(select);
-    const { data: carts } = await (bufferId
+    const cartsRes = await (bufferId
         ? base.eq("buffer_id", bufferId)
-        : base.eq("order_id", data.orderId)).order("cart_number");
+        : base.eq("order_id", dbOrderId)).order("cart_number");
+    if (cartsRes.error)
+        fail("karren lezen", cartsRes.error);
+    const carts = (cartsRes.data ?? []);
     // Orders in de scope + ordernummer per orderregel (voor de badges).
     let orders = [];
     if (bufferId) {
-        const { data: sibs } = await context.supabase
+        const sibs = await context.supabase
             .from("orders")
             .select("id, order_number")
             .eq("buffer_id", bufferId)
             .is("deleted_at", null);
-        orders = (sibs ?? []).map((o) => ({
+        if (sibs.error)
+            fail("orders in buffer lezen", sibs.error);
+        orders = (sibs.data ?? []).map((o) => ({
             id: o.id,
             order_number: o.order_number ?? null,
         }));
     }
     if (orders.length === 0) {
-        const { data: own } = await context.supabase
-            .from("orders")
-            .select("id, order_number")
-            .eq("id", data.orderId)
-            .maybeSingle();
-        if (own) {
-            orders = [{ id: own.id, order_number: own.order_number ?? null }];
-        }
+        orders = [{ id: dbOrderId, order_number: orderRow.order_number ?? null }];
     }
     const orderIds = orders.map((o) => o.id);
     let itemOrders = [];
     if (orderIds.length > 0) {
-        const { data: its } = await context.supabase
+        const its = await context.supabase
             .from("order_items")
             .select("id, order_id")
             .in("order_id", orderIds);
-        itemOrders = (its ?? []).map((i) => ({
+        if (its.error)
+            fail("orderregels lezen", its.error);
+        itemOrders = (its.data ?? []).map((i) => ({
             id: i.id,
             order_id: i.order_id,
         }));
     }
     // Blokkadereden alleen ophalen als er niets gepland staat.
     let blocked = null;
-    if ((carts ?? []).length === 0 && orderIds.length > 0) {
-        const { data: dec } = await context.supabase
+    if (carts.length === 0 && orderIds.length > 0) {
+        const dec = await context.supabase
             .from("logistics_decisions")
             .select("subject_id, slot, explanation, result, created_at")
             .in("subject_id", orderIds)
             .order("created_at", { ascending: false })
             .limit(1);
-        const d = (dec ?? [])[0];
+        if (dec.error)
+            fail("blokkadereden lezen", dec.error);
+        const d = (dec.data ?? [])[0];
         if (d) {
             blocked = {
                 reason: d.result?.reason ?? d.slot ?? null,
@@ -473,28 +495,36 @@ export const listOrderCarts = createServerFn({ method: "GET" })
             };
         }
         if (!blocked) {
-            const { data: q } = await context.supabase
+            const q = await context.supabase
                 .from("logistics_plan_queue")
                 .select("order_id, status, reason, error, updated_at")
                 .in("order_id", orderIds)
                 .order("updated_at", { ascending: false })
                 .limit(1);
-            const r = (q ?? [])[0];
+            if (q.error)
+                fail("planqueue lezen", q.error);
+            const r = (q.data ?? [])[0];
             if (r && (r.error || r.reason)) {
+                // `reason` in logistics_plan_queue is vaak een sleutel/veldnaam
+                // ("items"), geen leesbare reden. De echte fout staat in `error`.
+                const err = r.error ?? null;
+                const rawReason = r.reason ?? null;
                 blocked = {
-                    reason: r.reason ?? null,
-                    explanation: r.error ?? null,
+                    reason: rawReason,
+                    explanation: err ?? (rawReason ? `Planning geblokkeerd (${rawReason})` : null),
                     at: r.updated_at ?? null,
                 };
             }
         }
     }
-    return { carts: carts ?? [], bufferId, planLockedAt, orders, itemOrders, blocked };
+    return { carts, bufferId, orderId: dbOrderId, planLockedAt, orders, itemOrders, blocked };
 });
 export const replanBufferForOrder = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
-    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
-    .handler(async ({ data }) => {
-    const bufferId = await resolveBufferForOrderInternal(data.orderId);
-    return replanScopeInternal({ bufferId, orderId: data.orderId });
+    .inputValidator((input) => z.object({ orderId: z.string().min(1) }).parse(input))
+    .handler(async ({ data, context }) => {
+    // DTO-id kan een Floriday salesOrderId zijn.
+    const order = await resolveOrderRow(context.supabase, data.orderId);
+    const bufferId = await resolveBufferForOrderInternal(order.id);
+    return replanScopeInternal({ bufferId, orderId: order.id });
 });