@flowselections/floriday-authenticatie-module 1.0.13 → 1.0.14

package/dist-lib/lib/floriday-sync.functions.js

@@ -1,16 +1,18 @@
 // ============================================================================
-// Floriday resource sync — trade-items, sales-orders, customer-organizations.
+// Floriday resource sync — alle sequence-based + full-list sync helpers.
 // ----------------------------------------------------------------------------
 // Bouwt voort op `syncFloridayEntityBySequence` uit floriday.functions.ts.
 // Iedere server fn is admin-only en kan zowel handmatig (UI) als via een
-// publieke cron-route worden aangeroepen. Voor cron-aanroepen wordt
-// `runFloridayResourceSync` direct met `supabaseAdmin` aangeroepen.
+// publieke cron-route worden aangeroepen.
 // ============================================================================
 import { createServerFn } from "@tanstack/react-start";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { FLORYDAY_CLOCK_SUPPLY_PERMISSION_MESSAGE, FLORYDAY_CONTRACT_PERMISSION_MESSAGE, } from "./floriday-scopes";
 import { SUPPLIERS_API_VERSION, getActiveFlorydayCredentials, resolveFlorydayCronBaseUrl, syncFloridayEntityBySequence, } from "./floriday.functions";
+const now = () => new Date().toISOString();
 const RESOURCE_CONFIG = {
     "trade-items": {
+        kind: "sequence",
         entityType: "trade-items",
         maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/trade-items/current-max-sequence`,
         bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/trade-items/sync`,
@@ -26,7 +28,7 @@ const RESOURCE_CONFIG = {
                     sequence_number: Number(item?.sequenceNumber ?? 0),
                     is_deleted: Boolean(item?.isDeleted),
                     data: item,
-                    fetched_at: new Date().toISOString(),
+                    fetched_at: now(),
                 };
             })
                 .filter(Boolean);
@@ -40,6 +42,7 @@ const RESOURCE_CONFIG = {
         },
     },
     "sales-orders": {
+        kind: "sequence",
         entityType: "sales-orders",
         maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/sales-orders/current-max-sequence`,
         bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/sales-orders/sync`,
@@ -57,7 +60,7 @@ const RESOURCE_CONFIG = {
                     is_deleted: Boolean(item?.isDeleted),
                     sequence_number: Number(item?.sequenceNumber ?? 0),
                     data: item,
-                    updated_at: new Date().toISOString(),
+                    updated_at: now(),
                 };
             })
                 .filter(Boolean);
@@ -70,27 +73,37 @@ const RESOURCE_CONFIG = {
                 throw new Error(`sales-orders upsert: ${error.message}`);
         },
     },
-    // De Suppliers API heeft geen /customer-organizations endpoint.
-    // Klantorganisaties komen uit /connections (elke connection = een
-    // klantorganisatie die aan deze supplier gekoppeld is).
     "customer-organizations": {
+        // Floriday-richtlijn: gebruik /organizations/sync (CUSTOMER-filter) i.p.v.
+        // per-id GET /organizations/{id}. Naam + GLN landen daardoor lokaal en
+        // de connections-sync hoeft geen aparte fetch meer te doen.
+        kind: "sequence",
         entityType: "customer-organizations",
-        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/connections/current-max-sequence`,
-        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/connections/sync`,
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/organizations/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/organizations/sync`,
         upsert: async (supabase, connectionId, items) => {
             const rows = items
                 .map((item) => {
-                const oid = item?.customerOrganizationId ??
-                    item?.organizationId ??
+                const orgType = item?.organizationType ?? item?.type ?? null;
+                if (orgType && orgType !== "CUSTOMER")
+                    return null;
+                const oid = item?.organizationId ??
+                    item?.customerOrganizationId ??
                     item?.id ??
                     null;
                 if (!oid)
                     return null;
+                const name = item?.name ?? item?.commercialName ?? item?.organizationName ?? null;
+                const gln = item?.companyGln ?? item?.gln ?? item?.glnCode ?? null;
                 return {
                     organization_id: String(oid),
                     connection_id: connectionId,
+                    name,
+                    gln_code: gln,
+                    is_deleted: Boolean(item?.isDeleted),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
                     data: item,
-                    fetched_at: new Date().toISOString(),
+                    fetched_at: now(),
                 };
             })
                 .filter(Boolean);
@@ -103,9 +116,8 @@ const RESOURCE_CONFIG = {
                 throw new Error(`customer-organizations upsert: ${error.message}`);
         },
     },
-    // Vervoerders zijn organisaties met OrganizationType = CARRIER.
-    // We hergebruiken het algemene /organizations endpoint en filteren in onBatch.
     "carriers": {
+        kind: "sequence",
         entityType: "carriers",
         maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/organizations/current-max-sequence`,
         bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/organizations/sync`,
@@ -118,10 +130,7 @@ const RESOURCE_CONFIG = {
                 const oid = item?.organizationId ?? item?.id ?? null;
                 if (!oid)
                     return null;
-                const name = item?.name ??
-                    item?.commercialName ??
-                    item?.organizationName ??
-                    null;
+                const name = item?.name ?? item?.commercialName ?? item?.organizationName ?? null;
                 const gln = item?.companyGln ?? item?.gln ?? item?.glnCode ?? null;
                 return {
                     organization_id: String(oid),
@@ -129,7 +138,7 @@ const RESOURCE_CONFIG = {
                     name,
                     gln_code: gln,
                     data: item,
-                    fetched_at: new Date().toISOString(),
+                    fetched_at: now(),
                 };
             })
                 .filter(Boolean);
@@ -142,17 +151,423 @@ const RESOURCE_CONFIG = {
                 throw new Error(`carriers upsert: ${error.message}`);
         },
     },
+    "fulfillment-orders": {
+        kind: "sequence",
+        entityType: "fulfillment-orders",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/fulfillment-orders/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/fulfillment-orders/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.fulfillmentOrderId ?? item?.id ?? null;
+                if (!fid)
+                    return null;
+                const auctionDateRaw = item?.auctionDate ?? item?.auctionDateTime ?? null;
+                const auctionDate = typeof auctionDateRaw === "string" ? auctionDateRaw.slice(0, 10) : null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    delivery_order_id: item?.deliveryOrderId ?? item?.auctionDeliveryOrderId ?? null,
+                    despatch_warehouse_id: item?.despatchWarehouseId ?? item?.fromWarehouseId ?? null,
+                    destination_warehouse_id: item?.destinationWarehouseId ?? item?.toWarehouseId ?? null,
+                    auction_date: auctionDate,
+                    latest_delivery_at: item?.latestDeliveryDateTime ?? item?.latestDeliveryAt ?? null,
+                    load_carrier_type: item?.loadCarrierType ?? item?.loadcarrierType ?? null,
+                    one_label_only: item?.oneLabelOnly ?? null,
+                    status: item?.status ?? item?.fulfillmentStatus ?? null,
+                    is_deleted: Boolean(item?.isDeleted),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_fulfillment_orders_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`fulfillment-orders upsert: ${error.message}`);
+        },
+    },
+    "customer-stickers": {
+        kind: "sequence",
+        entityType: "customer-stickers",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/customer-stickers/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/customer-stickers/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.customerStickerId ?? item?.stickerId ?? item?.id ?? null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sales_order_id: item?.salesOrderId ?? item?.salesOrderLineId ?? null,
+                    trade_item_id: item?.tradeItemId ?? null,
+                    quantity: typeof item?.quantity === "number" ? item.quantity : null,
+                    status: item?.status ?? null,
+                    is_deleted: Boolean(item?.isDeleted),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_customer_stickers_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`customer-stickers upsert: ${error.message}`);
+        },
+    },
+    "packings": {
+        // Floriday noemt verpakkingen in de Suppliers API "custom packages".
+        // Gebruik het voorgeschreven sequence-patroon: current-max-sequence + sync/{sequenceNumber}.
+        kind: "sequence",
+        entityType: "packings",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/custom-packages/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/custom-packages/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.customPackageId ?? item?.packingId ?? item?.id ?? null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    data: item,
+                    fetched_at: now(),
+                    updated_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_packings_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`packings upsert: ${error.message}`);
+        },
+    },
+    "clock-supplies": {
+        // Floriday Suppliers API 2026v1 noemt klokaanvoer "clock-supply-lines".
+        kind: "sequence",
+        entityType: "clock-supplies",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/clock-supply-lines/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/clock-supply-lines/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.clockSupplyLineId ??
+                    item?.clockSupplyId ??
+                    item?.supplyLineId ??
+                    item?.supplyId ??
+                    item?.id ??
+                    null;
+                if (!fid)
+                    return null;
+                const auctionDateRaw = item?.auctionDate ?? item?.auctionDateTime ?? null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    trade_item_id: item?.tradeItemId ?? null,
+                    auction_date: typeof auctionDateRaw === "string" ? auctionDateRaw.slice(0, 10) : null,
+                    status: item?.status ?? null,
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_clock_supplies_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`clock-supplies upsert: ${error.message}`);
+        },
+    },
+    "delivery-orders": {
+        // Floriday Daytrade-stroom: DeliveryOrders volgens sequence-richtlijn.
+        // Eerst /current-max-sequence, daarna in batches /sync/{n}.
+        kind: "sequence",
+        entityType: "delivery-orders",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/delivery-orders/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/delivery-orders/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.deliveryOrderId ?? item?.id ?? null;
+                if (!fid)
+                    return null;
+                const auctionDateRaw = item?.auctionDate ?? null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    trade_item_id: item?.tradeItemId ?? null,
+                    destination_warehouse_id: item?.destinationWarehouseId ?? item?.warehouseId ?? null,
+                    auction_date: typeof auctionDateRaw === "string" ? auctionDateRaw.slice(0, 10) : null,
+                    status: item?.status ?? null,
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_delivery_orders_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`delivery-orders upsert: ${error.message}`);
+        },
+    },
+    "clock-presales": {
+        // Floriday Suppliers API 2026v1 noemt klokvoorverkoop "clock-presales-supply-lines".
+        kind: "sequence",
+        entityType: "clock-presales",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/clock-presales-supply-lines/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/clock-presales-supply-lines/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.clockPresalesSupplyLineId ??
+                    item?.clockPresaleSupplyLineId ??
+                    item?.clockPresaleId ??
+                    item?.presaleId ??
+                    item?.id ??
+                    null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    clock_supply_id: item?.clockSupplyLineId ?? item?.clockSupplyId ?? null,
+                    buyer_organization_id: item?.buyerOrganizationId ?? null,
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_clock_presales_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`clock-presales upsert: ${error.message}`);
+        },
+    },
+    // Legacy resources (agreements, agreement-calloffs, trips, invoices) zijn
+    // verwijderd: de Floriday Suppliers API 2026v1 biedt voor deze entiteiten
+    // geen sequence-endpoints, waardoor sync-aanroepen consistent een 404
+    // "route-not-found" gaven. Worden niet meer beheerd door deze module.
+    // ── Master-data via sequence-sync (Floriday-richtlijn) ───────────────────
+    "warehouses": {
+        kind: "sequence",
+        entityType: "warehouses",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/warehouses/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/warehouses/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((w) => {
+                const fid = w?.warehouseId ?? w?.id ?? null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    name: w?.name ?? null,
+                    gln_code: w?.location?.gln ?? w?.location?.glnCode ?? w?.gln ?? null,
+                    is_default: Boolean(w?.isDefault),
+                    is_deleted: Boolean(w?.isDeleted),
+                    data: w,
+                    fetched_at: now(),
+                    updated_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_warehouses_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`warehouses upsert: ${error.message}`);
+        },
+    },
+    "delivery-locations": {
+        kind: "sequence",
+        entityType: "delivery-locations",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/delivery-locations/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/delivery-locations/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((d) => {
+                const fid = d?.deliveryLocationId ?? d?.id ?? null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    organization_id: d?.organizationId ?? d?.ownerOrganizationId ?? d?.buyerOrganizationId ?? null,
+                    floriday_id: String(fid),
+                    gln_code: d?.gln ?? d?.glnCode ?? null,
+                    name: d?.name ?? d?.locationName ?? null,
+                    is_deleted: Boolean(d?.isDeleted),
+                    data: d,
+                    fetched_at: now(),
+                    updated_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_delivery_locations_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`delivery-locations upsert: ${error.message}`);
+        },
+    },
+    "contracts": {
+        // Floriday Suppliers API 2026v1 noemt overeenkomsten "contracts".
+        // Sequence-richtlijn: eerst current-max-sequence, daarna /sync/{n}.
+        kind: "sequence",
+        entityType: "contracts",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/contracts/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/contracts/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.contractId ?? item?.id ?? null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_contracts_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`contracts upsert: ${error.message}`);
+        },
+    },
+    "blanket-orders": {
+        // Floriday "Blanket Orders" = contract-afroepen.
+        kind: "sequence",
+        entityType: "blanket-orders",
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}/blanket-orders/current-max-sequence`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}/blanket-orders/sync`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = item?.blanketOrderId ?? item?.id ?? null;
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    contract_id: item?.contractId ?? null,
+                    data: item,
+                    fetched_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from("floriday_blanket_orders_cache")
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`blanket-orders upsert: ${error.message}`);
+        },
+    },
+    // ── Stamdata voor productformulieren (centraal voor andere modules) ────
+    "additional-services": makeSimpleSeq("additional-services", "additional-services", "floriday_additional_services_cache", ["additionalServiceId"]),
+    "commercial-service-types": makeSimpleSeq("commercial-service-types", "commercial-service-types", "floriday_commercial_service_types_cache", ["commercialServiceTypeId"]),
+    "collections": makeSimpleSeq("collections", "collections", "floriday_collections_cache", ["collectionId"]),
+    "price-groups": makeSimpleSeq("price-groups", "price-groups", "floriday_price_groups_cache", ["priceGroupId"]),
+    "delivery-condition-sets": makeSimpleSeq("delivery-condition-sets", "delivery-condition-sets", "floriday_delivery_condition_sets_cache", ["deliveryConditionSetId"]),
+    // sales-strategies wijkt af van het standaardpatroon: gebruikt
+    // `/sync/max-sequence-number` i.p.v. `/current-max-sequence`.
+    "sales-strategies": makeSimpleSeq("sales-strategies", "sales-strategies", "floriday_sales_strategies_cache", ["salesStrategyId"], { maxSequencePath: "/sales-strategies/sync/max-sequence-number" }),
+    "base-items": makeSimpleSeq("base-items", "base-items", "floriday_base_items_cache", ["baseItemId"]),
+    "contract-trade-item-groups": makeSimpleSeq("contract-trade-item-groups", "contract-trade-item-groups", "floriday_contract_trade_item_groups_cache", ["contractTradeItemGroupId"]),
+    // NB: `trade-item-classifications` is GEEN Floriday Suppliers-resource (2026v1
+    // levert geen `/trade-item-classifications/*` endpoints — bevestigd met 404 op
+    // /current-max-sequence). VBN-productcodes en -karakteristieken komen uit
+    // Floricode en zijn beschikbaar via de Swagger-enums (gateway/schema +
+    // gateway/code-list). Daarom hier bewust geen sequence-sync.
 };
-/**
- * Runt een sequence-sync voor één resource binnen één Floriday-koppeling.
- * Kan zowel met de user-scoped (RLS) als met de admin-client worden
- * aangeroepen — de helper laat dat aan de caller over.
- */
+function makeSimpleSeq(entityType, apiPath, table, idFields, opts) {
+    const maxPath = opts?.maxSequencePath ?? `/${apiPath}/current-max-sequence`;
+    const seqBase = opts?.bySequencePathBase ?? `/${apiPath}/sync`;
+    return {
+        kind: "sequence",
+        entityType,
+        maxSequenceEndpoint: `/${SUPPLIERS_API_VERSION}${maxPath}`,
+        bySequenceEndpointBase: `/${SUPPLIERS_API_VERSION}${seqBase}`,
+        upsert: async (supabase, connectionId, items) => {
+            const rows = items
+                .map((item) => {
+                const fid = [...idFields, "id"].map((f) => item?.[f]).find((v) => v != null);
+                if (!fid)
+                    return null;
+                return {
+                    connection_id: connectionId,
+                    floriday_id: String(fid),
+                    sequence_number: Number(item?.sequenceNumber ?? 0),
+                    is_deleted: Boolean(item?.isDeleted),
+                    data: item,
+                    fetched_at: now(),
+                    updated_at: now(),
+                };
+            })
+                .filter(Boolean);
+            if (rows.length === 0)
+                return;
+            const { error } = await supabase
+                .from(table)
+                .upsert(rows, { onConflict: "connection_id,floriday_id" });
+            if (error)
+                throw new Error(`${entityType} upsert: ${error.message}`);
+        },
+    };
+}
 export async function runFloridayResourceSync(supabase, env, resource) {
     const row = await getActiveFlorydayCredentials(supabase, env);
     if (!row)
         throw new Error(`Geen actieve Floriday-koppeling voor ${env}`);
     const cfg = RESOURCE_CONFIG[resource];
+    if (cfg.kind === "full") {
+        return cfg.run(supabase, env, row.id);
+    }
     return syncFloridayEntityBySequence(supabase, env, row.id, {
         entityType: cfg.entityType,
         maxSequenceEndpoint: cfg.maxSequenceEndpoint,
@@ -172,9 +587,6 @@ async function requireAdmin(supabase, userId) {
     if (!data)
         throw new Error("Alleen admins mogen deze actie uitvoeren");
 }
-// NB: server fns MOETEN top-level createServerFn(...).handler(...) chains zijn,
-// anders strippt de TanStack server-fn Vite-plugin de handler-body niet en krijg
-// je op de client "Cannot read properties of undefined (reading 'rpc')".
 const envValidator = (input) => {
     if (!["staging", "live"].includes(input.environment)) {
         throw new Error("Ongeldige environment");
@@ -184,17 +596,38 @@ const envValidator = (input) => {
 async function runSyncHandler(context, environment, resource) {
     await requireAdmin(context.supabase, context.userId);
     try {
-        const result = await runFloridayResourceSync(context.supabase, environment, resource);
+        // Schrijfacties gaan via de admin-client zodat RLS op de cache-tabellen niet
+        // afgehandeld hoeft te worden voor authenticated users — identiek aan de
+        // cron-route die elke 5-15 minuten draait.
+        const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+        const result = await runFloridayResourceSync(supabaseAdmin, environment, resource);
         return { ok: true, resource, ...result };
     }
     catch (e) {
+        const rawMessage = e?.message ?? "Onbekende fout";
+        const lower = String(rawMessage).toLowerCase();
+        const policyDenied = lower.includes("policy evaluation failed") ||
+            lower.includes("access_denied") ||
+            lower.includes("403") ||
+            lower.includes("forbidden");
+        const isContractResource = resource === "contracts" ||
+            resource === "blanket-orders" ||
+            resource === "contract-trade-item-groups";
+        let message = rawMessage;
+        if (resource === "sales-strategies" && policyDenied) {
+            message = FLORYDAY_CLOCK_SUPPLY_PERMISSION_MESSAGE;
+        }
+        else if (isContractResource && policyDenied) {
+            message = FLORYDAY_CONTRACT_PERMISSION_MESSAGE;
+        }
         return {
             ok: false,
             resource,
-            error: e?.message ?? "Onbekende fout",
+            error: message,
         };
     }
 }
+// ─── Server fns — één per resource ──────────────────────────────────────────
 export const syncFlorydayTradeItems = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
     .inputValidator(envValidator)
@@ -211,6 +644,46 @@ export const syncFlorydayCarriers = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
     .inputValidator(envValidator)
     .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "carriers"));
+export const syncFlorydayFulfillmentOrders = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "fulfillment-orders"));
+export const syncFlorydayCustomerStickers = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "customer-stickers"));
+export const syncFlorydayWarehouses = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "warehouses"));
+export const syncFlorydayPackings = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "packings"));
+export const syncFlorydayDeliveryLocations = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "delivery-locations"));
+export const syncFlorydayClockSupplies = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "clock-supplies"));
+export const syncFlorydayDeliveryOrders = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "delivery-orders"));
+export const syncFlorydayClockPresales = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "clock-presales"));
+export const syncFlorydayContracts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "contracts"));
+export const syncFlorydayBlanketOrders = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "blanket-orders"));
 const SCHEDULER_SPECS = {
     "trade-items": {
         rpc: "schedule_floriday_trade_items_sync",
@@ -232,6 +705,96 @@ const SCHEDULER_SPECS = {
         path: "/api/public/cron/sync-floriday-carriers",
         jobname: "floriday-carriers-sync-twice-daily",
     },
+    "fulfillment-orders": {
+        rpc: "schedule_floriday_fulfillment_orders_sync",
+        path: "/api/public/cron/sync-floriday-fulfillment-orders",
+        jobname: "floriday-fulfillment-orders-sync-5min",
+    },
+    "customer-stickers": {
+        rpc: "schedule_floriday_customer_stickers_sync",
+        path: "/api/public/cron/sync-floriday-customer-stickers",
+        jobname: "floriday-customer-stickers-sync-5min",
+    },
+    "warehouses": {
+        rpc: "schedule_floriday_warehouses_sync",
+        path: "/api/public/cron/sync-floriday-warehouses",
+        jobname: "floriday-warehouses-sync-twice-daily",
+    },
+    "packings": {
+        rpc: "schedule_floriday_packings_sync",
+        path: "/api/public/cron/sync-floriday-packings",
+        jobname: "floriday-packings-sync-daily",
+    },
+    "delivery-locations": {
+        rpc: "schedule_floriday_delivery_locations_sync",
+        path: "/api/public/cron/sync-floriday-delivery-locations",
+        jobname: "floriday-delivery-locations-sync-twice-daily",
+    },
+    "clock-supplies": {
+        rpc: "schedule_floriday_clock_supplies_sync",
+        path: "/api/public/cron/sync-floriday-clock-supplies",
+        jobname: "floriday-clock-supplies-sync-5min",
+    },
+    "delivery-orders": {
+        rpc: "schedule_floriday_delivery_orders_sync",
+        path: "/api/public/cron/sync-floriday-delivery-orders",
+        jobname: "floriday-delivery-orders-sync-5min",
+    },
+    "clock-presales": {
+        rpc: "schedule_floriday_clock_presales_sync",
+        path: "/api/public/cron/sync-floriday-clock-presales",
+        jobname: "floriday-clock-presales-sync-5min",
+    },
+    "contracts": {
+        rpc: "schedule_floriday_contracts_sync",
+        path: "/api/public/cron/sync-floriday-contracts",
+        jobname: "floriday-contracts-sync-hourly",
+    },
+    "blanket-orders": {
+        rpc: "schedule_floriday_blanket_orders_sync",
+        path: "/api/public/cron/sync-floriday-blanket-orders",
+        jobname: "floriday-blanket-orders-sync-15min",
+    },
+    "additional-services": {
+        rpc: "schedule_floriday_additional_services_sync",
+        path: "/api/public/cron/sync-floriday-additional-services",
+        jobname: "floriday-additional-services-sync-hourly",
+    },
+    "commercial-service-types": {
+        rpc: "schedule_floriday_commercial_service_types_sync",
+        path: "/api/public/cron/sync-floriday-commercial-service-types",
+        jobname: "floriday-commercial-service-types-sync-hourly",
+    },
+    "collections": {
+        rpc: "schedule_floriday_collections_sync",
+        path: "/api/public/cron/sync-floriday-collections",
+        jobname: "floriday-collections-sync-hourly",
+    },
+    "price-groups": {
+        rpc: "schedule_floriday_price_groups_sync",
+        path: "/api/public/cron/sync-floriday-price-groups",
+        jobname: "floriday-price-groups-sync-hourly",
+    },
+    "delivery-condition-sets": {
+        rpc: "schedule_floriday_delivery_condition_sets_sync",
+        path: "/api/public/cron/sync-floriday-delivery-condition-sets",
+        jobname: "floriday-delivery-condition-sets-sync-hourly",
+    },
+    "sales-strategies": {
+        rpc: "schedule_floriday_sales_strategies_sync",
+        path: "/api/public/cron/sync-floriday-sales-strategies",
+        jobname: "floriday-sales-strategies-sync-hourly",
+    },
+    "base-items": {
+        rpc: "schedule_floriday_base_items_sync",
+        path: "/api/public/cron/sync-floriday-base-items",
+        jobname: "floriday-base-items-sync-hourly",
+    },
+    "contract-trade-item-groups": {
+        rpc: "schedule_floriday_contract_trade_item_groups_sync",
+        path: "/api/public/cron/sync-floriday-contract-trade-item-groups",
+        jobname: "floriday-contract-trade-item-groups-sync-hourly",
+    },
 };
 export async function scheduleFlorydayResourceSyncInternal(supabase, resource) {
     const apikey = process.env.SUPABASE_PUBLISHABLE_KEY ??
@@ -270,11 +833,12 @@ export const scheduleFlorydayCustomerOrganizationsSync = createServerFn({ method
 export const scheduleFlorydayCarriersSync = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => runScheduleHandler(context, "carriers"));
-/**
- * Geeft de actieve Floriday-koppeling van de huidige user terug, zonder
- * credentials. Bedoeld voor andere modules (bv. de Voorraad Module) die
- * de gedeelde tokenflow gebruiken en alleen meta-informatie nodig hebben.
- */
+export const scheduleFlorydayFulfillmentOrdersSync = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => runScheduleHandler(context, "fulfillment-orders"));
+export const scheduleFlorydayCustomerStickersSync = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => runScheduleHandler(context, "customer-stickers"));
 export const getActiveFlorydayPublic = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
@@ -304,3 +868,240 @@ export const getActiveFlorydayPublic = createServerFn({ method: "GET" })
         preferred_warehouse_name: row.preferred_warehouse_name ?? null,
     };
 });
+// ─── Server fns voor de nieuwe stamdata-resources ───────────────────────────
+export const syncFlorydayAdditionalServices = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "additional-services"));
+export const syncFlorydayCommercialServiceTypes = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "commercial-service-types"));
+export const syncFlorydayCollections = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "collections"));
+export const syncFlorydayPriceGroups = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "price-groups"));
+export const syncFlorydayDeliveryConditionSets = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "delivery-condition-sets"));
+export const syncFlorydaySalesStrategies = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "sales-strategies"));
+export const syncFlorydayBaseItems = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "base-items"));
+export const syncFlorydayContractTradeItemGroups = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => runSyncHandler(context, data.environment, "contract-trade-item-groups"));
+// Opmerking: `trade-item-classifications` is verwijderd als sync-resource. De
+// Floriday Suppliers API (2026v1) kent dit endpoint niet (404 op
+// /current-max-sequence). Classificatie-data leeft in de Swagger-enums en
+// wordt door consumers via `/api/public/gateway/schema` en
+// `/api/public/gateway/code-list` opgehaald.
+// ─── Referentiedata: JSON-schema (uit Swagger) + code-lijsten ───────────────
+//
+// De Floriday Suppliers API publiceert haar Swagger publiek; daarmee halen we
+// alle invoervelden + enums op voor het trade-item formulier. Andere modules
+// renderen formulieren op basis van dit schema en valideren tegen dezelfde
+// bron — geen handmatige duplicaten meer.
+const SWAGGER_URL_PER_ENV = {
+    staging: `https://api.staging.floriday.io/${SUPPLIERS_API_VERSION}/swagger/UUID/swagger.json`,
+    live: `https://api.floriday.io/${SUPPLIERS_API_VERSION}/swagger/GUID/swagger.json`,
+};
+// Schema-roots die we uit de Suppliers-Swagger oogsten. Door breed in te
+// gaan op alle write-body's worden álle relevante enums (Currency,
+// AuctionLocation, SalesUnit, Incoterm, …) automatisch in
+// `floriday_code_lists_cache` geland, zodat andere modules invoervelden
+// kunnen valideren zónder zelf Floriday aan te roepen.
+const SCHEMA_ROOTS = {
+    // Catalogus
+    "trade-item": "TradeItemBase",
+    "trade-item-variant": "TradeItemVariant",
+    // Klok-aanbod (publish/edit)
+    "add-clock-supply-line": "AddClockSupplyLineV2",
+    "edit-clock-supply-line": "EditClockSupplyLine",
+    "add-clock-presales-supply-line": "AddClockPresalesSupplyLine",
+    // Daghandel / delivery-orders (lees-schema bevat de enums)
+    "delivery-order": "DeliveryOrder",
+    // Fulfillment
+    "fulfillment-order-create": "FulfillmentOrderCreate",
+    "fulfillment-order-correction": "AddFulfillmentOrderCorrection",
+    "fulfillment-order-claim": "FulfillmentOrderClaim",
+    // Sales-order schrijfacties
+    "sales-order-correction": "AddSalesOrderCorrectionRequest",
+    "sales-order-correction-additional-service": "AddSalesOrderCorrectionRequestForAdditionalService",
+    "sales-order-delivery": "AddSalesOrderDelivery",
+    // Contracten / blanket-orders
+    "add-blanket-order": "AddBlanketOrder",
+    "edit-blanket-order": "EditBlanketOrder",
+    // Verpakkingen
+    "add-batch-packing-configuration": "AddBatchPackingConfiguration",
+    "add-collection-packing-configuration": "AddCollectionPackingConfiguration",
+    // Master-data + locaties (enums voor types/landen)
+    "organization": "Organization",
+    "custom-package": "CustomPackage",
+    "warehouse": "Warehouse",
+    "add-delivery-location": "AddDeliveryLocation",
+    "delivery-location": "DeliveryLocation",
+};
+function extractSchemaWithRefs(defs, rootName) {
+    const collected = {};
+    const enums = {};
+    const seen = new Set();
+    const walk = (name) => {
+        if (seen.has(name) || !defs[name])
+            return;
+        seen.add(name);
+        const def = defs[name];
+        collected[name] = def;
+        if (Array.isArray(def.enum)) {
+            enums[name] = def.enum.map((v) => String(v));
+        }
+        const props = def.properties || {};
+        for (const prop of Object.values(props)) {
+            const ref = prop?.$ref ?? prop?.items?.$ref ?? prop?.additionalProperties?.$ref;
+            if (typeof ref === "string") {
+                walk(ref.split("/").pop());
+            }
+        }
+    };
+    walk(rootName);
+    return {
+        schema: { rootName, definitions: collected },
+        enums,
+    };
+}
+async function fetchAndStoreFlorydayTradeItemSchema(supabase, env) {
+    const results = [];
+    let swaggerJson = null;
+    try {
+        const res = await fetch(SWAGGER_URL_PER_ENV[env], { cache: "no-store" });
+        if (!res.ok)
+            throw new Error(`Swagger HTTP ${res.status}`);
+        swaggerJson = await res.json();
+    }
+    catch (e) {
+        for (const resource of Object.keys(SCHEMA_ROOTS)) {
+            results.push({ resource, ok: false, error: `swagger fetch: ${e?.message ?? e}` });
+        }
+        return results;
+    }
+    const defs = swaggerJson.definitions ?? {};
+    for (const [resource, root] of Object.entries(SCHEMA_ROOTS)) {
+        try {
+            const { schema, enums } = extractSchemaWithRefs(defs, root);
+            const { error } = await supabase
+                .from("floriday_resource_schemas")
+                .upsert({
+                resource,
+                version: SUPPLIERS_API_VERSION,
+                schema,
+                enums,
+                source_url: SWAGGER_URL_PER_ENV[env],
+                fetched_at: new Date().toISOString(),
+            }, { onConflict: "resource,version" });
+            if (error)
+                throw new Error(error.message);
+            results.push({ resource, ok: true });
+        }
+        catch (e) {
+            results.push({ resource, ok: false, error: e?.message ?? String(e) });
+        }
+    }
+    return results;
+}
+// Code-lijsten worden per environment opgehaald uit de Floriday-bronnen.
+// 2026v1 levert codelijsten als enums via Swagger en daarnaast via separate
+// endpoints. De enums die in de Swagger staan worden hier ook als code-list
+// platgeslagen zodat andere modules niet hoeven te weten waar ze vandaan komen.
+async function refreshFlorydayCodeListsFromSchemas(supabase, env) {
+    const results = [];
+    const { data: schemaRows, error } = await supabase
+        .from("floriday_resource_schemas")
+        .select("enums")
+        .eq("version", SUPPLIERS_API_VERSION);
+    if (error) {
+        return [{ list_name: "*", count: 0, ok: false, error: error.message }];
+    }
+    const merged = {};
+    for (const row of (schemaRows ?? [])) {
+        const enums = (row?.enums ?? {});
+        for (const [name, values] of Object.entries(enums)) {
+            if (!merged[name])
+                merged[name] = [];
+            for (const v of values) {
+                if (!merged[name].includes(v))
+                    merged[name].push(v);
+            }
+        }
+    }
+    for (const [list_name, codes] of Object.entries(merged)) {
+        try {
+            const rows = codes.map((code) => ({
+                environment: env,
+                list_name,
+                code,
+                label: code,
+                payload: null,
+                updated_at: new Date().toISOString(),
+            }));
+            const { error: upErr } = await supabase
+                .from("floriday_code_lists_cache")
+                .upsert(rows, { onConflict: "environment,list_name,code" });
+            if (upErr)
+                throw new Error(upErr.message);
+            results.push({ list_name, count: codes.length, ok: true });
+        }
+        catch (e) {
+            results.push({
+                list_name,
+                count: 0,
+                ok: false,
+                error: e?.message ?? String(e),
+            });
+        }
+    }
+    return results;
+}
+export async function runFlorydayReferenceDataRefresh(supabase, env) {
+    const schemas = await fetchAndStoreFlorydayTradeItemSchema(supabase, env);
+    const codeLists = await refreshFlorydayCodeListsFromSchemas(supabase, env);
+    return { ok: true, schemas, codeLists };
+}
+export const refreshFlorydayReferenceData = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator(envValidator)
+    .handler(async ({ data, context }) => {
+    await requireAdmin(context.supabase, context.userId);
+    try {
+        const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+        return await runFlorydayReferenceDataRefresh(supabaseAdmin, data.environment);
+    }
+    catch (e) {
+        return { ok: false, error: e?.message ?? "Onbekende fout" };
+    }
+});
+export async function scheduleFlorydayReferenceDataRefreshInternal(supabase) {
+    const apikey = process.env.SUPABASE_PUBLISHABLE_KEY ?? process.env.VITE_SUPABASE_PUBLISHABLE_KEY;
+    if (!apikey)
+        throw new Error("Supabase anon key ontbreekt in server-env");
+    const url = `${resolveFlorydayCronBaseUrl()}/api/public/cron/refresh-floriday-reference-data`;
+    const { data, error } = await supabase.rpc("schedule_floriday_reference_data_refresh", { p_url: url, p_apikey: apikey });
+    if (error)
+        throw new Error(error.message);
+    return { ok: true, jobid: data, url };
+}
+export const scheduleFlorydayReferenceDataRefresh = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    await requireAdmin(context.supabase, context.userId);
+    return scheduleFlorydayReferenceDataRefreshInternal(context.supabase);
+});