@flowselections/logistiek-engine 1.0.33 → 1.0.53

package/dist-lib/lib/flowTree.js

@@ -0,0 +1,519 @@
+// ============================================================================
+// src/lib/flowTree.ts — vertakkende beslisboom van de Logistiek Engine
+// ============================================================================
+// Bouwt uit WIZARD_STEPS en de opgeslagen werkwijze een boom waarin ELK
+// beslismoment al zijn uitkomsten laat zien. De vertakkingen komen uit de
+// `dependsOn`-regels van het schema: een instelling die alleen geldt bij een
+// bepaalde keuze hangt onder de pijl van die keuze. De actieve route wordt met
+// dezelfde `fieldVisible`-logica bepaald die de engine en het instelscherm
+// gebruiken. Er staat hier geen aparte flowlogica.
+// ============================================================================
+import { fieldVisible, optionLabel, } from "./ruleEngineSchema";
+import { WIZARD_STEPS, fieldHelp } from "./ruleEngineWizard";
+export const NODE_SIZE = {
+    start: { w: 240, h: 60 },
+    end: { w: 240, h: 60 },
+    source: { w: 260, h: 96 },
+    step: { w: 300, h: 88 },
+    decision: { w: 280, h: 118 },
+    setting: { w: 240, h: 66 },
+    option: { w: 150, h: 30 },
+    merge: { w: 14, h: 14 },
+};
+const DAY_SHORT = {
+    mon: "ma",
+    tue: "di",
+    wed: "wo",
+    thu: "do",
+    fri: "vr",
+    sat: "za",
+    sun: "zo",
+};
+function isDecision(field) {
+    if (field.type === "toggle")
+        return true;
+    if (field.type === "select" || field.type === "radio") {
+        return Array.isArray(field.options) && field.options.length >= 2;
+    }
+    return false;
+}
+function rulesOf(field) {
+    if (!field.dependsOn)
+        return [];
+    return Array.isArray(field.dependsOn) ? field.dependsOn : [field.dependsOn];
+}
+function optionsOf(field) {
+    if (field.type === "toggle") {
+        return [
+            { value: "true", label: "ja" },
+            { value: "false", label: "nee" },
+        ];
+    }
+    return (field.options ?? []).map((o) => ({ value: o.value, label: o.label }));
+}
+function currentOf(field, value) {
+    if (field.type === "toggle")
+        return value === true ? "true" : "false";
+    return String(value ?? "");
+}
+/**
+ * Zoekt de schemavelden op die bij een vakje horen. Gebruikt dezelfde
+ * WIZARD_STEPS als het instelscherm, zodat er geen tweede definitie ontstaat.
+ */
+export function fieldsFor(storeId, keys) {
+    const veiligeKeys = Array.isArray(keys) ? keys : [];
+    if (!storeId || !veiligeKeys.length)
+        return [];
+    const stappen = Array.isArray(WIZARD_STEPS) ? WIZARD_STEPS : [];
+    const alle = [];
+    for (const stap of stappen) {
+        if (stap.storeId !== storeId)
+            continue;
+        for (const group of Array.isArray(stap.groups) ? stap.groups : []) {
+            for (const field of Array.isArray(group.fields) ? group.fields : [])
+                alle.push(field);
+        }
+    }
+    return veiligeKeys
+        .map((k) => alle.find((f) => f.key === k))
+        .filter((f) => Boolean(f));
+}
+export function valueText(field, value) {
+    if (value === undefined || value === null || value === "")
+        return "niet ingesteld";
+    switch (field.type) {
+        case "toggle":
+            return value === true ? "aan" : "uit";
+        case "select":
+        case "radio":
+            return optionLabel(field, value);
+        case "days": {
+            const days = Array.isArray(value) ? value : [];
+            return days.length ? days.map((d) => DAY_SHORT[d] ?? d).join(", ") : "geen";
+        }
+        case "number":
+            return `${String(value)}${field.unit ? ` ${field.unit}` : ""}`;
+        case "priority": {
+            const entries = Array.isArray(value) ? value : [];
+            return `${entries.filter((e) => e?.enabled).length} actief`;
+        }
+        case "textarea":
+        case "text": {
+            const t = String(value);
+            return t.length > 40 ? `${t.slice(0, 39)}…` : t;
+        }
+        default:
+            return String(value);
+    }
+}
+/** Toestand van een tak-pijl uit een beslissing. */
+function edgeState(decision, isCurrent) {
+    if (decision === "active")
+        return isCurrent ? "active" : "possible";
+    if (decision === "possible")
+        return isCurrent ? "possible" : "disabled";
+    return "disabled";
+}
+function weakest(a, b) {
+    const rank = { active: 0, possible: 1, disabled: 2 };
+    return rank[a] >= rank[b] ? a : b;
+}
+/** Bouwt de complete beslisboom van binnenkomst tot afgehandelde order. */
+export function buildFlowTree(settings) {
+    const veilig = settings && typeof settings === "object" ? settings : {};
+    const nodes = [];
+    const edges = [];
+    const decisionIds = new Map();
+    const pendingRefs = [];
+    const add = (node) => {
+        const size = NODE_SIZE[node.kind];
+        const n = { ...node, ancestors: node.ancestors ?? [], w: size.w, h: size.h };
+        nodes.push(n);
+        return n;
+    };
+    const link = (from, to, state, label, ancestors = [], kind = "flow") => {
+        edges.push({ id: `${kind}:${from}->${to}:${label ?? ""}`, from, to, label, state, kind, ancestors });
+    };
+    // ── Start en herkomst ──────────────────────────────────────────────────────
+    add({
+        id: "__start",
+        kind: "start",
+        label: "Order komt binnen",
+        sublabel: "Floriday of eigen verkoop",
+        state: "active",
+        help: [
+            "Hier begint de route. Elke order die binnenkomt start bovenaan deze kaart en loopt via alle stappen naar 'Order afgehandeld'.",
+            "Gekleurde vakjes en dikke pijlen zijn de route die nu geldt. Lichte vakjes zijn keuzes die je ook kunt maken; grijze, gestippelde takken zijn op dit moment niet bereikbaar door een keuze eerder in de route.",
+        ],
+    });
+    add({
+        id: "__bron",
+        kind: "source",
+        label: "Waar komt de order vandaan?",
+        sublabel: "vaste regel — geen instelling",
+        state: "active",
+        help: [
+            "De engine herkent zelf waar een order vandaan komt: Floriday, de mailbox voor bestellingen, de actiemail of handmatige invoer. Dit is geen instelling; alle vier de routes bestaan altijd.",
+            "Het verschil zit vooral bij de verzendbrief: een Floriday-order krijgt uitsluitend de officiële Floriday-afleverbrief, de overige orders de eigen verzendbrieflayout uit de Layout maker.",
+            "Verder doorlopen alle orders dezelfde stappen en dezelfde regels hieronder.",
+        ],
+    });
+    link("__start", "__bron", "active");
+    add({ id: "__bron_merge", kind: "merge", label: "", state: "active", help: [] });
+    const bronnen = [
+        {
+            id: "__bron_floriday",
+            label: "Bestellingen uit Floriday",
+            sub: "order_source: floriday",
+            help: [
+                "Floriday levert per artikel een eigen verkooporder aan. Eén bestelling van één klant komt daardoor binnen als losse regels met elk een eigen FO-nummer.",
+                "Daarom volgt hierna eerst de stap 'Bestelregels samenvoegen'.",
+            ],
+        },
+        {
+            id: "__bron_mail",
+            label: "Bestellingen uit de mail",
+            sub: "mailbox voor bestellingen",
+            help: [
+                "Bestellingen die per e-mail binnenkomen en via de mailboxmodule als ordervoorstel worden goedgekeurd.",
+                "Een goedgekeurd voorstel wordt één order en loopt daarna dezelfde route als alle andere orders.",
+            ],
+        },
+        {
+            id: "__bron_actiemail",
+            label: "Bestellingen uit de actiemail",
+            sub: "actiemail kwekers",
+            help: [
+                "Bestellingen die voortkomen uit een actiemail aan kwekers/klanten.",
+                "Ook deze orders lopen daarna dezelfde route als alle andere orders.",
+            ],
+        },
+        {
+            id: "__bron_handmatig",
+            label: "Handmatige bestellingen",
+            sub: "ingevoerd in verkoop",
+            help: [
+                "Orders die een medewerker zelf aanmaakt in het verkoopscherm.",
+                "Deze orders zijn al één bestelling met één ordernummer en worden niet samengevoegd.",
+            ],
+        },
+    ];
+    for (const b of bronnen) {
+        add({ id: b.id, kind: "source", label: b.label, sublabel: b.sub, state: "active", help: b.help });
+        link("__bron", b.id, "active");
+    }
+    // ── Floriday: bestelregels eerst samenvoegen tot één bestelling ────────────
+    const ovFields = (veilig["order_verwerking"]?.fields ?? {});
+    const samenvoegenAan = ovFields["floriday_merge_lines"] !== false;
+    add({
+        id: "stap:bestelregels_samenvoegen",
+        kind: "step",
+        label: "Bestelregels samenvoegen",
+        sublabel: samenvoegenAan
+            ? "aan — regels van dezelfde klant en levermoment worden één bestelling"
+            : "uit — elke Floriday-regel blijft een eigen order",
+        state: samenvoegenAan ? "active" : "disabled",
+        storeId: "order_verwerking",
+        fieldKeys: ["floriday_merge_lines"],
+        lines: [
+            samenvoegenAan
+                ? "Samenvoegen: aan (zelfde klant, levermoment en afleverlocatie)"
+                : "Samenvoegen: uit",
+            "Laagste FO-nummer blijft het ordernummer",
+            "Al ingedeelde, geprinte of gecontroleerde orders blijven ongewijzigd",
+        ],
+        help: [
+            "Floriday stuurt elke bestelregel als een eigen verkooporder. Deze stap bundelt de regels van dezelfde klant, hetzelfde levermoment en dezelfde afleverlocatie tot één bestelling met één ordernummer.",
+            "Het laagste FO-nummer van de groep blijft staan; de andere nummers worden als herkomst bewaard, zodat documenten en terugkoppeling naar Floriday blijven kloppen.",
+            "Orders die al vastliggen (ingedeeld, geprint, gescand of afgehandeld) worden nooit alsnog samengevoegd.",
+        ],
+    });
+    link("__bron_floriday", "stap:bestelregels_samenvoegen", samenvoegenAan ? "active" : "possible");
+    link("stap:bestelregels_samenvoegen", "__bron_merge", samenvoegenAan ? "active" : "possible");
+    link("__bron_mail", "__bron_merge", "active");
+    link("__bron_actiemail", "__bron_merge", "active");
+    link("__bron_handmatig", "__bron_merge", "active");
+    let tail = "__bron_merge";
+    // ── Stappen ────────────────────────────────────────────────────────────────
+    WIZARD_STEPS.forEach((step, index) => {
+        const values = (veilig?.[step.storeId]?.fields ?? {});
+        const groups = Array.isArray(step.groups) ? step.groups : [];
+        const fieldsInOrder = [];
+        for (const group of groups) {
+            for (const field of Array.isArray(group.fields) ? group.fields : []) {
+                if (field.type === "guidance")
+                    continue;
+                fieldsInOrder.push({ field, group });
+            }
+        }
+        const keysHere = new Set(fieldsInOrder.map((f) => f.field.key));
+        const order = new Map(fieldsInOrder.map((f, i) => [f.field.key, i]));
+        // Elk veld hangt onder de "diepste" beslissing uit dezelfde stap waar het
+        // van afhangt (de regel waarvan het bronveld het laatst in de volgorde staat).
+        const childrenOf = new Map();
+        const roots = [];
+        for (const item of fieldsInOrder) {
+            const local = rulesOf(item.field).filter((r) => !r.step && keysHere.has(r.key));
+            if (!local.length) {
+                roots.push(item);
+                continue;
+            }
+            const parentRule = local.reduce((best, r) => (order.get(r.key) ?? -1) > (order.get(best.key) ?? -1) ? r : best);
+            const list = childrenOf.get(parentRule.key) ?? [];
+            list.push({ ...item, rule: parentRule });
+            childrenOf.set(parentRule.key, list);
+        }
+        const ctx = {
+            nodes,
+            edges,
+            settings: veilig,
+            step,
+            values,
+            fieldsInOrder,
+            childrenOf,
+            decisionIds,
+            pendingRefs,
+        };
+        const stepNode = add({
+            id: `stap:${step.id}`,
+            kind: "step",
+            label: `${index + 1}. ${step.label}`,
+            sublabel: step.description,
+            stepId: step.id,
+            storeId: step.storeId,
+            state: "active",
+            help: [
+                step.description,
+                `Achter deze stap staan ${fieldsInOrder.length} instellingen. Klik op het vakje om ze allemaal in het zijpaneel te openen.`,
+                "De vertakkingen hieronder laten zien welke instellingen alleen gelden bij een bepaalde keuze.",
+            ],
+        });
+        link(tail, stepNode.id, "active");
+        const stapMerge = `samen:stap:${step.id}`;
+        fan(ctx, stepNode.id, "active", roots, [], stapMerge);
+        nodes.push({ id: stapMerge, kind: "merge", label: "", state: "active", ancestors: [], help: [], w: NODE_SIZE.merge.w, h: NODE_SIZE.merge.h });
+        tail = stapMerge;
+    });
+    // ── Einde ──────────────────────────────────────────────────────────────────
+    add({
+        id: "__eind",
+        kind: "end",
+        label: "Order afgehandeld",
+        sublabel: "gecontroleerd en afgemeld",
+        state: "active",
+        help: [
+            "Dit is het einde van de route: de order is gepickt, gecontroleerd en afgemeld.",
+            "Pas als alle stappen hierboven doorlopen zijn, komt een order hier terecht.",
+        ],
+    });
+    link(tail, "__eind", "active");
+    // ── Verwijspijlen tussen stappen ───────────────────────────────────────────
+    for (const ref of pendingRefs) {
+        const from = decisionIds.get(`${ref.storeId}:${ref.key}`);
+        if (!from)
+            continue;
+        const fromNode = nodes.find((n) => n.id === from);
+        const label = fromNode
+            ? ref.values
+                .map((v) => fromNode.options?.find((o) => o.value === String(v))?.label ?? String(v))
+                .join(" / ")
+            : undefined;
+        link(from, ref.toNode, ref.state, label, ref.ancestors, "ref");
+    }
+    return { nodes, edges };
+}
+/**
+ * Waaiert een lijst velden uit vanaf `from`: elke beslissing wordt een eigen arm
+ * met al haar keuzes; losse instellingen worden per blok gebundeld in één
+ * vakje. Alle armen komen samen in `mergeId`.
+ */
+function fan(ctx, from, fromState, items, ancestors, mergeId) {
+    const size = NODE_SIZE;
+    // `from` is uniek per tak (stap, of het tussenpunt van een keuze).
+    const takSleutel = from.replace(/[^a-z0-9_]+/gi, "_");
+    const push = (e) => {
+        ctx.edges.push({
+            id: `${e.kind ?? "flow"}:${e.from}->${e.to}:${e.suffix ?? e.label ?? ""}`,
+            from: e.from,
+            to: e.to,
+            label: e.label,
+            state: e.state,
+            kind: e.kind ?? "flow",
+            ancestors: e.ancestors,
+        });
+    };
+    const uitlegVoor = (field, group, state) => {
+        const help = [];
+        const uitleg = fieldHelp(field);
+        if (uitleg)
+            help.push(uitleg);
+        help.push(`Onderdeel van stap "${ctx.step.label}", blok "${group.label}".`);
+        help.push(`Nu ingesteld op: ${valueText(field, ctx.values[field.key])}.`);
+        if (ancestors.length) {
+            help.push(`Deze tak geldt alleen onder: ${ancestors
+                .map((a) => ctx.nodes.find((n) => n.id === a)?.label ?? a)
+                .join(" → ")}.`);
+        }
+        if (state === "disabled") {
+            help.push("Deze tak is op dit moment niet bereikbaar door een keuze eerder in de route.");
+        }
+        else if (state === "possible") {
+            help.push("Deze tak is mogelijk, maar niet de keuze die nu geldt.");
+        }
+        return help;
+    };
+    const verwijzingen = (field, toNode, state, help) => {
+        for (const rule of rulesOf(field)) {
+            if (!rule.step)
+                continue;
+            ctx.pendingRefs.push({ toNode, storeId: rule.step, key: rule.key, values: rule.in, state, ancestors });
+            help.push("De gestippelde pijl laat zien van welke keuze uit een andere stap dit vakje afhangt.");
+        }
+    };
+    const stateVan = (field) => fieldVisible(field, ctx.values, ctx.settings) ? fromState : weakest(fromState, "disabled");
+    let armen = 0;
+    // ── Losse instellingen: per blok één vakje ────────────────────────────────
+    const losse = items.filter((i) => !isDecision(i.field));
+    const perBlok = new Map();
+    for (const { field, group } of losse) {
+        const b = perBlok.get(group.id) ?? { group, fields: [] };
+        b.fields.push(field);
+        perBlok.set(group.id, b);
+    }
+    for (const { group, fields } of perBlok.values()) {
+        const id = `blok:${ctx.step.storeId}:${group.id}:${takSleutel}`;
+        const states = fields.map(stateVan);
+        const state = states.some((s) => s !== "disabled") ? fromState : weakest(fromState, "disabled");
+        const lines = fields.map((f) => `${f.label}: ${valueText(f, ctx.values[f.key])}`);
+        const help = [];
+        if (group.description)
+            help.push(group.description);
+        help.push(`Vaste instellingen in blok "${group.label}" van stap "${ctx.step.label}":`);
+        help.push(...lines);
+        help.push("Dubbelklik op het vakje om deze instellingen hier meteen aan te passen.");
+        for (const f of fields)
+            verwijzingen(f, id, state, help);
+        const h = Math.min(6, lines.length) * 16 + 44;
+        ctx.nodes.push({
+            id,
+            kind: "setting",
+            label: group.label,
+            sublabel: `${fields.length} instelling${fields.length === 1 ? "" : "en"}`,
+            lines,
+            fieldKeys: fields.map((f) => f.key),
+            state,
+            stepId: ctx.step.id,
+            storeId: ctx.step.storeId,
+            ancestors,
+            help,
+            w: size.setting.w,
+            h,
+        });
+        push({ from, to: id, state, ancestors });
+        push({ from: id, to: mergeId, state, ancestors });
+        armen++;
+    }
+    // ── Beslissingen: elke keuze een eigen tak ────────────────────────────────
+    for (const { field, group } of items) {
+        if (!isDecision(field))
+            continue;
+        const state = stateVan(field);
+        const id = `keuze:${ctx.step.storeId}:${field.key}`;
+        const value = ctx.values[field.key];
+        const options = optionsOf(field);
+        const current = currentOf(field, value);
+        const eigenMerge = `samen:${ctx.step.storeId}:${field.key}`;
+        const help = uitlegVoor(field, group, state);
+        help.push(`Mogelijke keuzes: ${options.map((o) => o.label).join(" · ")}. Kies je hier iets anders, dan wordt meteen een andere tak actief én werkt de engine daarna volgens die keuze.`);
+        verwijzingen(field, id, state, help);
+        ctx.nodes.push({
+            id,
+            kind: "decision",
+            label: field.label,
+            sublabel: group.label,
+            state,
+            stepId: ctx.step.id,
+            storeId: ctx.step.storeId,
+            fieldKey: field.key,
+            fieldKeys: [field.key],
+            options,
+            currentValue: current,
+            isBoolean: field.type === "toggle",
+            mergeId: eigenMerge,
+            ancestors,
+            help,
+            w: size.decision.w,
+            h: size.decision.h,
+        });
+        ctx.decisionIds.set(`${ctx.step.storeId}:${field.key}`, id);
+        push({ from, to: id, state, ancestors });
+        const kinderen = ctx.childrenOf.get(field.key) ?? [];
+        const takAncestors = [...ancestors, id];
+        // Takken: één per verzameling keuzes waar dezelfde kinderen onder hangen,
+        // zodat een instelling die bij "scanner" én "scan_only" geldt één vakje blijft.
+        const takken = new Map();
+        for (const k of kinderen) {
+            const waarden = options.map((o) => o.value).filter((v) => k.rule.in.some((r) => String(r) === v));
+            if (!waarden.length)
+                continue;
+            const sleutel = waarden.join("|");
+            const tak = takken.get(sleutel) ?? { waarden, kinderen: [] };
+            tak.kinderen.push(k);
+            takken.set(sleutel, tak);
+        }
+        const gedekt = new Set([...takken.values()].flatMap((t) => t.waarden));
+        const labelVan = (waarden) => waarden.map((v) => options.find((o) => o.value === v)?.label ?? v).join(" / ");
+        for (const option of options) {
+            if (gedekt.has(option.value))
+                continue;
+            // Keuze zonder eigen vervolg: een klein label-vakje, zodat alle uitkomsten
+            // naast elkaar zichtbaar blijven.
+            const optState = edgeState(state, option.value === current);
+            const optId = `optie:${ctx.step.storeId}:${field.key}:${option.value}`;
+            ctx.nodes.push({
+                id: optId,
+                kind: "option",
+                label: option.label,
+                state: optState,
+                stepId: ctx.step.id,
+                storeId: ctx.step.storeId,
+                fieldKey: field.key,
+                ancestors: takAncestors,
+                help: [
+                    `Uitkomst "${option.label}" van "${field.label}".`,
+                    optState === "active"
+                        ? "Dit is de keuze die nu geldt."
+                        : "Deze keuze geldt nu niet; kies hem in de beslistegel om deze tak actief te maken.",
+                    "Er hangen geen extra instellingen onder deze uitkomst; de route gaat direct verder.",
+                ],
+                w: size.option.w,
+                h: size.option.h,
+            });
+            push({ from: id, to: optId, state: optState, ancestors: takAncestors });
+            push({ from: optId, to: eigenMerge, state: optState, ancestors: takAncestors });
+        }
+        for (const [sleutel, tak] of takken) {
+            const takState = edgeState(state, tak.waarden.includes(current));
+            // Klein tussenpunt met het keuzelabel; daarachter waaieren de kinderen uit.
+            const takId = `tak:${ctx.step.storeId}:${field.key}:${sleutel}`;
+            ctx.nodes.push({
+                id: takId,
+                kind: "merge",
+                label: "",
+                state: takState,
+                ancestors: takAncestors,
+                help: [],
+                w: size.merge.w,
+                h: size.merge.h,
+            });
+            push({ from: id, to: takId, label: labelVan(tak.waarden), suffix: sleutel, state: takState, ancestors: takAncestors });
+            const sub = { ...ctx };
+            fan(sub, takId, takState, tak.kinderen, takAncestors, eigenMerge);
+        }
+        ctx.nodes.push({ id: eigenMerge, kind: "merge", label: "", state, ancestors, help: [], w: size.merge.w, h: size.merge.h });
+        push({ from: eigenMerge, to: mergeId, state, ancestors });
+        armen++;
+    }
+    if (armen === 0)
+        push({ from, to: mergeId, state: fromState, ancestors });
+}

package/dist-lib/lib/handlers/index.d.ts

@@ -1,2 +1,3 @@
 export { handleLogisticsTick } from "./logistics-tick.server.js";
+export { handleShippingNoteNow } from "./logistics-shipping-note-now.server.js";
 //# sourceMappingURL=index.d.ts.map

package/dist-lib/lib/handlers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC"}

package/dist-lib/lib/handlers/index.js

@@ -2,3 +2,4 @@
 // src/lib/handlers/index.ts — server-route handlers voor shells
 // ============================================================================
 export { handleLogisticsTick } from "./logistics-tick.server.js";
+export { handleShippingNoteNow } from "./logistics-shipping-note-now.server.js";

package/dist-lib/lib/handlers/logistics-shipping-note-now.server.d.ts

@@ -0,0 +1,3 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleShippingNoteNow(request: Request, supabase: SupabaseClient): Promise<Response>;
+//# sourceMappingURL=logistics-shipping-note-now.server.d.ts.map

package/dist-lib/lib/handlers/logistics-shipping-note-now.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logistics-shipping-note-now.server.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/logistics-shipping-note-now.server.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQ5D,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC,CAiGnB"}

package/dist-lib/lib/handlers/logistics-shipping-note-now.server.js

@@ -0,0 +1,100 @@
+// ============================================================================
+// src/lib/handlers/logistics-shipping-note-now.server.ts
+// Verzendbrief direct ophalen op het moment dat de pakbon naar het pickstation
+// wordt gestuurd, in plaats van te wachten op de volgende ronde van de cron.
+//
+// Alleen-lezen richting Floriday: er wordt geen status gewijzigd en geen order
+// of kar afgehandeld. Het maken van de printopdracht is idempotent, dus vaker
+// aanroepen levert nooit een dubbele verzendbrief op.
+// Geen omgevingswaarden in deze code: de sleutel komt uit de omgeving.
+// ============================================================================
+const CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "apikey, authorization, content-type",
+    "Access-Control-Allow-Methods": "POST, OPTIONS",
+};
+export async function handleShippingNoteNow(request, supabase) {
+    if (request.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: CORS_HEADERS });
+    }
+    const apikey = request.headers.get("apikey") ??
+        request.headers.get("authorization")?.replace(/^Bearer /i, "") ??
+        "";
+    const expected = (process.env["SUPABASE_PUBLISHABLE_KEY"] ??
+        process.env["SUPABASE_ANON_KEY"] ??
+        "").replace(/^["']|["']$/g, "");
+    if (!expected || apikey !== expected) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+            status: 401,
+            headers: { "Content-Type": "application/json", ...CORS_HEADERS },
+        });
+    }
+    try {
+        const { runShippingNoteQueue } = await import("../shippingNoteQueue.server.js");
+        if (typeof runShippingNoteQueue !== "function") {
+            throw new Error("Deze versie van de Logistiek Engine bevat geen verzendbriefverwerking. Werk de module bij.");
+        }
+        // 1. Inhaalslag: pakbonnen die nog geen verzendbriefaanvraag hebben er
+        //    alsnog bij zetten. Idempotent, dus nooit een tweede aanvraag.
+        let backfill = null;
+        try {
+            const { data } = await supabase.rpc("logistics_ensure_shipping_notes", { p_limit: 500 });
+            backfill = data ?? null;
+        }
+        catch {
+            backfill = null;
+        }
+        // 1b. Foutieve eigen verzendbrieven bij Floriday-orders opruimen.
+        try {
+            await supabase.rpc("logistics_fix_wrong_shipping_notes");
+        }
+        catch {
+            /* opschonen mag de ronde niet blokkeren */
+        }
+        // 2. Alle openstaande aanvragen mogen nu meteen worden opgepakt.
+        let wake = null;
+        try {
+            const { data } = await supabase.rpc("logistics_shipping_notes_wake_all");
+            wake = data ?? null;
+        }
+        catch {
+            wake = null;
+        }
+        // 3. Gebundeld verwerken tot alles op is of het tijdbudget vol is; de knop
+        //    hoeft niet te wachten tot de laatste ronde klaar is.
+        const totaal = { claimed: 0, printed: 0, waiting: 0, retrying: 0, failed: 0, errors: [] };
+        const deadline = Date.now() + 20000;
+        let rondes = 0;
+        while (Date.now() < deadline && rondes < 40) {
+            const ronde = await runShippingNoteQueue(supabase, { limit: 10 });
+            rondes++;
+            totaal.claimed += ronde.claimed;
+            totaal.printed += ronde.printed;
+            totaal.waiting += ronde.waiting;
+            totaal.retrying += ronde.retrying;
+            totaal.failed += ronde.failed;
+            if (Array.isArray(ronde.errors))
+                totaal.errors.push(...ronde.errors);
+            if (ronde.claimed === 0)
+                break;
+        }
+        return Response.json({
+            ok: true,
+            shippingNotes: {
+                found: totaal.claimed,
+                printed: totaal.printed,
+                waitingForFloriday: totaal.waiting,
+                retrying: totaal.retrying,
+                failed: totaal.failed,
+                printJobsCreated: totaal.printed,
+                rounds: rondes,
+                backfill,
+                wake,
+                errors: totaal.errors.slice(0, 20),
+            },
+        }, { headers: CORS_HEADERS });
+    }
+    catch (e) {
+        return Response.json({ ok: false, error: String(e?.message ?? e) }, { status: 500, headers: CORS_HEADERS });
+    }
+}

package/dist-lib/lib/handlers/logistics-tick.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logistics-tick.server.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/logistics-tick.server.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQ5D,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC,CA4KnB"}
+{"version":3,"file":"logistics-tick.server.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/logistics-tick.server.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQ5D,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC,CAuRnB"}