@flowselections/floriday-verkoop-module 1.0.93 → 1.0.94

package/dist-lib/lib/floriday-auto-fulfillment.functions.js

@@ -0,0 +1,65 @@
+// Client-callable helpers around the auto-fulfillment log.
+import { createServerFn } from "@tanstack/react-start";
+import { z } from "zod";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware.js";
+export const getPreferredWarehouseStatus = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { supabase } = context;
+    const { data } = await supabase
+        .from("floriday_connections")
+        .select("id, preferred_warehouse_id")
+        .eq("is_active", true)
+        .limit(1)
+        .maybeSingle();
+    return {
+        hasPreferredWarehouse: Boolean(data?.preferred_warehouse_id),
+        connectionId: data?.id ?? null,
+    };
+});
+const SalesOrderSchema = z.object({ salesOrderId: z.string().min(1) });
+export const getAutoFulfillmentStatus = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => SalesOrderSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const { supabase } = context;
+    const { data: row } = await supabase
+        .from("floriday_auto_fulfillment_log")
+        .select("status, reason, error, fulfillment_order_id, attempts, last_attempt_at, updated_at")
+        .eq("sales_order_id", data.salesOrderId)
+        .order("updated_at", { ascending: false })
+        .limit(1)
+        .maybeSingle();
+    return { row: row ?? null };
+});
+export const retryAutoFulfillment = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => SalesOrderSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const { supabase, userId } = context;
+    const { data: isAdmin } = await supabase.rpc("has_role", {
+        _user_id: userId,
+        _role: "admin",
+    });
+    if (!isAdmin)
+        throw new Error("Alleen admins mogen fulfillment orders opnieuw aanmaken");
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
+    const { processOrderForAutoFulfillment } = await import("./floriday-auto-fulfillment.server.js");
+    const { data: order, error } = await supabaseAdmin
+        .from("floriday_salesorders_cache")
+        .select("connection_id, floriday_id, status, is_deleted, data")
+        .eq("floriday_id", data.salesOrderId)
+        .limit(1)
+        .maybeSingle();
+    if (error)
+        throw new Error(`Salesorder ophalen faalde: ${error.message}`);
+    if (!order)
+        throw new Error("Salesorder niet gevonden in cache");
+    // Force a fresh attempt: clear a prior 'created' guard so we re-run.
+    await supabaseAdmin.from("floriday_auto_fulfillment_log")
+        .update({ status: "pending", error: null })
+        .eq("connection_id", order.connection_id)
+        .eq("sales_order_id", order.floriday_id);
+    const result = await processOrderForAutoFulfillment(supabaseAdmin, order);
+    return result;
+});

package/dist-lib/lib/floriday-auto-fulfillment.server.d.ts

@@ -0,0 +1,21 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+type SalesOrderRow = {
+    connection_id: string;
+    floriday_id: string;
+    status: string | null;
+    is_deleted: boolean | null;
+    data: any;
+};
+export declare function processOrderForAutoFulfillment(supabase: SupabaseClient, order: SalesOrderRow): Promise<{
+    status: "created" | "skipped" | "failed";
+    reason?: string;
+    fulfillmentOrderId?: string;
+}>;
+export declare function processRecentSalesOrders(supabase: SupabaseClient, connectionId: string, sinceIso: string): Promise<{
+    processed: number;
+    created: number;
+    failed: number;
+    skipped: number;
+}>;
+export {};
+//# sourceMappingURL=floriday-auto-fulfillment.server.d.ts.map

package/dist-lib/lib/floriday-auto-fulfillment.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-auto-fulfillment.server.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-auto-fulfillment.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,KAAK,aAAa,GAAG;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,IAAI,EAAE,GAAG,CAAC;CACX,CAAC;AA4NF,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA+IrG;AAED,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CA2ElF"}

package/dist-lib/lib/floriday-auto-fulfillment.server.js

@@ -0,0 +1,352 @@
+import { florydayWrite } from "./floriday-gateway.server.js";
+async function loadConnectionMeta(supabase, connectionId) {
+    const { data } = await supabase
+        .from("floriday_connections")
+        .select("id, environment, api_key, is_active, gln_code, preferred_warehouse_id")
+        .eq("id", connectionId)
+        .maybeSingle();
+    return data ?? null;
+}
+async function loadProductPacking(supabase, tradeItemId) {
+    if (!tradeItemId)
+        return null;
+    const { data } = await supabase
+        .from("products")
+        .select("plants_per_crate, crates_per_layer, layers_per_cart")
+        .eq("trade_item_key", tradeItemId)
+        .limit(1)
+        .maybeSingle();
+    if (!data)
+        return null;
+    return {
+        plants_per_crate: Number(data.plants_per_crate) || 0,
+        crates_per_layer: Number(data.crates_per_layer) || 0,
+        layers_per_cart: Number(data.layers_per_cart) || 0,
+    };
+}
+function upsertLog(supabase, connectionId, salesOrderId, patch) {
+    return supabase.from("floriday_auto_fulfillment_log").upsert({
+        connection_id: connectionId,
+        sales_order_id: salesOrderId,
+        last_attempt_at: new Date().toISOString(),
+        ...patch,
+    }, { onConflict: "connection_id,sales_order_id" });
+}
+async function existingFulfillmentForOrder(supabase, connectionId, salesOrderId) {
+    // Scan the most recent fulfillment orders for this connection and look for
+    // a nested loadCarrierItems entry referencing this sales order.
+    const { data } = await supabase
+        .from("floriday_fulfillment_orders_cache")
+        .select("data")
+        .eq("connection_id", connectionId)
+        .order("fetched_at", { ascending: false })
+        .limit(500);
+    const rows = data ?? [];
+    for (const row of rows) {
+        const carriers = row?.data?.loadCarriers;
+        if (!Array.isArray(carriers))
+            continue;
+        for (const c of carriers) {
+            const items = c?.loadCarrierItems;
+            if (!Array.isArray(items))
+                continue;
+            for (const it of items) {
+                if (String(it?.salesOrderId ?? "") === salesOrderId)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+async function alreadyProcessed(supabase, connectionId, salesOrderId) {
+    const { data } = await supabase
+        .from("floriday_auto_fulfillment_log")
+        .select("status")
+        .eq("connection_id", connectionId)
+        .eq("sales_order_id", salesOrderId)
+        .maybeSingle();
+    return data?.status === "created";
+}
+async function loadDeliveryContext(supabase, connectionId, salesOrderId) {
+    const { data } = await supabase
+        .from("floriday_delivery_orders_cache")
+        .select("data")
+        .eq("connection_id", connectionId)
+        .eq("is_deleted", false)
+        .order("fetched_at", { ascending: false })
+        .limit(500);
+    const rows = data ?? [];
+    for (const row of rows) {
+        const d = row?.data;
+        const reqs = Array.isArray(d?.fulfillmentRequests) ? d.fulfillmentRequests : [];
+        const matching = [];
+        for (const r of reqs) {
+            if (String(r?.salesOrderId ?? "") !== salesOrderId)
+                continue;
+            matching.push({
+                fulfillmentRequestId: String(r?.fulfillmentRequestId ?? ""),
+                salesOrderId: String(r?.salesOrderId ?? ""),
+                loadCarrier: r?.loadCarrier ?? null,
+                numberOfPackages: Number(r?.numberOfPackages ?? 0) || 0,
+                deliveryRemarks: r?.deliveryRemarks ?? null,
+                tradeItemId: r?.tradeItemId ?? null,
+            });
+        }
+        if (matching.length > 0) {
+            return {
+                deliveryOrderId: String(d?.deliveryOrderId ?? ""),
+                despatchWarehouseId: d?.despatchWarehouseId ?? null,
+                destination: d?.destination ?? null,
+                latestDeliveryDateTime: d?.deliveryDateTime ?? null,
+                requests: matching,
+            };
+        }
+    }
+    return null;
+}
+function buildFulfillmentPayload(order, warehouseId, ctx) {
+    const warnings = [];
+    const supplierOrganizationId = String(order?.supplierOrganizationId ?? "");
+    const customerOrganizationId = String(order?.customerOrganizationId ?? "");
+    // Group requests by load-carrier type to build one loadCarrier per group.
+    const byCarrier = new Map();
+    for (const r of ctx.requests) {
+        const key = r.loadCarrier ?? "DANISH_TROLLEY";
+        if (!byCarrier.has(key))
+            byCarrier.set(key, []);
+        byCarrier.get(key).push(r);
+    }
+    const loadCarriers = [];
+    let sortIndex = 1;
+    for (const [carrier, requests] of byCarrier) {
+        loadCarriers.push({
+            sortIndex: sortIndex++,
+            loadCarrierType: carrier === "NONE" ? "DANISH_TROLLEY" : carrier,
+            numberOfAdditionalLayers: 0,
+            loadCarrierItems: requests.map((r, idx) => {
+                const item = {
+                    sortIndex: idx + 1,
+                    fulfillmentRequestId: r.fulfillmentRequestId,
+                    tradeItemId: r.tradeItemId ?? String(order?.tradeItemId ?? ""),
+                    salesOrderId: r.salesOrderId,
+                    numberOfPackages: r.numberOfPackages,
+                };
+                const remarks = (r.deliveryRemarks ?? "").toString().trim();
+                if (remarks)
+                    item.deliveryRemarks = remarks;
+                return item;
+            }),
+        });
+    }
+    const payload = {
+        fulfillmentOrderId: crypto.randomUUID(),
+        type: order?.tradeInstrument ?? "DIRECT_SALES",
+        despatchWarehouseId: warehouseId,
+        latestDeliveryDateTime: ctx.latestDeliveryDateTime ?? order?.delivery?.latestDeliveryDateTime ?? null,
+        supplierOrganizationId,
+        fulfillingOrganizationId: supplierOrganizationId,
+        destination: ctx.destination ?? {
+            organizationId: customerOrganizationId,
+            location: order?.delivery?.location ?? null,
+            warehouseId: null,
+        },
+        loadCarriers,
+        oneLabelOnly: false,
+    };
+    return { payload, warnings };
+}
+const SKIPPABLE_STATUSES = new Set(["REJECTED", "CANCELLED", "CANCELED", "EXPIRED"]);
+export async function processOrderForAutoFulfillment(supabase, order) {
+    const salesOrderId = order.floriday_id;
+    const connectionId = order.connection_id;
+    if (order.is_deleted) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "sales-order-deleted",
+        });
+        return { status: "skipped", reason: "sales-order-deleted" };
+    }
+    if (order.status && SKIPPABLE_STATUSES.has(String(order.status).toUpperCase())) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: `status-${order.status}`,
+        });
+        return { status: "skipped", reason: `status-${order.status}` };
+    }
+    if (await alreadyProcessed(supabase, connectionId, salesOrderId)) {
+        return { status: "skipped", reason: "already-created" };
+    }
+    if (await existingFulfillmentForOrder(supabase, connectionId, salesOrderId)) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "existing-fulfillment",
+        });
+        return { status: "skipped", reason: "existing-fulfillment" };
+    }
+    const conn = await loadConnectionMeta(supabase, connectionId);
+    if (!conn) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "failed",
+            error: "connection-not-found",
+        });
+        return { status: "failed", reason: "connection-not-found" };
+    }
+    // Warehouse fallback chain:
+    //   1) connection.preferred_warehouse_id
+    //   2) salesorder.data.despatchWarehouseId
+    //   3) first non-deleted warehouse from floriday_warehouses_cache
+    let warehouseId = conn.preferred_warehouse_id ?? null;
+    let warehouseFallback = null;
+    if (!warehouseId) {
+        const orderWarehouse = String(order.data?.despatchWarehouseId ?? "").trim();
+        if (orderWarehouse) {
+            warehouseId = orderWarehouse;
+            warehouseFallback = "warehouse-fallback:order";
+        }
+    }
+    if (!warehouseId) {
+        const { data: wh } = await supabase
+            .from("floriday_warehouses_cache")
+            .select("floriday_id, is_default")
+            .eq("connection_id", connectionId)
+            .eq("is_deleted", false)
+            .order("is_default", { ascending: false })
+            .limit(1)
+            .maybeSingle();
+        const cached = String(wh?.floriday_id ?? "").trim();
+        if (cached) {
+            warehouseId = cached;
+            warehouseFallback = "warehouse-fallback:cache";
+        }
+    }
+    if (!warehouseId) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "no-warehouse",
+        });
+        return { status: "skipped", reason: "no-warehouse" };
+    }
+    // Load Floriday-issued fulfillment requests from the matching delivery order.
+    const deliveryCtx = await loadDeliveryContext(supabase, connectionId, salesOrderId);
+    if (!deliveryCtx || deliveryCtx.requests.length === 0) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "no-delivery-order",
+        });
+        return { status: "skipped", reason: "no-delivery-order" };
+    }
+    // Prefer the delivery order's despatchWarehouseId when Floriday supplies it.
+    const effectiveWarehouseId = deliveryCtx.despatchWarehouseId || warehouseId;
+    const { payload, warnings } = buildFulfillmentPayload(order.data, effectiveWarehouseId, deliveryCtx);
+    if (warehouseFallback && !deliveryCtx.despatchWarehouseId)
+        warnings.push(warehouseFallback);
+    // Increment attempts.
+    const { data: existing } = await supabase
+        .from("floriday_auto_fulfillment_log")
+        .select("attempts")
+        .eq("connection_id", connectionId)
+        .eq("sales_order_id", salesOrderId)
+        .maybeSingle();
+    const attempts = Number(existing?.attempts ?? 0) + 1;
+    const env = (conn.environment === "production" || conn.environment === "live" ? "live" : "staging");
+    const result = await florydayWrite(supabase, env, {
+        module: "warehouse",
+        action: "add-fulfillment-order",
+        method: "POST",
+        path: "/fulfillment-orders",
+        referenceId: salesOrderId,
+        body: payload,
+    }, null);
+    if (!result.ok) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "failed",
+            attempts,
+            error: (result.error ?? `HTTP ${result.status}`).slice(0, 500),
+            reason: warnings.join(",") || null,
+        });
+        return { status: "failed", reason: result.error };
+    }
+    const fulfillmentOrderId = String(result.data?.fulfillmentOrderId ?? result.data?.id ?? payload.fulfillmentOrderId ?? "");
+    await upsertLog(supabase, connectionId, salesOrderId, {
+        status: "created",
+        attempts,
+        fulfillment_order_id: fulfillmentOrderId || null,
+        error: null,
+        reason: warnings.join(",") || null,
+    });
+    return { status: "created", fulfillmentOrderId };
+}
+export async function processRecentSalesOrders(supabase, connectionId, sinceIso) {
+    // 1) Recently synced / updated sales orders in this cycle.
+    const { data: recent } = await supabase
+        .from("floriday_salesorders_cache")
+        .select("connection_id, floriday_id, status, is_deleted, data, updated_at")
+        .eq("connection_id", connectionId)
+        .gte("updated_at", sinceIso)
+        .limit(200);
+    const rowMap = new Map();
+    for (const r of (recent ?? [])) {
+        rowMap.set(r.floriday_id, r);
+    }
+    // 2) Backlog: sales orders that never got a log row, or were previously
+    //    skipped/failed because the preferred warehouse wasn't set yet.
+    const { data: allOrders } = await supabase
+        .from("floriday_salesorders_cache")
+        .select("connection_id, floriday_id, status, is_deleted, data")
+        .eq("connection_id", connectionId)
+        .eq("is_deleted", false)
+        .limit(500);
+    const orderList = allOrders ?? [];
+    if (orderList.length > 0) {
+        const ids = orderList.map((o) => o.floriday_id);
+        const { data: logs } = await supabase
+            .from("floriday_auto_fulfillment_log")
+            .select("sales_order_id, status, reason")
+            .eq("connection_id", connectionId)
+            .in("sales_order_id", ids);
+        const logMap = new Map();
+        for (const l of (logs ?? [])) {
+            logMap.set(l.sales_order_id, { status: l.status, reason: l.reason });
+        }
+        for (const o of orderList) {
+            const existing = logMap.get(o.floriday_id);
+            if (!existing) {
+                rowMap.set(o.floriday_id, o);
+                continue;
+            }
+            if (existing.status === "failed") {
+                rowMap.set(o.floriday_id, o);
+                continue;
+            }
+            if (existing.status === "skipped" &&
+                (existing.reason === "no-preferred-warehouse" ||
+                    existing.reason === "no-warehouse" ||
+                    existing.reason === "no-delivery-order")) {
+                rowMap.set(o.floriday_id, o);
+            }
+        }
+    }
+    const rows = Array.from(rowMap.values());
+    let created = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const row of rows) {
+        try {
+            const r = await processOrderForAutoFulfillment(supabase, row);
+            if (r.status === "created")
+                created++;
+            else if (r.status === "failed")
+                failed++;
+            else
+                skipped++;
+        }
+        catch (err) {
+            failed++;
+            await upsertLog(supabase, row.connection_id, row.floriday_id, {
+                status: "failed",
+                error: err.message?.slice(0, 500) ?? "unknown error",
+            });
+        }
+    }
+    return { processed: rows.length, created, failed, skipped };
+}

package/dist-lib/lib/floriday-status-sync.server.d.ts

@@ -0,0 +1,14 @@
+type SyncAction = "commit" | "cancel" | null;
+/** Welke Floriday-actie hoort bij onze opgeslagen status? */
+export declare function actionForStatus(status: string): SyncAction;
+export interface StatusPushResult {
+    ok: boolean;
+    processed: number;
+    pushed: number;
+    skipped: number;
+    failed: number;
+    errors: string[];
+}
+export declare function pushOrderStatusesToFloriday(limit?: number): Promise<StatusPushResult>;
+export {};
+//# sourceMappingURL=floriday-status-sync.server.d.ts.map

package/dist-lib/lib/floriday-status-sync.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-status-sync.server.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-status-sync.server.ts"],"names":[],"mappings":"AAWA,KAAK,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;AAW7C,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAM1D;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAsB,2BAA2B,CAC/C,KAAK,SAAM,GACV,OAAO,CAAC,gBAAgB,CAAC,CAuH3B"}

package/dist-lib/lib/floriday-status-sync.server.js

@@ -0,0 +1,130 @@
+// Statuswijzigingen uit ons ERP doorzetten naar Floriday.
+//
+// Floriday kent voor een verkooporder maar twee schrijfacties op de status:
+//   PATCH /sales-orders/{id}/commit  (ACCEPTED -> COMMITTED)
+//   PATCH /sales-orders/{id}/cancel  (ACCEPTED -> CANCELLED)
+// Verzending/levering gaat in Floriday niet via de verkooporder maar via
+// fulfillment-orders (afleverbrieven); dat blijft de bestaande route.
+//
+// Geen omgevingswaarden in deze module: environment en sleutels komen uit
+// floriday_connections / de centrale auth-module.
+const CANCEL_STATUSES = new Set([
+    "geannuleerd",
+    "cancelled",
+    "canceled",
+    "vervallen",
+    "afgewezen",
+    "rejected",
+]);
+/** Welke Floriday-actie hoort bij onze opgeslagen status? */
+export function actionForStatus(status) {
+    const s = String(status ?? "").trim().toLowerCase();
+    if (CANCEL_STATUSES.has(s))
+        return "cancel";
+    // Alle overige werkstatussen betekenen: wij gaan hem leveren.
+    if (s.length === 0)
+        return null;
+    return "commit";
+}
+export async function pushOrderStatusesToFloriday(limit = 100) {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
+    const { florydayWrite } = await import("./floriday-gateway.server.js");
+    const result = {
+        ok: true,
+        processed: 0,
+        pushed: 0,
+        skipped: 0,
+        failed: 0,
+        errors: [],
+    };
+    const { data: queue, error: qErr } = await supabaseAdmin
+        .from("floriday_status_sync_queue")
+        .select("order_id, floriday_sales_order_id, target_status, attempts")
+        .eq("state", "pending")
+        .order("requested_at", { ascending: true })
+        .limit(Math.min(500, Math.max(1, limit)));
+    if (qErr)
+        throw new Error(`statuswachtrij lezen faalde: ${qErr.message}`);
+    if (!queue || queue.length === 0)
+        return result;
+    // Actieve Floriday-connectie bepaalt de omgeving. Ontbreekt die, dan stoppen
+    // we bewust met een duidelijke fout in plaats van een aanname.
+    const { data: conn } = await supabaseAdmin
+        .from("floriday_connections")
+        .select("environment")
+        .eq("is_active", true)
+        .limit(1)
+        .maybeSingle();
+    const environment = conn?.environment
+        ? String(conn.environment).toLowerCase() === "production" ||
+            String(conn.environment).toLowerCase() === "live"
+            ? "live"
+            : "staging"
+        : null;
+    if (!environment) {
+        throw new Error("Geen actieve Floriday-connectie gevonden; statuswijzigingen worden niet verstuurd.");
+    }
+    const salesOrderIds = queue.map((q) => String(q.floriday_sales_order_id));
+    const { data: cached } = await supabaseAdmin
+        .from("floriday_salesorders_cache")
+        .select("sales_order_id, data")
+        .in("sales_order_id", salesOrderIds);
+    const floridayStatusById = new Map();
+    for (const row of cached ?? []) {
+        const status = String((row.data ?? {})?.status ?? "").toUpperCase();
+        floridayStatusById.set(String(row.sales_order_id), status);
+    }
+    for (const item of queue) {
+        result.processed += 1;
+        const orderId = String(item.order_id);
+        const salesOrderId = String(item.floriday_sales_order_id);
+        const action = actionForStatus(String(item.target_status ?? ""));
+        const currentFloriday = floridayStatusById.get(salesOrderId) ?? "";
+        const markDone = async (state, error) => {
+            await supabaseAdmin.from("floriday_status_sync_queue")
+                .update({
+                state,
+                error,
+                attempts: Number(item.attempts ?? 0) + 1,
+                processed_at: new Date().toISOString(),
+            })
+                .eq("order_id", orderId);
+        };
+        if (!action) {
+            result.skipped += 1;
+            await markDone("skipped", "Geen Floriday-actie voor deze status");
+            continue;
+        }
+        // Floriday accepteert commit/cancel alleen vanuit ACCEPTED. Staat de order
+        // daar al verder, dan is er niets te doen (en is dat geen fout).
+        if (currentFloriday && currentFloriday !== "ACCEPTED") {
+            const alreadyThere = (action === "cancel" && currentFloriday === "CANCELLED") ||
+                (action === "commit" && currentFloriday === "COMMITTED");
+            result.skipped += 1;
+            await markDone(alreadyThere ? "done" : "skipped", alreadyThere
+                ? null
+                : `Floriday-status is ${currentFloriday}; ${action} is daar niet meer toegestaan`);
+            continue;
+        }
+        const res = await florydayWrite(supabaseAdmin, environment, {
+            module: "sales",
+            action: `sales-order-${action}`,
+            method: "PATCH",
+            path: `/sales-orders/${encodeURIComponent(salesOrderId)}/${action}`,
+            referenceId: salesOrderId,
+        }, null);
+        if (res.ok) {
+            result.pushed += 1;
+            await markDone("done", null);
+        }
+        else {
+            result.failed += 1;
+            const msg = `${salesOrderId}: ${res.error ?? `HTTP ${res.status}`}`;
+            result.errors.push(msg);
+            await markDone("failed", msg.slice(0, 500));
+        }
+    }
+    if (result.failed > 0)
+        result.ok = false;
+    return result;
+}