@flowselections/mailbox-orders 1.0.2 → 1.0.4

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

@@ -1,85 +1,272 @@
 // Server functions voor de Mailbox-bestellingen module
 import { createServerFn } from "@tanstack/react-start";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { createClient } from "@supabase/supabase-js";
 import { z } from "zod";
-// ─── Settings ────────────────────────────────────────────────────────────────
-export const getMailboxSettings = createServerFn({ method: "GET" })
-    .middleware([requireSupabaseAuth])
-    .handler(async ({ context }) => {
-    const { data, error } = await context.supabase
-        .from("mailbox_settings")
-        .select("*")
-        .limit(1)
-        .maybeSingle();
+// ─── 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
+// ontbreekt of verlopen is — anders crasht de UI met een 401.
+export const getActiveOrdersMailbox = createServerFn({ method: "GET" })
+    .handler(async () => {
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_PUBLISHABLE_KEY;
+    if (!url || !key)
+        return { connected: false, error: "missing_env" };
+    const sb = createClient(url, key, {
+        auth: { storage: undefined, persistSession: false, autoRefreshToken: false },
+    });
+    const { data, error } = await sb.rpc("email_auth_for_purpose", {
+        _purpose: "orders",
+        _direction: "receive",
+    });
     if (error)
-        throw new Error(error.message);
-    return { settings: data };
-});
-const SettingsInput = z.object({
-    imap_host: z.string().max(255),
-    imap_port: z.number().int().min(1).max(65535),
-    imap_username: z.string().max(255),
-    imap_use_tls: z.boolean(),
-    folder: z.string().max(255),
-    polling_enabled: z.boolean(),
+        return { connected: false, error: error.message };
+    const row = Array.isArray(data) ? data[0] : null;
+    if (!row)
+        return { connected: false };
+    return {
+        connected: true,
+        id: row.id,
+        provider: row.provider,
+        account_email: row.account_email,
+        display_name: (row.display_name ?? null),
+        status: (row.status ?? null),
+        last_error: (row.last_error ?? null),
+        last_verified_at: (row.last_verified_at ?? null),
+        needs_reauth: !!row.needs_reauth,
+    };
 });
-export const saveMailboxSettings = createServerFn({ method: "POST" })
-    .middleware([requireSupabaseAuth])
-    .inputValidator((input) => SettingsInput.parse(input))
-    .handler(async ({ data, context }) => {
-    const { data: existing } = await context.supabase
-        .from("mailbox_settings").select("id").limit(1).maybeSingle();
-    if (existing?.id) {
-        const { error } = await context.supabase
-            .from("mailbox_settings").update(data).eq("id", existing.id);
-        if (error)
-            throw new Error(error.message);
+// ─── 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 };
+        }
     }
-    else {
-        const { error } = await context.supabase
-            .from("mailbox_settings").insert({ ...data, singleton: true });
-        if (error)
-            throw new Error(error.message);
+    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 };
+        }
+        throw new Error(insErr.message);
     }
-    return { ok: true };
-});
-async function invokeMailboxImap(supabase, action) {
-    const { data, error } = await supabase.functions.invoke("mailbox-imap", {
-        body: { action },
+    // 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,
+        },
     });
-    if (error)
-        throw new Error(error.message ?? "Edge function aanroep mislukt");
-    return data;
 }
-export const testMailboxConnection = createServerFn({ method: "POST" })
-    .middleware([requireSupabaseAuth])
-    .handler(async ({ context }) => {
-    try {
-        return await invokeMailboxImap(context.supabase, "test");
+// 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: [] };
     }
-    catch (e) {
-        return { ok: false, error: e?.message ?? "Onbekende fout" };
+    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) {
+        return {
+            customerId: uniqueCustomerIds[0],
+            source: "customer_contacts",
+            warning: null,
+            candidates: cands,
+        };
     }
+    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" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ eventId: z.string().uuid() }).parse(input))
+    .handler(async ({ data }) => {
+    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)
+        .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 };
 });
-// ─── Polling ─────────────────────────────────────────────────────────────────
-export const pollMailbox = createServerFn({ method: "POST" })
+// ─── Backfill: haal alle nog niet-consumed events op voor 'orders/receive' ───
+export const backfillRecentEvents = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
-    try {
-        const res = await invokeMailboxImap(context.supabase, "poll");
-        let autoProcessed = 0;
-        let autoApproved = 0;
-        if (res.ok && (res.inserted ?? 0) > 0) {
-            const { autoProcessNewMessagesInternal } = await import("./mailbox-auto.server");
-            const r = await autoProcessNewMessagesInternal();
-            autoProcessed = r.processed;
-            autoApproved = r.approved;
+    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
         }
-        return { ok: !!res.ok, inserted: res.inserted ?? 0, autoProcessed, autoApproved, error: res.error };
     }
-    catch (e) {
-        return { ok: false, error: e?.message ?? "Onbekende fout", inserted: 0 };
+    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 };
 });
 // ─── Messages & Proposals ────────────────────────────────────────────────────
 export const listMessages = createServerFn({ method: "GET" })
@@ -103,120 +290,42 @@ export const parseMessage = createServerFn({ method: "POST" })
         .from("mailbox_messages").select("*").eq("id", data.messageId).single();
     if (msgErr || !msg)
         throw new Error("Bericht niet gevonden");
+    // AI staat uit: maak een leeg voorstel zodat het bericht in "Voorstellen" verschijnt.
+    await createStubProposal(supabaseAdmin, msg.id, msg.from_email ?? null);
     await supabaseAdmin.from("mailbox_messages")
-        .update({ status: "parsing", error_message: null }).eq("id", msg.id);
-    try {
-        // Templatevelden ophalen
-        const { data: fields } = await supabaseAdmin
-            .from("mailbox_order_template_fields")
-            .select("*")
-            .order("sort_order", { ascending: true });
-        const templateFields = (fields ?? []).filter((f) => f.ai_enabled);
-        // Databron-catalogi
-        const [{ data: products }, { data: customers }, { data: suppliers }] = await Promise.all([
-            supabaseAdmin.from("products").select("id, product, product_type").order("product").range(0, 1999),
-            supabaseAdmin.from("customers").select("id, company_name, email").eq("is_active", true).order("company_name").range(0, 4999),
-            supabaseAdmin.from("suppliers").select("id, name").order("name").range(0, 999),
-        ]);
-        const catalog = (products ?? []).map((p) => ({ id: p.id, name: p.product }));
-        const plantTypeSet = new Set();
-        (products ?? []).forEach((p) => { if (p.product_type)
-            plantTypeSet.add(p.product_type); });
-        const plantTypes = Array.from(plantTypeSet).sort().map((v) => ({ id: v, name: v }));
-        // Bouw spec met allowed values per database-veld
-        const spec = templateFields.map((f) => {
-            let allowed;
-            if (f.source === "database") {
-                switch (f.field_type) {
-                    case "customer":
-                        allowed = (customers ?? []).map((c) => ({ id: c.id, name: c.company_name }));
-                        break;
-                    case "product":
-                        allowed = catalog;
-                        break;
-                    case "plant_type":
-                        allowed = plantTypes;
-                        break;
-                    case "supplier":
-                        allowed = (suppliers ?? []).map((s) => ({ id: s.id, name: s.name }));
-                        break;
-                }
-            }
-            return {
-                key: f.key,
-                label: f.label,
-                field_type: f.field_type,
-                ai_hint: f.ai_hint,
-                allowed,
-            };
-        });
-        const { parseOrderEmail } = await import("./mailbox-ai.server");
-        const parsed = await parseOrderEmail(msg.body_text ?? msg.body_html ?? "", msg.subject ?? "", spec, catalog);
-        // Backwards-compat: leid klant/leverdatum/notes af voor de bestaande kolommen
-        const customerId = parsed.fields["customer"]?.value;
-        const deliveryDate = parsed.fields["delivery_date"]?.value;
-        const notesValue = parsed.fields["notes"]?.value;
-        const matchedCustomerId = typeof customerId === "string" && customerId.length === 36 ? customerId : null;
-        // Fallback: match op e-mail als AI niets vond
-        let finalCustomerId = matchedCustomerId;
-        if (!finalCustomerId && msg.from_email) {
-            const { data: customer } = await supabaseAdmin
-                .from("customers").select("id").eq("email", msg.from_email).maybeSingle();
-            finalCustomerId = customer?.id ?? null;
-        }
-        const { data: proposal, error: propErr } = await supabaseAdmin
-            .from("mailbox_order_proposals").insert({
-            message_id: msg.id,
-            matched_customer_id: finalCustomerId,
-            confidence: parsed.overall_confidence,
-            delivery_date: typeof deliveryDate === "string" ? deliveryDate : null,
-            notes: typeof notesValue === "string" ? notesValue : null,
-            parsed_payload: parsed,
-            status: "pending",
-        }).select("id").single();
-        if (propErr)
-            throw new Error(propErr.message);
-        // Sla alle veldwaarden op
-        const fieldRows = Object.entries(parsed.fields).map(([key, v]) => ({
-            proposal_id: proposal.id,
-            field_key: key,
-            value: v.value === undefined ? null : v.value,
-            ai_confidence: v.confidence,
-            ai_filled: v.value !== null && v.value !== undefined,
-            needs_review: v.needs_review,
-        }));
-        if (fieldRows.length > 0) {
-            await supabaseAdmin.from("mailbox_proposal_field_values").insert(fieldRows);
-        }
-        if (parsed.lines.length > 0) {
-            const linesToInsert = parsed.lines.map((l, idx) => ({
-                proposal_id: proposal.id,
-                product_id: l.product_id,
-                raw_product_text: l.raw_product_text,
-                quantity: l.quantity,
-                unit: l.unit,
-                match_confidence: l.match_confidence,
-                sort_order: idx,
-            }));
-            await supabaseAdmin.from("mailbox_proposal_lines").insert(linesToInsert);
-        }
-        await supabaseAdmin.from("mailbox_messages")
-            .update({ status: "parsed" }).eq("id", msg.id);
-        return { ok: true, proposalId: proposal.id };
-    }
-    catch (e) {
-        await supabaseAdmin.from("mailbox_messages")
-            .update({ status: "failed", error_message: e?.message ?? "Parsefout" }).eq("id", msg.id);
-        return { ok: false, error: e?.message ?? "Parsefout" };
-    }
+        .update({ status: "parsed", error_message: null }).eq("id", msg.id);
+    return { ok: true };
 });
 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
         .from("mailbox_order_proposals")
-        .select("*, mailbox_messages(subject, from_email, from_name, body_text, received_at), mailbox_proposal_lines(*), mailbox_proposal_field_values(*)")
+        .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)
         .order("created_at", { ascending: false })
         .limit(100);
     if (data.status)
@@ -250,11 +359,29 @@ export const approveProposal = createServerFn({ method: "POST" })
 }).parse(input))
     .handler(async ({ data, context }) => {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
-    // Bouw custom_fields map vanuit alle templatevelden
     const customFields = {};
     (data.fieldValues ?? []).forEach((fv) => {
         customFields[fv.field_key] = fv.value;
     });
+    // ─── Validatie eerst mogelijke leverdatum ────────────────────────────────
+    const carrierId = typeof customFields["carrier"] === "string" ? customFields["carrier"] : null;
+    let carrierDeliveryDays = 0;
+    if (carrierId) {
+        const { data: c } = await context.supabase
+            .from("carriers").select("delivery_days").eq("id", carrierId).maybeSingle();
+        carrierDeliveryDays = Math.max(0, Number(c?.delivery_days ?? 0));
+    }
+    const { data: settings } = await context.supabase
+        .from("afhandeling_settings")
+        .select("pick_days_before_transport")
+        .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);
+    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).`);
+    }
     const orderNumber = `MB-${Date.now()}`;
     const { data: order, error: orderErr } = await supabaseAdmin
         .from("orders").insert({
@@ -280,7 +407,6 @@ export const approveProposal = createServerFn({ method: "POST" })
     const { error: itemsErr } = await supabaseAdmin.from("order_items").insert(items);
     if (itemsErr)
         throw new Error(itemsErr.message);
-    // Sla finale veldwaarden op (overschrijft AI-waarden)
     if (data.fieldValues && data.fieldValues.length > 0) {
         for (const fv of data.fieldValues) {
             await supabaseAdmin.from("mailbox_proposal_field_values").upsert({
@@ -318,6 +444,19 @@ export const rejectProposal = createServerFn({ method: "POST" })
     }).eq("id", data.proposalId);
     return { ok: true };
 });
+// Een afgewezen (of goedgekeurd) voorstel terugzetten naar "te controleren".
+export const reopenProposal = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ proposalId: z.string().uuid() }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    await supabaseAdmin.from("mailbox_order_proposals").update({
+        status: "pending",
+        reviewed_by: null,
+        reviewed_at: null,
+    }).eq("id", data.proposalId);
+    return { ok: true };
+});
 export const listCustomersForPicker = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
@@ -329,6 +468,230 @@ export const listProductsForPicker = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
     const { data } = await context.supabase
-        .from("products").select("id, product, unit").order("product").range(0, 4999);
+        .from("products")
+        .select("id, product, unit, plants_per_crate, crates_per_layer, layers_per_cart")
+        .order("product").range(0, 4999);
     return { items: data ?? [] };
 });
+export const planAndSaveAutoCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    // Items met productbelading ophalen
+    const { data: items, error: itErr } = await context.supabase
+        .from("order_items")
+        .select("id, product_id, product_name, quantity, products(plants_per_crate, crates_per_layer, layers_per_cart)")
+        .eq("order_id", data.orderId);
+    if (itErr)
+        throw new Error(itErr.message);
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Reset eventuele eerdere auto-karren (idempotent)
+    await supabaseAdmin.from("order_carts").delete().eq("order_id", data.orderId).eq("is_auto", true);
+    let cartNumber = 1;
+    // Eerst hoogste bestaande nr ophalen (voor manueel toegevoegde karren)
+    const { data: existingMax } = await supabaseAdmin
+        .from("order_carts").select("cart_number").eq("order_id", data.orderId)
+        .order("cart_number", { ascending: false }).limit(1);
+    if (existingMax && existingMax[0])
+        cartNumber = existingMax[0].cart_number + 1;
+    const autoCarts = [];
+    const remainders = [];
+    for (const it of items ?? []) {
+        const prod = it.products ?? {};
+        const ppc = Math.max(1, Number(prod.plants_per_crate ?? 1));
+        const cpl = Math.max(1, Number(prod.crates_per_layer ?? 1));
+        const lpc = Math.max(1, Number(prod.layers_per_cart ?? 1));
+        const cratesPerCart = cpl * lpc;
+        // quantity is in PLANTEN (zie approveProposal)
+        const totalPlants = Math.max(0, Number(it.quantity ?? 0));
+        const totalCrates = Math.ceil(totalPlants / ppc);
+        const fullCarts = Math.floor(totalCrates / cratesPerCart);
+        const remainder = totalCrates - fullCarts * cratesPerCart;
+        for (let i = 0; i < fullCarts; i++) {
+            const { data: cart, error: cErr } = await supabaseAdmin
+                .from("order_carts").insert({
+                order_id: data.orderId,
+                cart_number: cartNumber,
+                is_auto: true,
+                is_complete: true,
+            }).select("id").single();
+            if (cErr)
+                throw new Error(cErr.message);
+            await supabaseAdmin.from("order_cart_items").insert({
+                cart_id: cart.id,
+                order_item_id: it.id,
+                product_id: it.product_id,
+                product_name: it.product_name,
+                crates: cratesPerCart,
+                plants_per_crate: ppc,
+                crates_per_layer: cpl,
+            });
+            autoCarts.push({
+                cart_number: cartNumber,
+                product_name: it.product_name,
+                crates: cratesPerCart,
+                plants: cratesPerCart * ppc,
+                capacity: cratesPerCart,
+            });
+            cartNumber++;
+        }
+        if (remainder > 0) {
+            remainders.push({
+                order_item_id: it.id,
+                product_id: it.product_id,
+                product_name: it.product_name,
+                crates_remaining: remainder,
+                plants_per_crate: ppc,
+                crates_per_layer: cpl,
+                layers_per_cart: lpc,
+            });
+        }
+    }
+    // Bestaande handmatige karren ophalen + crates per order_item aftrekken van remainders,
+    // zodat heropenen van de wizard niet dezelfde fusten opnieuw vraagt.
+    const { data: manualCartsRaw } = await supabaseAdmin
+        .from("order_carts")
+        .select("id, cart_number, notes, order_cart_items(order_item_id, product_id, product_name, crates, plants_per_crate, crates_per_layer)")
+        .eq("order_id", data.orderId).eq("is_auto", false)
+        .order("cart_number");
+    const existingManualCarts = (manualCartsRaw ?? []).map((c) => ({
+        cart_number: c.cart_number,
+        notes: c.notes,
+        items: (c.order_cart_items ?? []).map((i) => ({
+            order_item_id: i.order_item_id,
+            product_id: i.product_id,
+            product_name: i.product_name,
+            crates: Number(i.crates ?? 0),
+            plants_per_crate: Number(i.plants_per_crate ?? 1),
+            crates_per_layer: Number(i.crates_per_layer ?? 1),
+        })),
+    }));
+    const assignedByItem = {};
+    existingManualCarts.forEach((c) => c.items.forEach((i) => {
+        if (!i.order_item_id)
+            return;
+        assignedByItem[i.order_item_id] = (assignedByItem[i.order_item_id] ?? 0) + Number(i.crates ?? 0);
+    }));
+    const adjustedRemainders = remainders
+        .map((r) => ({ ...r, crates_remaining: Math.max(0, r.crates_remaining - (assignedByItem[r.order_item_id] ?? 0)) }))
+        .filter((r) => r.crates_remaining > 0);
+    return { ok: true, autoCarts, remainders: adjustedRemainders, existingManualCarts, nextCartNumber: cartNumber };
+});
+const ManualCartItem = z.object({
+    order_item_id: z.string().uuid().nullable(),
+    product_id: z.string().uuid().nullable(),
+    product_name: z.string().min(1).max(255),
+    crates: z.number().int().min(1),
+    plants_per_crate: z.number().int().min(1),
+    crates_per_layer: z.number().int().min(1),
+});
+const ManualCart = z.object({
+    is_complete: z.boolean().optional(),
+    notes: z.string().max(500).nullable().optional(),
+    items: z.array(ManualCartItem).min(1),
+});
+export const saveManualCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid(), carts: z.array(ManualCart) }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Verwijder eerdere handmatige karren (replace strategy)
+    await supabaseAdmin.from("order_carts").delete()
+        .eq("order_id", data.orderId).eq("is_auto", false);
+    const { data: existingMax } = await supabaseAdmin
+        .from("order_carts").select("cart_number").eq("order_id", data.orderId)
+        .order("cart_number", { ascending: false }).limit(1);
+    let cartNumber = existingMax && existingMax[0] ? existingMax[0].cart_number + 1 : 1;
+    for (const cart of data.carts) {
+        const { data: inserted, error: cErr } = await supabaseAdmin
+            .from("order_carts").insert({
+            order_id: data.orderId,
+            cart_number: cartNumber,
+            is_auto: false,
+            is_complete: !!cart.is_complete,
+            notes: cart.notes ?? null,
+        }).select("id").single();
+        if (cErr)
+            throw new Error(cErr.message);
+        const rows = cart.items.map((i) => ({
+            cart_id: inserted.id,
+            order_item_id: i.order_item_id,
+            product_id: i.product_id,
+            product_name: i.product_name,
+            crates: i.crates,
+            plants_per_crate: i.plants_per_crate,
+            crates_per_layer: i.crates_per_layer,
+        }));
+        const { error: iErr } = await supabaseAdmin.from("order_cart_items").insert(rows);
+        if (iErr)
+            throw new Error(iErr.message);
+        cartNumber++;
+    }
+    return { ok: true };
+});
+export const listOrderCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => d)
+    .handler(async ({ data, context }) => {
+    const { data: carts } = await context.supabase
+        .from("order_carts")
+        .select("id, cart_number, is_auto, is_complete, notes, order_cart_items(*)")
+        .eq("order_id", data.orderId)
+        .order("cart_number");
+    return { items: carts ?? [] };
+});
+export const listDeliveryLocationsForCustomer = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => d)
+    .handler(async ({ data, context }) => {
+    if (!data.customerId)
+        return { items: [] };
+    const { data: rows } = await context.supabase
+        .from("customer_delivery_locations")
+        .select("id, name, address_line, street, house_number, postal_code, city, province, country, is_primary, carrier_id, carriers(id, name)")
+        .eq("customer_id", data.customerId)
+        .order("is_primary", { ascending: false })
+        .order("name");
+    return { items: Array.isArray(rows) ? rows : [] };
+});
+// Onze eigen bedrijfslocaties (tuinen / afhaallocaties). Staan los van klantlocaties.
+export const listPickupLocations = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("locations")
+        .select("id, name, sort_order")
+        .order("sort_order", { ascending: true })
+        .order("name");
+    return { items: Array.isArray(data) ? data : [] };
+});
+export const listCarriersForPicker = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("carriers")
+        .select("id, name, is_default, sort_order, delivery_days")
+        .order("sort_order", { ascending: true, nullsFirst: false })
+        .order("name");
+    return { items: data ?? [] };
+});
+// Orderpicktijd — gebruikt voor het berekenen van de eerst mogelijke leverdatum
+export const getOrderPickDays = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("afhandeling_settings")
+        .select("pick_days_before_transport")
+        .order("updated_at", { ascending: false })
+        .limit(1)
+        .maybeSingle();
+    return { pickDays: Math.max(0, Number(data?.pick_days_before_transport ?? 0)) };
+});
+function addCalendarDays(base, n) {
+    const x = new Date(base);
+    x.setDate(x.getDate() + n);
+    return x;
+}
+function toISODate(d) {
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}