@flowselections/floriday-voorraad 1.0.29 → 1.0.31

package/dist-lib/lib/logistics-tasks.server.d.ts

@@ -0,0 +1,17 @@
+export declare const TASK_TYPE = "stock.reserve";
+export declare const MAX_ATTEMPTS = 8;
+export declare class PermanentTaskError extends Error {
+    readonly permanent = true;
+}
+export interface RunSummary {
+    claimed: number;
+    done: number;
+    retried: number;
+    failed: number;
+    shadow: number;
+    skipped: number;
+    durationMs: number;
+}
+export declare function runLogisticsTasks(): Promise<RunSummary>;
+export declare function maybeTickLogisticsTasks(): void;
+//# sourceMappingURL=logistics-tasks.server.d.ts.map

package/dist-lib/lib/logistics-tasks.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logistics-tasks.server.d.ts","sourceRoot":"","sources":["../../src/lib/logistics-tasks.server.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,SAAS,kBAAkB,CAAC;AACzC,eAAO,MAAM,YAAY,IAAI,CAAC;AAQ9B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,SAAS,QAAQ;CAC3B;AA0BD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AA0FD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CAuJ7D;AAgBD,wBAAgB,uBAAuB,IAAI,IAAI,CA2B9C"}

package/dist-lib/lib/logistics-tasks.server.js

@@ -0,0 +1,303 @@
+/**
+ * Achtergrondverwerking van Logistics Engine-taken (`stock.reserve`).
+ *
+ * De Engine plant; deze module voert uit. Er is GEEN UI meer: een cron roept
+ * elke minuut de hook `/api/public/hooks/logistics-tasks-run` aan, die deze
+ * runner start.
+ *
+ * Bulletproof-eigenschappen:
+ *  - Atomair claimen (`claim_logistics_tasks`, FOR UPDATE SKIP LOCKED), dus
+ *    nooit dubbele uitvoering bij overlappende runs of meerdere instanties.
+ *  - Vastgelopen taken (`in_progress` ouder dan 5 min) worden vanzelf herclaimd.
+ *  - Exponentiële backoff met jitter bij tijdelijke fouten; permanente fouten
+ *    stoppen direct.
+ *  - Idempotent: reserveringen worden op een absolute waarde gezet, nooit
+ *    opgeteld. Een herhaalde poging kan dus niet dubbeltellen.
+ *  - Harde tijdslimiet per run zodat de worker nooit zijn limiet overschrijdt.
+ *
+ * Server-only: dit bestand mag nooit vanuit componenten geïmporteerd worden.
+ */
+import { OWNER_MODULE, describeLoadCarriers, parseStockReservePlan, } from "./logistics-engine";
+export const TASK_TYPE = "stock.reserve";
+export const MAX_ATTEMPTS = 8;
+const BATCH_SIZE = 25;
+const STALE_MINUTES = 5;
+const RUN_BUDGET_MS = 25000;
+/** Wachttijd (minuten) per poging; laatste waarde geldt voor alle latere. */
+const BACKOFF_MINUTES = [1, 2, 4, 8, 15, 30];
+const ATTEMPT_LOG_LIMIT = 20;
+export class PermanentTaskError extends Error {
+    constructor() {
+        super(...arguments);
+        this.permanent = true;
+    }
+}
+function backoffMs(attempt) {
+    const idx = Math.min(Math.max(attempt - 1, 0), BACKOFF_MINUTES.length - 1);
+    const base = BACKOFF_MINUTES[idx] * 60000;
+    // Jitter (±20%) voorkomt dat veel taken tegelijk opnieuw losbarsten.
+    const jitter = base * 0.2 * (Math.random() * 2 - 1);
+    return Math.max(15000, Math.round(base + jitter));
+}
+function isPermanent(error) {
+    if (error instanceof PermanentTaskError)
+        return true;
+    const message = String(error?.message ?? error ?? "").toLowerCase();
+    return (message.includes("geen voorraadrij") ||
+        message.includes("ongeldige payload") ||
+        message.includes("stale_connection") ||
+        message.includes("no_active_floriday_connection"));
+}
+function errorMessage(error) {
+    const raw = error?.message ?? String(error ?? "onbekende fout");
+    return String(raw).slice(0, 500);
+}
+function appendAttempt(task, entry) {
+    const current = Array.isArray(task.attempt_log)
+        ? task.attempt_log
+        : [];
+    return [...current, entry].slice(-ATTEMPT_LOG_LIMIT);
+}
+/**
+ * Voert één geclaimde taak uit. Gooit bij mislukking; de caller bepaalt
+ * of er opnieuw geprobeerd wordt.
+ */
+async function executeTask(supabaseAdmin, task, connectionId) {
+    const plan = parseStockReservePlan(task.payload);
+    if (plan.lines.length === 0) {
+        return {
+            applied: false,
+            diff: [],
+            message: `Taak zonder regels (${describeLoadCarriers(plan.loadCarriers)}).`,
+        };
+    }
+    const keys = plan.lines.map((l) => l.tradeItemKey);
+    let query = supabaseAdmin
+        .from("trade_item_stock")
+        .select("trade_item_key,physical_stock,reserved_stock,connection_id")
+        .in("trade_item_key", keys);
+    if (connectionId)
+        query = query.eq("connection_id", connectionId);
+    const { data: rows, error: readError } = await query;
+    if (readError)
+        throw new Error(`voorraad lezen: ${readError.message}`);
+    const stock = (rows ?? []);
+    const diff = plan.lines.map((line) => {
+        const row = stock.find((r) => r.trade_item_key === line.tradeItemKey);
+        return {
+            tradeItemKey: line.tradeItemKey,
+            currentReserved: row?.reserved_stock ?? 0,
+            engineReserved: line.quantity,
+            delta: line.quantity - (row?.reserved_stock ?? 0),
+        };
+    });
+    if (task.shadow) {
+        return {
+            applied: false,
+            diff,
+            message: `Schaduwmodus: ${diff.length} regel(s) vergeleken, niets geschreven (${describeLoadCarriers(plan.loadCarriers)}).`,
+        };
+    }
+    for (const line of plan.lines) {
+        const row = stock.find((r) => r.trade_item_key === line.tradeItemKey);
+        if (!row) {
+            throw new PermanentTaskError(`Geen voorraadrij voor ${line.tradeItemKey}`);
+        }
+        // Absolute waarde: idempotent bij een herhaalde poging.
+        const { error } = await supabaseAdmin
+            .from("trade_item_stock")
+            .update({ reserved_stock: line.quantity })
+            .eq("connection_id", row.connection_id)
+            .eq("trade_item_key", line.tradeItemKey);
+        if (error)
+            throw new Error(`reservering ${line.tradeItemKey}: ${error.message}`);
+    }
+    return {
+        applied: true,
+        diff,
+        message: `${plan.lines.length} regel(s) gereserveerd (${describeLoadCarriers(plan.loadCarriers)}).`,
+    };
+}
+export async function runLogisticsTasks() {
+    const startedAt = Date.now();
+    const summary = {
+        claimed: 0,
+        done: 0,
+        retried: 0,
+        failed: 0,
+        shadow: 0,
+        skipped: 0,
+        durationMs: 0,
+    };
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Actieve koppeling is optioneel: zonder koppeling reserveren we op alle
+    // rijen van het artikel. Faalt de resolutie, dan blokkeren we niet.
+    let connectionId = null;
+    try {
+        const { resolveActiveFloridayConnection } = await import("./floriday-env.server");
+        connectionId = (await resolveActiveFloridayConnection(supabaseAdmin)).id;
+    }
+    catch {
+        connectionId = null;
+    }
+    const worker = `voorraad-${crypto.randomUUID().slice(0, 8)}`;
+    const { data: claimed, error: claimError } = await supabaseAdmin.rpc("claim_logistics_tasks", {
+        _owner_module: OWNER_MODULE,
+        _task_type: TASK_TYPE,
+        _worker: worker,
+        _limit: BATCH_SIZE,
+        _stale_minutes: STALE_MINUTES,
+    });
+    if (claimError)
+        throw new Error(`taken claimen: ${claimError.message}`);
+    const tasks = (claimed ?? []);
+    summary.claimed = tasks.length;
+    for (const task of tasks) {
+        if (Date.now() - startedAt > RUN_BUDGET_MS) {
+            // Tijdbudget op: taak teruggeven zodat de volgende run hem oppakt.
+            await supabaseAdmin
+                .from("logistics_tasks")
+                .update({
+                status: "planned",
+                claimed_by: null,
+                claimed_at: null,
+                next_attempt_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            })
+                .eq("id", task.id)
+                .eq("claimed_by", worker);
+            summary.skipped++;
+            continue;
+        }
+        const attempt = (task.attempts ?? 0) + 1;
+        const nowIso = new Date().toISOString();
+        try {
+            const result = await executeTask(supabaseAdmin, task, connectionId);
+            const log = appendAttempt(task, {
+                attempt,
+                at: nowIso,
+                ok: true,
+            });
+            await supabaseAdmin
+                .from("logistics_tasks")
+                .update({
+                status: "done",
+                attempts: attempt,
+                attempt_log: log,
+                last_error: null,
+                error: null,
+                next_attempt_at: null,
+                claimed_by: null,
+                claimed_at: null,
+                result: {
+                    taskId: task.id,
+                    applied: result.applied,
+                    shadow: task.shadow,
+                    diff: result.diff,
+                    message: result.message,
+                },
+                completed_at: nowIso,
+                updated_at: nowIso,
+            })
+                .eq("id", task.id);
+            if (task.shadow)
+                summary.shadow++;
+            summary.done++;
+        }
+        catch (e) {
+            const message = errorMessage(e);
+            const permanent = isPermanent(e);
+            const exhausted = attempt >= MAX_ATTEMPTS;
+            const log = appendAttempt(task, {
+                attempt,
+                at: nowIso,
+                ok: false,
+                error: message,
+                permanent,
+            });
+            if (permanent || exhausted) {
+                await supabaseAdmin
+                    .from("logistics_tasks")
+                    .update({
+                    status: "failed",
+                    attempts: attempt,
+                    attempt_log: log,
+                    last_error: message,
+                    error: message,
+                    next_attempt_at: null,
+                    claimed_by: null,
+                    claimed_at: null,
+                    completed_at: nowIso,
+                    updated_at: nowIso,
+                })
+                    .eq("id", task.id);
+                summary.failed++;
+                console.error(`[voorraad] taak ${task.id} definitief mislukt (poging ${attempt}): ${message}`);
+            }
+            else {
+                const next = new Date(Date.now() + backoffMs(attempt)).toISOString();
+                await supabaseAdmin
+                    .from("logistics_tasks")
+                    .update({
+                    status: "planned",
+                    attempts: attempt,
+                    attempt_log: log,
+                    last_error: message,
+                    error: message,
+                    next_attempt_at: next,
+                    claimed_by: null,
+                    claimed_at: null,
+                    updated_at: nowIso,
+                })
+                    .eq("id", task.id);
+                summary.retried++;
+                console.warn(`[voorraad] taak ${task.id} mislukt (poging ${attempt}), opnieuw om ${next}: ${message}`);
+            }
+        }
+    }
+    summary.durationMs = Date.now() - startedAt;
+    return summary;
+}
+/**
+ * Vangnet zonder cron.
+ *
+ * Kan pg_net de host (nog) niet bereiken — bijvoorbeeld direct nadat de module
+ * in een nieuwe shell is gehangen — dan blijven taken staan. Deze tick wordt
+ * fire-and-forget vanuit binnenkomende requests aangeroepen: hoogstens één keer
+ * per minuut, en alleen wanneer er daadwerkelijk taken openstaan.
+ * Volledig onzichtbaar voor de gebruiker en veilig, omdat de runner atomair
+ * claimt en idempotent is.
+ */
+const TICK_THROTTLE_MS = 60000;
+let lastTickAt = 0;
+let tickInFlight = false;
+export function maybeTickLogisticsTasks() {
+    const now = Date.now();
+    if (tickInFlight || now - lastTickAt < TICK_THROTTLE_MS)
+        return;
+    lastTickAt = now;
+    tickInFlight = true;
+    void (async () => {
+        try {
+            const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+            const { count, error } = await supabaseAdmin
+                .from("logistics_tasks")
+                .select("id", { count: "exact", head: true })
+                .eq("owner_module", OWNER_MODULE)
+                .eq("task_type", TASK_TYPE)
+                .eq("status", "planned")
+                .or(`next_attempt_at.is.null,next_attempt_at.lte.${new Date().toISOString()}`);
+            if (error)
+                throw new Error(error.message);
+            if (!count)
+                return;
+            await runLogisticsTasks();
+        }
+        catch (e) {
+            console.warn("[voorraad] achtergrond-tick mislukt:", e?.message ?? e);
+        }
+        finally {
+            tickInFlight = false;
+        }
+    })();
+}

package/dist-lib/lib/module-runtime-config.functions.d.ts

@@ -1,14 +1,2 @@
-export interface RegisterBaseUrlResult {
-    ok: boolean;
-    baseUrl: string | null;
-    changed: boolean;
-    reason?: string;
-}
-/**
- * Idempotent: schrijft alleen wanneer de waarde daadwerkelijk wijzigt.
- * Bewust zonder auth-middleware zodat de registratie ook tijdens SSR van een
- * publieke shell-pagina kan slagen; er wordt niets gelezen of teruggegeven
- * dat gevoelig is.
- */
-export declare const registerModuleBaseUrl: import("@tanstack/start-client-core").OptionalFetcher<undefined, undefined, Promise<RegisterBaseUrlResult>>;
+export declare const registerModuleBaseUrl: import("@tanstack/start-client-core").OptionalFetcher<undefined, undefined, Promise<import("./module-runtime.server").ModuleRegistrationResult>>;
 //# sourceMappingURL=module-runtime-config.functions.d.ts.map

package/dist-lib/lib/module-runtime-config.functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-runtime-config.functions.d.ts","sourceRoot":"","sources":["../../src/lib/module-runtime-config.functions.ts"],"names":[],"mappings":"AAsEA,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,6GAqCjC,CAAC"}
+{"version":3,"file":"module-runtime-config.functions.d.ts","sourceRoot":"","sources":["../../src/lib/module-runtime-config.functions.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,qBAAqB,kJAsBjC,CAAC"}

package/dist-lib/lib/module-runtime-config.functions.js

@@ -1,107 +1,31 @@
 /**
- * Zelf-registrerende basis-URL voor deze module.
+ * Server-functie die de module registreert in de database waarin hij draait.
  *
- * De cron-taak `run_floriday_continuous_stock_sync()` in Postgres bevat GEEN
- * hardgecodeerde host: hij leest `module_runtime_config.voorraad_base_url`.
- * Deze server-functie schrijft die waarde weg met de origin van de shell
- * waarin de module op dat moment draait, zodat de voorraadsync blijft werken
- * wanneer de module in een andere shell wordt gehangen.
- *
- * Resolutievolgorde:
- *   1. PUBLIC_BASE_URL (expliciet gezet)
- *   2. centrale Auth-module `/api/shell-host`
- *   3. origin van het inkomende request
+ * De echte logica staat in `module-runtime.server.ts`. Deze wrapper wordt
+ * tijdens SSR aangeroepen (zie `src/routes/__root.tsx`), zodat de cron-hosts
+ * kloppen zodra de module in een andere shell wordt gehangen — zonder UI en
+ * zonder handmatige instellingen.
  */
 import { createServerFn } from "@tanstack/react-start";
 import { getRequest } from "@tanstack/react-start/server";
-const CONFIG_KEY = "voorraad_base_url";
-function normalizeOrigin(raw) {
-    const trimmed = String(raw ?? "").trim();
-    if (!trimmed)
-        return null;
-    try {
-        const u = new URL(trimmed);
-        if (u.protocol !== "https:" && u.protocol !== "http:")
-            return null;
-        // Lokale dev-origins nooit registreren: pg_cron kan die niet bereiken.
-        const host = u.hostname.toLowerCase();
-        if (host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" || host.endsWith(".local")) {
-            return null;
-        }
-        return `${u.protocol}//${u.host}`;
-    }
-    catch {
-        return null;
-    }
-}
-async function resolveBaseUrl() {
-    const explicit = normalizeOrigin(process.env.PUBLIC_BASE_URL);
-    if (explicit)
-        return explicit;
-    // De hooks (/api/public/hooks/...) worden door DEZE module geserveerd,
-    // dus de origin van het inkomende request heeft voorrang op de shell-host.
+export const registerModuleBaseUrl = createServerFn({ method: "POST" }).handler(async () => {
+    const { registerModuleRuntime } = await import("./module-runtime.server");
+    let request = null;
     try {
-        const req = getRequest();
-        const fromRequest = normalizeOrigin(req?.url ?? null);
-        if (fromRequest)
-            return fromRequest;
-        const forwardedHost = req?.headers?.get("x-forwarded-host") ?? req?.headers?.get("host");
-        if (forwardedHost) {
-            const proto = req?.headers?.get("x-forwarded-proto") ?? "https";
-            const fromHeaders = normalizeOrigin(`${proto}://${forwardedHost}`);
-            if (fromHeaders)
-                return fromHeaders;
-        }
+        request = getRequest();
     }
     catch {
-        // geen request-context
+        request = null;
     }
+    const result = await registerModuleRuntime(request);
+    // Vangnet: mocht de cron (nog) niet aankomen, dan verwerkt de module zelf
+    // openstaande taken. Throttled tot maximaal één run per minuut.
     try {
-        const { getShellHost } = await import("./centralSecrets.server");
-        const host = normalizeOrigin(await getShellHost());
-        if (host)
-            return host;
+        const { maybeTickLogisticsTasks } = await import("./logistics-tasks.server");
+        maybeTickLogisticsTasks();
     }
     catch {
-        // centrale module niet bereikbaar
-    }
-    return null;
-}
-/**
- * Idempotent: schrijft alleen wanneer de waarde daadwerkelijk wijzigt.
- * Bewust zonder auth-middleware zodat de registratie ook tijdens SSR van een
- * publieke shell-pagina kan slagen; er wordt niets gelezen of teruggegeven
- * dat gevoelig is.
- */
-export const registerModuleBaseUrl = createServerFn({ method: "POST" }).handler(async () => {
-    const baseUrl = await resolveBaseUrl();
-    if (!baseUrl) {
-        return { ok: false, baseUrl: null, changed: false, reason: "geen origin resolvbaar" };
-    }
-    try {
-        const { supabaseAdmin } = await import("../integrations/supabase/client.server");
-        const { data: existing } = await supabaseAdmin
-            .from("module_runtime_config")
-            .select("value")
-            .eq("key", CONFIG_KEY)
-            .maybeSingle();
-        if (existing?.value === baseUrl) {
-            return { ok: true, baseUrl, changed: false };
-        }
-        const { error } = await supabaseAdmin
-            .from("module_runtime_config")
-            .upsert({ key: CONFIG_KEY, value: baseUrl }, { onConflict: "key" });
-        if (error) {
-            return { ok: false, baseUrl, changed: false, reason: error.message };
-        }
-        return { ok: true, baseUrl, changed: true };
-    }
-    catch (e) {
-        return {
-            ok: false,
-            baseUrl,
-            changed: false,
-            reason: e?.message ?? String(e),
-        };
+        // tick mag nooit de registratie laten falen
     }
+    return result;
 });

package/dist-lib/lib/module-runtime.server.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Zelfregistratie van de module in de database waarin hij draait.
+ *
+ * De cron-functies `run_logistics_tasks_dispatch()` en
+ * `run_floriday_continuous_stock_sync()` bevatten geen hardgecodeerde host:
+ * ze lezen `module_runtime_config.voorraad_base_url` en
+ * `module_runtime_config.voorraad_hook_apikey`. Dit bestand schrijft die twee
+ * waarden weg zodra de module ergens een request afhandelt, zodat de cron
+ * out-of-the-box werkt in elke shell/database waar de module wordt gehangen —
+ * zonder handmatige instellingen en zonder iets in de UI.
+ *
+ * Server-only: nooit importeren vanuit componenten of client-code.
+ */
+/**
+ * Resolutie met verificatie: de eerste kandidaat die de module daadwerkelijk
+ * bedient wint. Bedient geen enkele kandidaat de module, dan wordt er niets
+ * geregistreerd (de bestaande, werkende waarde blijft staan).
+ */
+export declare function resolveModuleBaseUrl(request?: Request | null): Promise<string | null>;
+export interface ModuleRegistrationResult {
+    ok: boolean;
+    baseUrl: string | null;
+    changed: boolean;
+    reason?: string;
+}
+/** Schrijft basis-URL + hook-apikey weg (idempotent, schrijft alleen bij wijziging). */
+export declare function registerModuleRuntime(request?: Request | null): Promise<ModuleRegistrationResult>;
+/**
+ * Fire-and-forget variant met throttle; veilig om bij élk request aan te roepen.
+ * Faalt nooit hard en logt alleen bij een echte fout.
+ */
+export declare function ensureModuleRuntimeRegistered(request?: Request | null): void;
+//# sourceMappingURL=module-runtime.server.d.ts.map

package/dist-lib/lib/module-runtime.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-runtime.server.d.ts","sourceRoot":"","sources":["../../src/lib/module-runtime.server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA2FH;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,GACvB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB;AAkCD,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wFAAwF;AACxF,wBAAsB,qBAAqB,CACzC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,GACvB,OAAO,CAAC,wBAAwB,CAAC,CAyBnC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAsB5E"}