@flowselections/mailbox-orders 1.0.9 → 1.0.10

package/dist-lib/lib/mailbox.functions.js

@@ -3,6 +3,9 @@ import { createServerFn } from "@tanstack/react-start";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
 import { createClient } from "@supabase/supabase-js";
 import { z } from "zod";
+import { computeEarliestDelivery } from "../lib/delivery-date";
+import { emailBodyText } from "./mailbox-body";
+import { EMPTY_LOAD_CARRIERS, isLoadCarrierAllowed, loadCarrierLabel, normalizeAllowedLoadCarriers, } from "./load-carriers";
 // ─── Actieve mailbox (uit gedeelde e-mail-auth module) ──────────────────────
 // Geen auth-middleware: de RPC is SECURITY DEFINER en EXECUTE staat ook aan
 // `anon`. Zo blijft de status-banner werken als de bearer-token tijdelijk
@@ -37,242 +40,80 @@ export const getActiveOrdersMailbox = createServerFn({ method: "GET" })
         needs_reauth: !!row.needs_reauth,
     };
 });
-// ─── Event ingest helpers ────────────────────────────────────────────────────
-function pickStr(obj, ...keys) {
-    for (const k of keys) {
-        const v = k.split(".").reduce((a, p) => (a == null ? a : a[p]), obj);
-        if (typeof v === "string" && v.length > 0)
-            return v;
-    }
-    return null;
-}
-async function ingestSingleEvent(supabaseAdmin, connectionId, ev) {
-    const p = ev.payload ?? {};
-    const externalId = ev.external_id ?? pickStr(p, "message_id", "messageId", "id") ?? ev.id;
-    // Skip als deze external_id al bestaat
-    if (externalId) {
-        const { data: existing } = await supabaseAdmin
-            .from("mailbox_messages")
-            .select("id")
-            .eq("external_id", externalId)
-            .maybeSingle();
-        if (existing?.id) {
-            return { inserted: false, messageId: existing.id };
+// ─── Ingest-triggers ────────────────────────────────────────────────────────
+// De volledige ingest-pipeline (events → messages → stub-proposals) leeft in
+// `src/lib/mailbox-ingest.server.ts`. Onderstaande server-fns zijn dunne
+// wrappers zodat de client dezelfde pipeline kan afvuren als pg_cron.
+// Bewust ZONDER `requireSupabaseAuth`-middleware: die gooit een raw `Response`
+// (401/500) die in de browser als onleesbare "[object Response]"-runtimefout met
+// blanco scherm eindigt. We verifiëren de bearer-token hier zelf en geven altijd
+// nette JSON terug, zodat de UI de fout gewoon kan tonen.
+export const syncMailboxNow = createServerFn({ method: "POST" })
+    .inputValidator((input) => z.object({ trigger: z.enum(["manual", "realtime"]).default("manual") }).parse(input ?? {}))
+    .handler(async ({ data }) => {
+    try {
+        const { getRequest } = await import("@tanstack/react-start/server");
+        const token = getRequest()?.headers?.get("authorization")?.replace(/^Bearer\s+/i, "") ?? "";
+        const url = process.env.SUPABASE_URL;
+        const key = process.env.SUPABASE_PUBLISHABLE_KEY;
+        if (!token || !url || !key) {
+            return { ok: false, error: "unauthorized", processed: 0, inserted: 0, errors: 1 };
         }
-    }
-    const fromEmail = pickStr(p, "from_email", "fromEmail", "from.address", "from.email", "sender.address") ?? "";
-    const fromName = pickStr(p, "from_name", "fromName", "from.name", "sender.name");
-    const subject = pickStr(p, "subject", "title") ?? "";
-    const bodyText = pickStr(p, "body_text", "bodyText", "text", "body.text", "snippet");
-    const bodyHtml = pickStr(p, "body_html", "bodyHtml", "html", "body.html");
-    const receivedAt = pickStr(p, "received_at", "receivedAt", "date", "internalDate") ?? ev.received_at ?? new Date().toISOString();
-    const { data: inserted, error: insErr } = await supabaseAdmin
-        .from("mailbox_messages")
-        .insert({
-        external_id: externalId,
-        message_id: pickStr(p, "message_id", "messageId") ?? externalId,
-        connection_id: connectionId,
-        from_email: fromEmail,
-        from_name: fromName,
-        subject,
-        body_text: bodyText,
-        body_html: bodyHtml,
-        received_at: receivedAt,
-        status: "new",
-    })
-        .select("id")
-        .single();
-    if (insErr) {
-        // Duplicate race → markeer alsnog als consumed
-        if (insErr.code === "23505") {
-            return { inserted: false, messageId: null };
+        const sb = createClient(url, key, {
+            auth: { storage: undefined, persistSession: false, autoRefreshToken: false },
+        });
+        const { data: userData, error: userErr } = await sb.auth.getUser(token);
+        if (userErr || !userData?.user) {
+            return { ok: false, error: "unauthorized", processed: 0, inserted: 0, errors: 1 };
         }
-        throw new Error(insErr.message);
-    }
-    // Maak direct een leeg voorstel aan (AI staat uit) — match klant op afzender
-    await createStubProposal(supabaseAdmin, inserted.id, fromEmail);
-    return { inserted: true, messageId: inserted.id };
-}
-async function createStubProposal(supabaseAdmin, messageId, fromEmail) {
-    const { data: existing } = await supabaseAdmin
-        .from("mailbox_order_proposals").select("id").eq("message_id", messageId).maybeSingle();
-    if (existing?.id)
-        return;
-    const matchResult = await matchCustomerByEmail(supabaseAdmin, fromEmail);
-    await supabaseAdmin.from("mailbox_order_proposals").insert({
-        message_id: messageId,
-        matched_customer_id: matchResult.customerId,
-        confidence: matchResult.customerId ? 1 : 0,
-        status: "pending",
-        parsed_payload: {
-            stub: true,
-            reason: "ai_disabled",
-            auto_matched_customer: matchResult.customerId !== null,
-            auto_match_source: matchResult.source,
-            auto_match_email: fromEmail,
-            auto_match_warning: matchResult.warning,
-            auto_match_candidates: matchResult.candidates,
-        },
-    });
-}
-// Exact (case-insensitive) match op afzender-e-mailadres.
-// Eerst customers.email, dan customer_contacts.email als fallback.
-// Bij meerdere treffers: geen automatische koppeling, wel waarschuwing.
-async function matchCustomerByEmail(supabaseAdmin, fromEmail) {
-    if (!fromEmail) {
-        return { customerId: null, source: null, warning: null, candidates: [] };
-    }
-    const email = fromEmail.trim();
-    if (!email) {
-        return { customerId: null, source: null, warning: null, candidates: [] };
-    }
-    // 1) customers.email (case-insensitive exact)
-    const { data: directHits } = await supabaseAdmin
-        .from("customers")
-        .select("id, company_name")
-        .ilike("email", email)
-        .limit(5);
-    const direct = Array.isArray(directHits) ? directHits : [];
-    if (direct.length === 1) {
-        return {
-            customerId: direct[0].id,
-            source: "customers",
-            warning: null,
-            candidates: direct.map((c) => ({ id: c.id, name: c.company_name })),
-        };
-    }
-    if (direct.length > 1) {
-        return {
-            customerId: null,
-            source: "customers",
-            warning: `Meerdere klanten met e-mailadres ${email} — kies handmatig.`,
-            candidates: direct.map((c) => ({ id: c.id, name: c.company_name })),
-        };
-    }
-    // 2) customer_contacts.email (case-insensitive exact)
-    const { data: contactHits } = await supabaseAdmin
-        .from("customer_contacts")
-        .select("customer_id")
-        .ilike("email", email)
-        .limit(5);
-    const contacts = Array.isArray(contactHits) ? contactHits : [];
-    const uniqueCustomerIds = Array.from(new Set(contacts.map((c) => c.customer_id).filter(Boolean)));
-    if (uniqueCustomerIds.length === 0) {
-        return { customerId: null, source: null, warning: null, candidates: [] };
+        const { runIngest } = await import("../lib/mailbox-ingest.server");
+        return await runIngest(data.trigger);
     }
-    const { data: custRows } = await supabaseAdmin
-        .from("customers")
-        .select("id, company_name")
-        .in("id", uniqueCustomerIds);
-    const cands = (Array.isArray(custRows) ? custRows : []).map((c) => ({
-        id: c.id,
-        name: c.company_name,
-    }));
-    if (uniqueCustomerIds.length === 1) {
+    catch (e) {
         return {
-            customerId: uniqueCustomerIds[0],
-            source: "customer_contacts",
-            warning: null,
-            candidates: cands,
+            ok: false,
+            error: String(e?.message ?? e),
+            processed: 0,
+            inserted: 0,
+            errors: 1,
         };
     }
-    return {
-        customerId: null,
-        source: "customer_contacts",
-        warning: `Meerdere klanten gevonden via contactpersoon met e-mailadres ${email} — kies handmatig.`,
-        candidates: cands,
-    };
-}
-// ─── Ingest één specifiek event (vanuit realtime subscription) ───────────────
-export const ingestEmailEvent = createServerFn({ method: "POST" })
+});
+export const getLastIngestRun = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
-    .inputValidator((input) => z.object({ eventId: z.string().uuid() }).parse(input))
-    .handler(async ({ data }) => {
+    .handler(async () => {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
-    const { data: ev, error: evErr } = await supabaseAdmin
-        .from("email_auth_events")
-        .select("id, connection_id, external_id, payload, received_at, consumed_at")
-        .eq("id", data.eventId)
+    const { data } = await supabaseAdmin
+        .from("mailbox_ingest_runs")
+        .select("id, trigger, started_at, finished_at, processed, inserted, errors, error_sample")
+        .order("started_at", { ascending: false })
+        .limit(1)
         .maybeSingle();
-    if (evErr)
-        throw new Error(evErr.message);
-    if (!ev)
-        return { ok: false, error: "Event niet gevonden" };
-    if (ev.consumed_at)
-        return { ok: true, inserted: 0, autoProcessed: 0, autoApproved: 0 };
-    const res = await ingestSingleEvent(supabaseAdmin, ev.connection_id, ev);
-    await supabaseAdmin
-        .from("email_auth_events")
-        .update({ consumed_at: new Date().toISOString() })
-        .eq("id", ev.id);
-    // AI-verwerking uitgeschakeld — wacht op externe model-koppeling
-    const autoProcessed = 0;
-    const autoApproved = 0;
-    return { ok: true, inserted: res.inserted ? 1 : 0, autoProcessed, autoApproved };
+    return { run: data ?? null };
 });
-// ─── Backfill: haal alle nog niet-consumed events op voor 'orders/receive' ───
-export const backfillRecentEvents = createServerFn({ method: "POST" })
+/** Handmatig één voorstel opnieuw laten analyseren met de huidige AI-agent. */
+export const reparseProposalNow = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
-    .handler(async ({ context }) => {
+    .inputValidator((input) => z.object({ proposalId: z.string().uuid() }).parse(input))
+    .handler(async ({ data }) => {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
-    // Welke connection is gekoppeld aan orders/receive?
-    const { data: active, error: actErr } = await context.supabase.rpc("email_auth_for_purpose", {
-        _purpose: "orders",
-        _direction: "receive",
-    });
-    if (actErr)
-        return { ok: false, error: actErr.message };
-    const row = Array.isArray(active) ? active[0] : null;
-    if (!row?.id)
-        return { ok: false, error: "Geen actieve koppeling voor orders/receive" };
-    const { data: events, error: evErr } = await supabaseAdmin
-        .from("email_auth_events")
-        .select("id, connection_id, external_id, payload, received_at")
-        .eq("connection_id", row.id)
-        .is("consumed_at", null)
-        .order("received_at", { ascending: true })
-        .limit(200);
-    if (evErr)
-        return { ok: false, error: evErr.message };
-    let inserted = 0;
-    const consumedIds = [];
-    for (const ev of events ?? []) {
-        try {
-            const res = await ingestSingleEvent(supabaseAdmin, ev.connection_id, ev);
-            if (res.inserted)
-                inserted++;
-            consumedIds.push(ev.id);
-        }
-        catch {
-            // Fout → niet markeren als consumed, volgende ronde opnieuw proberen
-        }
-    }
-    if (consumedIds.length > 0) {
-        await supabaseAdmin
-            .from("email_auth_events")
-            .update({ consumed_at: new Date().toISOString() })
-            .in("id", consumedIds);
-    }
-    // Maak ook stubs voor eerder ontvangen berichten zonder voorstel
-    const { data: orphanMsgs } = await supabaseAdmin
-        .from("mailbox_messages")
-        .select("id, from_email, mailbox_order_proposals(id)")
-        .order("received_at", { ascending: false })
-        .limit(200);
-    let stubbed = 0;
-    for (const m of (orphanMsgs ?? [])) {
-        if (Array.isArray(m.mailbox_order_proposals) && m.mailbox_order_proposals.length > 0)
-            continue;
-        await createStubProposal(supabaseAdmin, m.id, m.from_email ?? null);
-        stubbed++;
-    }
-    return { ok: true, inserted: inserted + stubbed, autoProcessed: 0, autoApproved: 0 };
+    const { reparseProposal } = await import("../lib/mailbox-ingest.server");
+    return reparseProposal(supabaseAdmin, data.proposalId);
+});
+/** Detecteert een gewijzigde AI-agent en herverwerkt openstaande voorstellen. */
+export const refreshProposalsForAgentChange = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async () => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { reparseChangedAgentProposals } = await import("../lib/mailbox-ingest.server");
+    return reparseChangedAgentProposals(supabaseAdmin);
 });
 // ─── Messages & Proposals ────────────────────────────────────────────────────
 export const listMessages = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
-    .handler(async ({ context }) => {
-    const { data, error } = await context.supabase
+    .handler(async () => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { data, error } = await supabaseAdmin
         .from("mailbox_messages")
         .select("id, uid, from_email, from_name, subject, received_at, status, error_message, created_at")
         .order("received_at", { ascending: false })
@@ -286,6 +127,7 @@ export const parseMessage = createServerFn({ method: "POST" })
     .inputValidator((input) => z.object({ messageId: z.string().uuid() }).parse(input))
     .handler(async ({ data }) => {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { createStubProposal } = await import("../lib/mailbox-ingest.server");
     const { data: msg, error: msgErr } = await supabaseAdmin
         .from("mailbox_messages").select("*").eq("id", data.messageId).single();
     if (msgErr || !msg)
@@ -299,41 +141,41 @@ export const parseMessage = createServerFn({ method: "POST" })
 export const listProposals = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .inputValidator((input) => z.object({ status: z.enum(["pending", "approved", "rejected"]).optional() }).parse(input ?? {}))
-    .handler(async ({ data, context }) => {
-    // Beperk tot berichten die binnenkwamen via de actieve orders/receive mailbox
-    const { data: active } = await context.supabase.rpc("email_auth_for_purpose", {
-        _purpose: "orders",
-        _direction: "receive",
-    });
-    const activeRow = Array.isArray(active) ? active[0] : null;
-    const activeConnectionId = activeRow?.id ?? null;
-    if (!activeConnectionId)
-        return { items: [] };
-    // Stap 1: message-ids van de actieve mailbox
-    const { data: msgs, error: msgErr } = await context.supabase
-        .from("mailbox_messages")
-        .select("id")
-        .eq("connection_id", activeConnectionId)
-        .order("received_at", { ascending: false })
-        .limit(500);
-    if (msgErr)
-        throw new Error(msgErr.message);
-    const messageIds = (msgs ?? []).map((m) => m.id);
-    if (messageIds.length === 0)
-        return { items: [] };
-    // Stap 2: voorstellen op die berichten
-    let q = context.supabase
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Alle voorstellen uit de database, ongeacht via welke mailbox ze binnenkwamen.
+    // Bewust server-side: mailbox-voorstellen mogen niet rechtstreeks door andere
+    // browsermodules als verkooporders worden gelezen.
+    let q = supabaseAdmin
         .from("mailbox_order_proposals")
-        .select("*, mailbox_messages(subject, from_email, from_name, body_text, received_at, connection_id), mailbox_proposal_lines(*), mailbox_proposal_field_values(*)")
-        .in("message_id", messageIds)
+        .select("*, mailbox_messages(subject, from_email, from_name, body_text, body_html, received_at, connection_id), mailbox_proposal_lines(*), mailbox_proposal_field_values(*)")
         .order("created_at", { ascending: false })
-        .limit(100);
+        .limit(500);
     if (data.status)
         q = q.eq("status", data.status);
     const { data: rows, error } = await q;
     if (error)
         throw new Error(error.message);
-    return { items: rows ?? [] };
+    const items = (Array.isArray(rows) ? rows : []).map((r) => {
+        const m = r?.mailbox_messages;
+        if (!m)
+            return r;
+        const { body_html, ...rest } = m;
+        return { ...r, mailbox_messages: { ...rest, body_text: emailBodyText(m.body_text, body_html) } };
+    });
+    return { items };
+});
+// ─── Ladingdragers uit de Logistics Engine ─────────────────────────────────
+// Nooit cachen: de instelling kan op elk moment wijzigen.
+export const listAllowedLoadCarriers = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data, error } = await context.supabase.rpc("logistics_allowed_load_carriers", {
+        p_strategy_id: undefined,
+    });
+    if (error)
+        return { ...EMPTY_LOAD_CARRIERS, error: error.message };
+    return { ...normalizeAllowedLoadCarriers(data), error: null };
 });
 const LineEdit = z.object({
     id: z.string().uuid().optional(),
@@ -363,12 +205,29 @@ export const approveProposal = createServerFn({ method: "POST" })
     (data.fieldValues ?? []).forEach((fv) => {
         customFields[fv.field_key] = fv.value;
     });
+    // ─── Ladingdrager: uitsluitend wat de Engine toestaat ───────────────────
+    const { data: lcRaw, error: lcErr } = await context.supabase.rpc("logistics_allowed_load_carriers", { p_strategy_id: undefined });
+    if (lcErr)
+        throw new Error(`Ladingdragers ophalen mislukt: ${lcErr.message}`);
+    const lcList = normalizeAllowedLoadCarriers(lcRaw);
+    const requestedCarrier = typeof customFields["load_carrier"] === "string" && customFields["load_carrier"]
+        ? customFields["load_carrier"]
+        : null;
+    const loadCarrierType = requestedCarrier ?? lcList.default;
+    if (!isLoadCarrierAllowed(lcList, loadCarrierType)) {
+        throw new Error(`Ladingdrager "${loadCarrierLabel(lcList, loadCarrierType) ?? "onbekend"}" is uitgeschakeld in de Rule Engine — bestelling niet aangemaakt.`);
+    }
+    customFields["load_carrier"] = loadCarrierType;
     // ─── Validatie eerst mogelijke leverdatum ────────────────────────────────
     const carrierId = typeof customFields["carrier"] === "string" ? customFields["carrier"] : null;
     let carrierDeliveryDays = 0;
+    let carrierSchedule = null;
     if (carrierId) {
         const { data: c } = await context.supabase
-            .from("carriers").select("delivery_days").eq("id", carrierId).maybeSingle();
+            .from("carriers")
+            .select("delivery_days, pickup_weekdays, delivery_weekdays, pickup_moments")
+            .eq("id", carrierId).maybeSingle();
+        carrierSchedule = c ?? null;
         carrierDeliveryDays = Math.max(0, Number(c?.delivery_days ?? 0));
     }
     const { data: settings } = await context.supabase
@@ -377,10 +236,45 @@ export const approveProposal = createServerFn({ method: "POST" })
         .order("updated_at", { ascending: false })
         .limit(1).maybeSingle();
     const pickDays = Math.max(0, Number(settings?.pick_days_before_transport ?? 0));
-    const earliest = addCalendarDays(new Date(), pickDays + carrierDeliveryDays);
-    const earliestISO = toISODate(earliest);
+    const earliestISO = computeEarliestDelivery(carrierSchedule, pickDays).iso;
     if (data.deliveryDate < earliestISO) {
-        throw new Error(`Leverdatum (${data.deliveryDate}) ligt voor de eerst mogelijke datum (${earliestISO}) o.b.v. orderpicktijd (${pickDays}d) + levertijd vervoerder (${carrierDeliveryDays}d).`);
+        throw new Error(`Leverdatum (${data.deliveryDate}) ligt voor het eerstvolgende aanmeldmoment van de vervoerder (${earliestISO}).`);
+    }
+    // ─── Voorraadcontrole door de Logistics Engine (nooit zelf beslissen) ────
+    const checkLines = data.lines
+        .filter((l) => l.product_id)
+        .map((l) => ({
+        productId: l.product_id,
+        quantity: Math.max(1, Math.round(l.quantity ?? 1)),
+        loadCarrierType,
+    }));
+    let shortages = [];
+    if (checkLines.length > 0) {
+        const { data: check, error: checkErr } = await context.supabase.rpc("logistics_check_order_allowed", { p_lines: checkLines });
+        if (checkErr)
+            throw new Error(`Voorraadcontrole mislukt: ${checkErr.message}`);
+        const result = (check ?? {});
+        shortages = Array.isArray(result.shortages) ? result.shortages : [];
+        if (result.allowed === false) {
+            const detail = shortages
+                .map((s) => `${s.product ?? s.productId}: besteld ${s.wanted}, beschikbaar ${s.available}, tekort ${s.missing}`)
+                .join("\n");
+            const blockText = `Geblokkeerd - onvoldoende voorraad\n${detail}`;
+            await supabaseAdmin
+                .from("mailbox_order_proposals")
+                .update({ notes: blockText })
+                .eq("id", data.proposalId);
+            const { data: blockedProp } = await supabaseAdmin
+                .from("mailbox_order_proposals")
+                .select("message_id").eq("id", data.proposalId).maybeSingle();
+            if (blockedProp?.message_id) {
+                await supabaseAdmin
+                    .from("mailbox_messages")
+                    .update({ status: "blocked_insufficient_stock" })
+                    .eq("id", blockedProp.message_id);
+            }
+            throw new Error(blockText);
+        }
     }
     const orderNumber = `MB-${Date.now()}`;
     const { data: order, error: orderErr } = await supabaseAdmin
@@ -429,7 +323,26 @@ export const approveProposal = createServerFn({ method: "POST" })
     if (prop?.message_id) {
         await supabaseAdmin.from("mailbox_messages").update({ status: "converted" }).eq("id", prop.message_id);
     }
-    return { ok: true, orderId: order.id };
+    // ─── Gebeurtenis melden aan de Logistics Engine ─────────────────────────
+    const deliveryLocationRef = typeof customFields["delivery_location"] === "string" ? customFields["delivery_location"] : null;
+    await context.supabase.rpc("logistics_emit_event", {
+        p_source_module: "mailbox",
+        p_event_type: "order.received",
+        p_order_ref: orderNumber,
+        p_payload: {
+            checkinAt: data.deliveryDate,
+            pickupAt: data.deliveryDate,
+            customerRef: data.customerId,
+            deliveryLocationRef,
+            bufferRef: null,
+            loadCarrierType,
+            loadCarriers: [loadCarrierType],
+            ruleVersion: null,
+        },
+        p_shadow: true,
+        p_idempotency_key: `mailbox:${orderNumber}:order.received:v1`,
+    });
+    return { ok: true, orderId: order.id, orderNumber, shortages };
 });
 export const rejectProposal = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
@@ -464,13 +377,107 @@ export const listCustomersForPicker = createServerFn({ method: "GET" })
         .from("customers").select("id, company_name, email").eq("is_active", true).order("company_name").range(0, 4999);
     return { items: data ?? [] };
 });
-// Producten voor de picker — alleen items met beschikbare voorraad volgens de
-// Floriday Voorraad Module (`trade_item_stock`). Beschikbaar = physical - reserved.
-// De koppeling loopt via `products.custom_fields.floriday_id` = `trade_item_stock.trade_item_key`.
+// Producten voor de picker — ALLE artikelen uit de voorraad:
+//  1. alles in `products`
+//  2. elk handelsitem uit `floriday_trade_items_cache` (Voorraad Module) dat nog
+//     geen products-rij heeft, wordt hier automatisch aangemaakt (id = floriday_id)
+//     zodat bestelregels, belading en orders er gewoon naar kunnen verwijzen
+// Voorraad komt uit `trade_item_stock` en `trade_item_stock_view`.
 export const listProductsForPicker = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
-    const { data: stockRows } = await context.supabase
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // ── 1. Handelsitems uit de Voorraad Module materialiseren ───────────────
+    const { data: cacheRows } = await supabaseAdmin
+        .from("floriday_trade_items_cache")
+        .select("floriday_id, is_deleted, data")
+        .range(0, 4999);
+    const tradeItems = (Array.isArray(cacheRows) ? cacheRows : []).filter((r) => !r?.is_deleted && typeof r?.floriday_id === "string");
+    const { data: existingRows } = await supabaseAdmin
+        .from("products")
+        .select("id, custom_fields, floriday_trade_item_id")
+        .range(0, 9999);
+    const existing = Array.isArray(existingRows) ? existingRows : [];
+    const known = new Set();
+    for (const p of existing) {
+        known.add(String(p.id));
+        const fid = p?.custom_fields?.floriday_id ?? p?.floriday_trade_item_id;
+        if (typeof fid === "string" && fid)
+            known.add(fid);
+    }
+    const norm = (v) => Math.max(1, Math.round(Number(v ?? 1)) || 1);
+    const nameOf = (d) => {
+        const n = d?.tradeItemName;
+        if (typeof n === "string" && n.trim())
+            return n.trim();
+        if (n && typeof n === "object") {
+            const v = n.nl ?? n.en ?? Object.values(n).find((x) => typeof x === "string");
+            if (typeof v === "string" && v.trim())
+                return v.trim();
+        }
+        return typeof d?.tradeItemReference === "string" && d.tradeItemReference
+            ? d.tradeItemReference
+            : "Onbekend artikel";
+    };
+    const missing = tradeItems.filter((r) => !known.has(r.floriday_id));
+    const buildRow = (r) => {
+        const d = r.data ?? {};
+        const pk = Array.isArray(d.packingConfigurations) ? d.packingConfigurations[0] ?? {} : {};
+        return {
+            id: r.floriday_id,
+            product: nameOf(d),
+            // batch + location zijn NOT NULL zonder default in de Voorraad Module
+            batch: "",
+            location: "",
+            unit: "stuks",
+            quantity: 0,
+            plants_per_crate: norm(pk?.piecesPerPackage ?? pk?.unitsPerPackage),
+            crates_per_layer: norm(pk?.packagesPerLayer),
+            layers_per_cart: norm(pk?.layersPerLoadCarrier),
+            floriday_trade_item_id: r.floriday_id,
+            article_number: typeof d?.supplierArticleCode === "string" ? d.supplierArticleCode : null,
+            custom_fields: { floriday_id: r.floriday_id, source: "floriday_trade_items_cache" },
+        };
+    };
+    // Concept-artikelen uit de Voorraad Module (nog niet in Floriday) ook tonen
+    const { data: draftRowsAll } = await supabaseAdmin
+        .from("trade_item_drafts")
+        .select("id, data, floriday_id")
+        .range(0, 4999);
+    const draftMissing = (Array.isArray(draftRowsAll) ? draftRowsAll : []).filter((d) => typeof d?.id === "string" && !known.has(d.id) &&
+        !(typeof d?.floriday_id === "string" && known.has(d.floriday_id)));
+    const buildDraftRow = (r) => {
+        const d = r.data ?? {};
+        const pk = Array.isArray(d.packingConfigurations) ? d.packingConfigurations[0] ?? {} : {};
+        return {
+            id: r.id,
+            product: nameOf(d),
+            batch: "",
+            location: "",
+            unit: "stuks",
+            quantity: 0,
+            plants_per_crate: norm(pk?.unitsPerPackage ?? pk?.piecesPerPackage),
+            crates_per_layer: norm(pk?.packagesPerLayer),
+            layers_per_cart: norm(pk?.layersPerLoadCarrier),
+            article_number: typeof d?.supplierArticleCode === "string" ? d.supplierArticleCode : null,
+            custom_fields: { draft_id: r.id, source: "trade_item_drafts" },
+        };
+    };
+    const toInsert = [...missing.map(buildRow), ...draftMissing.map(buildDraftRow)];
+    // Artikelen die (nog) niet in `products` staan, tonen we hoe dan ook —
+    // ook als materialiseren faalt.
+    let virtualRows = [];
+    if (toInsert.length > 0) {
+        const { error: upsertError } = await supabaseAdmin
+            .from("products")
+            .upsert(toInsert, { onConflict: "id" });
+        if (upsertError) {
+            console.error("[listProductsForPicker] materialiseren mislukt:", upsertError.message);
+            virtualRows = toInsert;
+        }
+    }
+    // ── 2. Voorraad verzamelen ──────────────────────────────────────────────
+    const { data: stockRows } = await supabaseAdmin
         .from("trade_item_stock")
         .select("trade_item_key, physical_stock, reserved_stock");
     const availByProductId = new Map();
@@ -499,12 +506,14 @@ export const listProductsForPicker = createServerFn({ method: "GET" })
     }
     // Drafts uit de Voorraad Module: koppel via linkedProductId → products.id
     if (availByDraftId.size > 0) {
-        const { data: drafts } = await context.supabase
+        const { data: drafts } = await supabaseAdmin
             .from("trade_item_drafts")
             .select("id, data, floriday_id")
             .in("id", Array.from(availByDraftId.keys()));
         for (const d of Array.isArray(drafts) ? drafts : []) {
             const qty = availByDraftId.get(d.id) ?? 0;
+            // Concepten worden ook als product gematerialiseerd op hun eigen id
+            addAvail(availByProductId, d.id, qty);
             const linked = d?.data?.linkedProductId;
             if (typeof linked === "string" && linked)
                 addAvail(availByProductId, linked, qty);
@@ -513,19 +522,76 @@ export const listProductsForPicker = createServerFn({ method: "GET" })
                 addAvail(availByFloridayId, fid, qty);
         }
     }
-    const { data } = await context.supabase
+    // Voorraadoverzicht van de Voorraad Module (view)
+    try {
+        const { data: viewRows } = await supabaseAdmin
+            .from("trade_item_stock_view")
+            .select("trade_item_id, stock");
+        for (const v of Array.isArray(viewRows) ? viewRows : []) {
+            const id = v?.trade_item_id;
+            if (typeof id !== "string")
+                continue;
+            if (!availByFloridayId.has(id) && !availByProductId.has(id)) {
+                availByFloridayId.set(id, Number(v?.stock ?? 0));
+            }
+        }
+    }
+    catch {
+        // view optioneel
+    }
+    // ── 3. Alle producten teruggeven ────────────────────────────────────────
+    const { data } = await supabaseAdmin
         .from("products")
-        .select("id, product, unit, plants_per_crate, crates_per_layer, layers_per_cart, custom_fields")
-        .order("product").range(0, 4999);
-    const items = (Array.isArray(data) ? data : [])
+        .select("id, product, unit, plants_per_crate, crates_per_layer, layers_per_cart, custom_fields, floriday_trade_item_id")
+        .order("product")
+        .range(0, 9999);
+    const dbRows = Array.isArray(data) ? data : [];
+    const seen = new Set(dbRows.map((p) => String(p.id)));
+    const allRows = [
+        ...dbRows,
+        ...virtualRows.filter((v) => !seen.has(String(v.id))),
+    ];
+    const items = allRows
         .map((p) => {
-        const fid = p?.custom_fields?.floriday_id;
+        const fid = p?.custom_fields?.floriday_id ?? p?.floriday_trade_item_id;
         const byProd = availByProductId.get(p.id) ?? 0;
         const byFid = typeof fid === "string" ? (availByFloridayId.get(fid) ?? 0) : 0;
-        const available_stock = byProd + byFid;
-        return { ...p, available_stock };
-    });
-    return { items };
+        return { ...p, available_stock: byProd + byFid };
+    })
+        .sort((a, b) => String(a.product ?? "").localeCompare(String(b.product ?? "")));
+    // ── 4. Rule Engine: mag er doorverkocht worden zonder voorraad? ─────────
+    // `logistics_rule_configs.settings.order_verwerking.fields.allow_backorder`
+    // bepaalt of artikelen zonder voorraad selecteerbaar blijven. Er is niet
+    // altijd een config met is_active = true; val dan terug op de laatst
+    // bijgewerkte werkwijze zodat de instelling toch wordt gevolgd.
+    let allowBackorder = false;
+    try {
+        const readFlag = (rows) => {
+            const cfg = (Array.isArray(rows) ? rows : [])[0];
+            const raw = cfg?.settings?.order_verwerking?.fields?.allow_backorder;
+            return raw === undefined ? undefined : raw === true || raw === "true";
+        };
+        const { data: activeRows } = await supabaseAdmin
+            .from("logistics_rule_configs")
+            .select("settings, is_active, updated_at")
+            .eq("is_active", true)
+            .order("updated_at", { ascending: false })
+            .limit(1);
+        let flag = readFlag(activeRows);
+        if (flag === undefined) {
+            const { data: latestRows } = await supabaseAdmin
+                .from("logistics_rule_configs")
+                .select("settings, updated_at")
+                .order("updated_at", { ascending: false })
+                .limit(1);
+            flag = readFlag(latestRows);
+        }
+        allowBackorder = flag === true;
+    }
+    catch (e) {
+        console.error("[listProductsForPicker] rule engine lezen mislukt:", e);
+    }
+    return { items, allowBackorder };
 });
 export const planAndSaveAutoCarts = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
@@ -731,9 +797,14 @@ export const listPickupLocations = createServerFn({ method: "GET" })
         const label = nameRaw.length > 0
             ? nameRaw
             : [addr, city].filter(Boolean).join(", ") || "(naamloos)";
-        return { id: r.floriday_id, name: label, sort_order: 0 };
+        return {
+            id: r.floriday_id,
+            name: label,
+            is_default: r?.data?.isDefault === true,
+            sort_order: 0,
+        };
     })
-        .sort((a, b) => a.name.localeCompare(b.name, "nl"));
+        .sort((a, b) => (a.is_default === b.is_default ? a.name.localeCompare(b.name, "nl") : a.is_default ? -1 : 1));
     return { items };
 });
 export const listCarriersForPicker = createServerFn({ method: "GET" })
@@ -741,7 +812,7 @@ export const listCarriersForPicker = createServerFn({ method: "GET" })
     .handler(async ({ context }) => {
     const { data } = await context.supabase
         .from("carriers")
-        .select("id, name, is_default, sort_order, delivery_days")
+        .select("id, name, is_default, sort_order, delivery_days, pickup_weekdays, delivery_weekdays, pickup_moments")
         .order("sort_order", { ascending: true, nullsFirst: false })
         .order("name");
     return { items: data ?? [] };
@@ -766,3 +837,206 @@ function addCalendarDays(base, n) {
 function toISODate(d) {
     return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
 }
+// ─── Beladingen per product ────────────────────────────────────────────────
+// Zelfde bronnen als de Floriday Verkoop-module: packing-configuraties uit de
+// trade item cache, concept-artikelen, groepsleden en de products-tabel
+// (inclusief de opgeslagen Floriday-payload). Daarnaast worden ALLE in het
+// systeem bekende beladingen meegegeven, ook de niet-gekoppelde.
+export const listBeladingOptionsForProducts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ productIds: z.array(z.string()).max(200) }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const ids = Array.from(new Set((data.productIds ?? []).filter(Boolean)));
+    const byProduct = {};
+    function sortCombos(list) {
+        return [...list]
+            .sort((a, b) => a.plants_per_crate - b.plants_per_crate ||
+            a.crates_per_layer - b.crates_per_layer ||
+            a.layers_per_cart - b.layers_per_cart)
+            .map((v) => ({
+            ...v,
+            crates_per_cart: v.crates_per_layer * v.layers_per_cart,
+            plants_per_cart: v.plants_per_crate * v.crates_per_layer * v.layers_per_cart,
+        }));
+    }
+    // ── Namen van fusten (VBN-verpakkingscodes) en karren (load carriers) ───
+    const CARRIER_NAMES = {
+        DANISH_TROLLEY: "Deense container",
+        DANISH_CONTAINER: "Deense container",
+        DANISH_TROLLEY_NON_CC_RFID: "Deense container (non-CC RFID)",
+        DANISH_TROLLEY_WATER_TRAY: "Deense container met waterschaal",
+        ONE_THIRD_DANISH_TROLLEY: "1/3 Deense container",
+        AUCTION_TROLLEY: "Veilingstapelwagen",
+        EURO_TROLLEY: "Euro-stapelwagen",
+        CC_CONTAINER: "CC-container",
+        PALLET: "Pallet",
+        EURO_PALLET: "Europallet",
+        BOX: "Doos",
+        NONE: "Losse fusten",
+    };
+    const { data: floricodeRows } = await supabaseAdmin
+        .from("floricode_records")
+        .select("data")
+        .eq("resource", "LoadCarrier")
+        .range(0, 4999);
+    const crateNameByCode = new Map();
+    for (const r of Array.isArray(floricodeRows) ? floricodeRows : []) {
+        const d = r?.data;
+        if (d?.code == null)
+            continue;
+        const descr = typeof d?.description === "string" ? d.description.trim() : "";
+        if (descr)
+            crateNameByCode.set(String(d.code), descr);
+    }
+    const crateInfo = (p) => {
+        const raw = p?.package?.vbnPackageCode ?? p?.vbnPackageCode ?? p?.package?.customPackageId ?? null;
+        const code = raw == null || raw === "" ? null : String(raw);
+        return { code, name: code ? crateNameByCode.get(code) ?? `Fust ${code}` : null };
+    };
+    const carrierInfo = (p) => {
+        const raw = typeof p?.loadCarrier === "string" ? p.loadCarrier : (p?.loadCarrier?.type ?? null);
+        const code = typeof raw === "string" && raw ? raw : null;
+        return { code, name: code ? CARRIER_NAMES[code.toUpperCase()] ?? code : null };
+    };
+    const norm = (v) => Math.max(1, Math.round(Number(v ?? 1)) || 1);
+    const emptyMeta = { crate_code: null, crate_name: null, carrier_code: null, carrier_name: null };
+    const sameCombo = (x, a, b, c, m) => x.plants_per_crate === a && x.crates_per_layer === b && x.layers_per_cart === c &&
+        (x.crate_code ?? null) === (m.crate_code ?? null) &&
+        (x.carrier_code ?? null) === (m.carrier_code ?? null);
+    const packsById = new Map();
+    const push = (key, ppc, cpl, lpc, isDefault, meta = emptyMeta) => {
+        const a = norm(ppc), b = norm(cpl), c = norm(lpc);
+        const arr = packsById.get(key) ?? [];
+        const hit = arr.find((x) => sameCombo(x, a, b, c, meta));
+        if (hit) {
+            if (isDefault)
+                hit.is_default = true;
+            return;
+        }
+        arr.push({ plants_per_crate: a, crates_per_layer: b, layers_per_cart: c, is_default: isDefault, ...meta });
+        packsById.set(key, arr);
+    };
+    const pushPack = (key, p, ppc, isDefault) => {
+        const cr = crateInfo(p), ca = carrierInfo(p);
+        push(key, ppc, p?.packagesPerLayer, p?.layersPerLoadCarrier, isDefault, {
+            crate_code: cr.code, crate_name: cr.name, carrier_code: ca.code, carrier_name: ca.name,
+        });
+    };
+    // ── Alle beladingen in het systeem (ook niet-gekoppeld) ─────────────────
+    const globalCombos = new Map();
+    const addGlobal = (ppc, cpl, lpc, meta = emptyMeta) => {
+        const a = norm(ppc), b = norm(cpl), c = norm(lpc);
+        if (a === 1 && b === 1 && c === 1)
+            return;
+        const k = `${a}x${b}x${c}|${meta.crate_code ?? ""}|${meta.carrier_code ?? ""}`;
+        if (globalCombos.has(k))
+            return;
+        globalCombos.set(k, { plants_per_crate: a, crates_per_layer: b, layers_per_cart: c, is_default: false, ...meta });
+    };
+    const addGlobalPack = (p, ppc) => {
+        const cr = crateInfo(p), ca = carrierInfo(p);
+        addGlobal(ppc, p?.packagesPerLayer, p?.layersPerLoadCarrier, {
+            crate_code: cr.code, crate_name: cr.name, carrier_code: ca.code, carrier_name: ca.name,
+        });
+    };
+    const addAllPackings = (d, fn) => {
+        const packs = Array.isArray(d?.packingConfigurations) ? d.packingConfigurations : [];
+        for (const p of packs)
+            fn(p);
+    };
+    const [allTiRes, allDraftRes, allProdRes] = await Promise.all([
+        supabaseAdmin.from("floriday_trade_items_cache").select("data").range(0, 4999),
+        supabaseAdmin.from("trade_item_drafts").select("data").range(0, 4999),
+        supabaseAdmin
+            .from("products")
+            .select("plants_per_crate, crates_per_layer, layers_per_cart, custom_fields")
+            .range(0, 9999),
+    ]);
+    for (const r of Array.isArray(allTiRes.data) ? allTiRes.data : []) {
+        addAllPackings(r?.data, (p) => addGlobalPack(p, p?.piecesPerPackage ?? p?.unitsPerPackage));
+    }
+    for (const r of Array.isArray(allDraftRes.data) ? allDraftRes.data : []) {
+        addAllPackings(r?.data, (p) => addGlobalPack(p, p?.unitsPerPackage ?? p?.piecesPerPackage));
+    }
+    for (const p of Array.isArray(allProdRes.data) ? allProdRes.data : []) {
+        addGlobal(p.plants_per_crate, p.crates_per_layer, p.layers_per_cart);
+        addAllPackings(p?.custom_fields?.floriday_payload, (pc) => addGlobalPack(pc, pc?.unitsPerPackage ?? pc?.piecesPerPackage));
+    }
+    // Verwijder "kale" varianten (zonder fust-/kartype) als dezelfde afmetingen
+    // ook met fust- en kartype bekend zijn — anders zie je dubbele regels.
+    const dims = (c) => `${c.plants_per_crate}x${c.crates_per_layer}x${c.layers_per_cart}`;
+    const dropBare = (list) => {
+        const rich = new Set(list.filter((c) => c.crate_code || c.carrier_code).map(dims));
+        return list.filter((c) => c.crate_code || c.carrier_code || !rich.has(dims(c)));
+    };
+    const globalList = dropBare(Array.from(globalCombos.values()));
+    if (!ids.length)
+        return { byProduct, allBeladingen: sortCombos(globalList) };
+    // ── Gekoppelde beladingen per product ───────────────────────────────────
+    const { data: giRows } = await supabaseAdmin
+        .from("product_group_items")
+        .select("product_group_id, trade_item_id")
+        .in("product_group_id", ids);
+    const membersByGroup = new Map();
+    for (const gi of Array.isArray(giRows) ? giRows : []) {
+        const gid = gi.product_group_id;
+        const arr = membersByGroup.get(gid) ?? [];
+        arr.push(gi.trade_item_id);
+        membersByGroup.set(gid, arr);
+    }
+    const lookupIds = Array.from(new Set([...ids, ...Array.from(membersByGroup.values()).flat()]));
+    const [tiRes, draftRes, prodRes] = await Promise.all([
+        supabaseAdmin.from("floriday_trade_items_cache").select("floriday_id, data").in("floriday_id", lookupIds),
+        supabaseAdmin.from("trade_item_drafts").select("id, data").in("id", lookupIds),
+        supabaseAdmin
+            .from("products")
+            .select("id, plants_per_crate, crates_per_layer, layers_per_cart, custom_fields, trade_item_key")
+            .in("id", lookupIds),
+    ]);
+    for (const r of Array.isArray(tiRes.data) ? tiRes.data : []) {
+        const key = r.floriday_id;
+        addAllPackings(r?.data, (p) => pushPack(key, p, p?.piecesPerPackage ?? p?.unitsPerPackage, !!(p?.primary || p?.isPrimary)));
+    }
+    for (const r of Array.isArray(draftRes.data) ? draftRes.data : []) {
+        const key = r.id;
+        addAllPackings(r?.data, (p) => pushPack(key, p, p?.unitsPerPackage ?? p?.piecesPerPackage, !!(p?.primary || p?.isPrimary)));
+    }
+    for (const p of Array.isArray(prodRes.data) ? prodRes.data : []) {
+        const key = p.id;
+        push(key, p.plants_per_crate, p.crates_per_layer, p.layers_per_cart, true);
+        const fid = p.custom_fields?.floriday_id;
+        if (fid)
+            push(fid, p.plants_per_crate, p.crates_per_layer, p.layers_per_cart, false);
+        const tk = p.trade_item_key;
+        if (typeof tk === "string" && tk.startsWith("group:")) {
+            push(tk.slice("group:".length), p.plants_per_crate, p.crates_per_layer, p.layers_per_cart, true);
+        }
+        addAllPackings(p?.custom_fields?.floriday_payload, (pc) => {
+            const isPrim = !!(pc?.isPrimary || pc?.primary);
+            const ppc = pc?.unitsPerPackage ?? pc?.piecesPerPackage;
+            pushPack(key, pc, ppc, isPrim);
+            if (fid)
+                pushPack(fid, pc, ppc, isPrim);
+        });
+    }
+    for (const id of ids) {
+        const own = packsById.get(id) ?? [];
+        const memberCombos = [];
+        for (const m of membersByGroup.get(id) ?? []) {
+            for (const c of packsById.get(m) ?? [])
+                memberCombos.push(c);
+        }
+        const merged = [];
+        for (const c of [...own, ...memberCombos, ...globalList]) {
+            if (merged.some((x) => sameCombo(x, c.plants_per_crate, c.crates_per_layer, c.layers_per_cart, c)))
+                continue;
+            merged.push({ ...c, is_default: c.is_default && own.includes(c) });
+        }
+        const cleaned = dropBare(merged);
+        if (cleaned.length && !cleaned.some((x) => x.is_default))
+            cleaned[0].is_default = true;
+        byProduct[id] = sortCombos(cleaned);
+    }
+    return { byProduct, allBeladingen: sortCombos(globalList) };
+});