@flowselections/logistiek-engine 1.0.5 → 1.0.7

package/dist-lib/lib/planQueue.server.js

@@ -0,0 +1,124 @@
+// ============================================================================
+// src/lib/planQueue.server.ts — incrementele planning van nieuwe/gewijzigde orders
+// ============================================================================
+// De databasewachtrij `logistics_plan_queue` bevat orders die (opnieuw) moeten
+// worden ingedeeld. Deze module claimt een batch, plant per impactgroep en
+// draait daarna de dagniveau-stappen (taken inplannen, tellingen, capaciteit)
+// voor de geraakte dagen. Alles via de meegegeven Supabase-client, zodat de
+// module in elke shell werkt.
+// ============================================================================
+import { replanBufferInternal, replanOrderInternal } from "./loadCarrierPlanning.server.js";
+import { attachIndelingToTasks } from "./loadCarrierTaskSync.server.js";
+const EMPTY = {
+    claimed: 0,
+    planned: 0,
+    cartsCreated: 0,
+    skippedLocked: 0,
+    failed: 0,
+    errors: [],
+};
+/** Verwerkt één ronde van de planwachtrij. Idempotent en veilig bij parallelle runs. */
+export async function runPlanQueue(sb, options = {}) {
+    const result = { ...EMPTY, errors: [] };
+    const deadlineAt = options.deadlineAt ?? Date.now() + 15000;
+    const { data, error } = await sb.rpc("logistics_plan_claim", {
+        p_limit: options.limit ?? null,
+    });
+    if (error) {
+        result.failed++;
+        result.errors.push(error.message);
+        return result;
+    }
+    const rows = Array.isArray(data) ? data : [];
+    result.claimed = rows.length;
+    if (rows.length === 0)
+        return result;
+    // Voorkomt dat dezelfde buffer binnen één ronde meerdere keren wordt gepland.
+    const plannedBuffers = new Set();
+    const touchedDates = new Set();
+    for (const row of rows) {
+        if (Date.now() > deadlineAt) {
+            // Teruggeven aan de wachtrij; de volgende ronde pakt hem weer op.
+            await sb.rpc("logistics_plan_finish", { p_id: row.id, p_error: "deadline" });
+            continue;
+        }
+        try {
+            const { data: impact } = await sb.rpc("logistics_plan_impact_orders", {
+                p_order_id: row.order_id,
+            });
+            const group = Array.isArray(impact) ? impact : [];
+            for (const g of group) {
+                if (g.plan_date)
+                    touchedDates.add(String(g.plan_date).slice(0, 10));
+            }
+            const bufferId = group.find((g) => g.buffer_id)?.buffer_id ?? null;
+            if (bufferId) {
+                if (!plannedBuffers.has(bufferId)) {
+                    plannedBuffers.add(bufferId);
+                    const plan = await replanBufferInternal(sb, bufferId);
+                    if (plan.skipped === "locked") {
+                        result.skippedLocked++;
+                    }
+                    else {
+                        result.planned++;
+                        result.cartsCreated += Number(plan.cartsCreated ?? 0);
+                        await attachIndelingToTasks(sb, plan);
+                    }
+                }
+            }
+            else {
+                const plan = await replanOrderInternal(sb, row.order_id);
+                if (plan && plan.skipped !== "locked") {
+                    result.planned++;
+                    result.cartsCreated += Number(plan.cartsCreated ?? 0);
+                    await attachIndelingToTasks(sb, plan);
+                }
+                else if (plan?.skipped === "locked") {
+                    result.skippedLocked++;
+                }
+            }
+            // Orders zonder taken krijgen een order.received-event, zodat de
+            // taakdispatcher er taken van maakt.
+            for (const g of group.length > 0 ? group : [{ order_id: row.order_id }]) {
+                if (!g.order_id)
+                    continue;
+                await sb.rpc("logistics_plan_ensure_event", { p_order_id: g.order_id });
+            }
+            await sb.rpc("logistics_plan_finish", { p_id: row.id, p_error: null });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            result.failed++;
+            if (result.errors.length < 5)
+                result.errors.push(message);
+            await sb.rpc("logistics_plan_finish", { p_id: row.id, p_error: message });
+        }
+    }
+    if (result.planned > 0) {
+        await runDayLevelSteps(sb, touchedDates, result);
+    }
+    return result;
+}
+/** Dagniveau-stappen: taken inplannen, tellingen bijwerken en capaciteit controleren. */
+async function runDayLevelSteps(sb, dates, result) {
+    const sorted = [...dates].filter(Boolean).sort();
+    const today = new Date().toISOString().slice(0, 10);
+    const from = sorted[0] && sorted[0] < today ? sorted[0] : today;
+    const to = sorted.length > 0 ? sorted[sorted.length - 1] : today;
+    const calls = [
+        { fn: "logistics_schedule_tasks", args: {} },
+        { fn: "logistics_sync_task_carriers", args: { p_order_ref: null } },
+        { fn: "logistics_sync_pick_queue", args: {} },
+        { fn: "logistics_apply_document_layouts", args: {} },
+        { fn: "logistics_capacity_day_check", args: { p_from: from, p_to: to >= from ? to : from } },
+    ];
+    for (const call of calls) {
+        const { error } = await sb.rpc(call.fn, call.args);
+        if (error && result.errors.length < 10)
+            result.errors.push(`${call.fn}: ${error.message}`);
+    }
+}
+/** Ruimt afgeronde wachtrijrijen op volgens de ingestelde bewaartermijn. */
+export async function prunePlanQueue(sb) {
+    await sb.rpc("logistics_plan_prune");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowselections/logistiek-engine",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "flowselections": {
     "moduleId": "logistiek-engine",
     "pages": [