@flowselections/floriday-verkoop-module 1.0.7 → 1.0.9

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

@@ -0,0 +1,210 @@
+// Public-read helpers (server functions) — used by all other modules.
+// Reads gaan via de lokale Supabase-cache; geen directe Floriday API-calls.
+import { createServerFn } from "@tanstack/react-start";
+import { z } from "zod";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+const EnvSchema = z.enum(["staging", "live"]);
+// Toegestane cache-entities en hun tabel-mapping.
+const ENTITY_TABLE = {
+    "sales-orders": "floriday_salesorders_cache",
+    "trade-items": "floriday_trade_items_cache",
+    "customer-organizations": "floriday_customers_cache",
+    carriers: "floriday_carriers_cache",
+    "fulfillment-orders": "floriday_fulfillment_orders_cache",
+    "delivery-orders": "floriday_delivery_orders_cache",
+    "clock-supplies": "floriday_clock_supplies_cache",
+    "clock-presales": "floriday_clock_presales_cache",
+    contracts: "floriday_contracts_cache",
+    "blanket-orders": "floriday_blanket_orders_cache",
+    warehouses: "floriday_warehouses_cache",
+    "delivery-locations": "floriday_delivery_locations_cache",
+    packings: "floriday_packings_cache",
+    connections: "floriday_connections_cache",
+    "customer-stickers": "floriday_customer_stickers_cache",
+    "additional-services": "floriday_additional_services_cache",
+    "commercial-service-types": "floriday_commercial_service_types_cache",
+    collections: "floriday_collections_cache",
+    "price-groups": "floriday_price_groups_cache",
+    "delivery-condition-sets": "floriday_delivery_condition_sets_cache",
+    "sales-strategies": "floriday_sales_strategies_cache",
+    "base-items": "floriday_base_items_cache",
+    "contract-trade-item-groups": "floriday_contract_trade_item_groups_cache",
+};
+const CachedListSchema = z.object({
+    environment: EnvSchema,
+    entity: z.string().min(1),
+    limit: z.number().int().positive().max(5000).optional(),
+});
+export const getFlorydayCachedList = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => CachedListSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const table = ENTITY_TABLE[data.entity];
+    if (!table) {
+        throw new Error(`Onbekende entity "${data.entity}" — toegestane waarden: ${Object.keys(ENTITY_TABLE).join(", ")}`);
+    }
+    const limit = data.limit ?? 1000;
+    let q = context.supabase.from(table).select("*").limit(limit);
+    // Most cache-tables have an is_deleted column; filter when present.
+    const hasIsDeleted = [
+        "floriday_salesorders_cache",
+        "floriday_trade_items_cache",
+    ].includes(table);
+    if (hasIsDeleted)
+        q = q.eq("is_deleted", false);
+    const { data: rows, error } = await q;
+    if (error)
+        throw new Error(`${table} lezen faalde: ${error.message}`);
+    return { entity: data.entity, rows: rows ?? [] };
+});
+const CodeListSchema = z.object({
+    environment: EnvSchema,
+    listName: z.string().min(1),
+});
+export const getFlorydayCodeList = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => CodeListSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const { data: rows, error } = await context.supabase
+        .from("floriday_code_lists_cache")
+        .select("code, label, payload")
+        .eq("environment", data.environment)
+        .eq("list_name", data.listName);
+    if (error)
+        throw new Error(`code-list lezen faalde: ${error.message}`);
+    return { listName: data.listName, items: rows ?? [] };
+});
+export const getFlorydayAllowedValues = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => CodeListSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const { data: rows, error } = await context.supabase
+        .from("floriday_code_lists_cache")
+        .select("code")
+        .eq("environment", data.environment)
+        .eq("list_name", data.listName);
+    if (error)
+        throw new Error(`allowed-values lezen faalde: ${error.message}`);
+    return { listName: data.listName, values: (rows ?? []).map((r) => String(r.code)) };
+});
+const AssertSchema = z.object({
+    environment: EnvSchema,
+    listName: z.string().min(1),
+    value: z.string(),
+});
+export const assertFlorydayValue = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => AssertSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const { data: rows, error } = await context.supabase
+        .from("floriday_code_lists_cache")
+        .select("code")
+        .eq("environment", data.environment)
+        .eq("list_name", data.listName);
+    if (error)
+        throw new Error(`assert lezen faalde: ${error.message}`);
+    const allowed = (rows ?? []).map((r) => String(r.code));
+    if (allowed.length === 0) {
+        return { ok: false, error: `Lijst "${data.listName}" leeg of niet gecached`, allowed };
+    }
+    if (allowed.includes(data.value))
+        return { ok: true, allowed };
+    return {
+        ok: false,
+        error: `Waarde "${data.value}" niet toegestaan in "${data.listName}"`,
+        allowed,
+    };
+});
+const VbnSchema = z.object({
+    environment: EnvSchema,
+    code: z.string().optional(),
+    search: z.string().optional(),
+});
+export const getFlorydayVbnProduct = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => VbnSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    let q = context.supabase
+        .from("floriday_code_lists_cache")
+        .select("code, label, payload")
+        .eq("environment", data.environment)
+        .eq("list_name", "vbn-products");
+    if (data.code)
+        q = q.eq("code", data.code);
+    else if (data.search)
+        q = q.ilike("label", `%${data.search}%`).limit(50);
+    else
+        q = q.limit(50);
+    const { data: rows, error } = await q;
+    if (error)
+        throw new Error(`vbn-products lezen faalde: ${error.message}`);
+    return { items: rows ?? [] };
+});
+const SchemaArgs = z.object({
+    resource: z.string().min(1),
+    version: z.string().optional(),
+});
+export const getFlorydayResourceSchema = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => SchemaArgs.parse(d))
+    .handler(async ({ data, context }) => {
+    let q = context.supabase
+        .from("floriday_resource_schemas")
+        .select("resource, version, schema, enums, fetched_at")
+        .eq("resource", data.resource);
+    if (data.version)
+        q = q.eq("version", data.version);
+    const { data: rows, error } = await q.order("fetched_at", { ascending: false }).limit(1);
+    if (error)
+        throw new Error(`resource-schema lezen faalde: ${error.message}`);
+    return rows?.[0] ?? null;
+});
+const SyncHealthSchema = z.object({
+    environment: EnvSchema,
+    resources: z.array(z.string()).min(1),
+});
+// Voor de FlorydaySyncHealthBanner — leest sync-state voor de actieve connectie
+// van de gevraagde environment en geeft per resource laatste sync-info terug.
+export const getFlorydaySyncHealth = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => SyncHealthSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const dbEnv = data.environment === "live" ? "production" : "staging";
+    const { data: conns } = await context.supabase
+        .from("floriday_connections")
+        .select("id")
+        .eq("environment", dbEnv)
+        .eq("is_active", true)
+        .limit(1);
+    const connectionId = (conns ?? [])[0]?.id ?? null;
+    if (!connectionId) {
+        return { connectionId: null, resources: [] };
+    }
+    // Map resource → entity_type used in floriday_sync_state.
+    const RES_TO_ENTITY = {
+        "sales-orders": "salesorders",
+        "trade-items": "tradeitems",
+        "customer-organizations": "customers",
+        "fulfillment-orders": "fulfillment-orders",
+    };
+    const { data: rows } = await context.supabase
+        .from("floriday_sync_state")
+        .select("entity_type, last_sequence_number, last_synced_at, last_success_at, last_error")
+        .eq("connection_id", connectionId);
+    const stateByEntity = new Map((rows ?? []).map((r) => [String(r.entity_type), r]));
+    return {
+        connectionId,
+        resources: data.resources.map((res) => {
+            const entity = RES_TO_ENTITY[res] ?? res;
+            const s = stateByEntity.get(entity) ?? null;
+            return {
+                resource: res,
+                entityType: entity,
+                lastSyncedAt: s?.last_synced_at ?? null,
+                lastSuccessAt: s?.last_success_at ?? null,
+                lastSequenceNumber: s?.last_sequence_number ?? null,
+                lastError: s?.last_error ?? null,
+            };
+        }),
+    };
+});

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

@@ -0,0 +1,32 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare const FLORIDAY_API_BASES: {
+    readonly staging: "https://api.staging.floriday.io/suppliers-api-2026v1";
+    readonly production: "https://api.floriday.io/suppliers-api-2026v1";
+};
+export interface FloridayConnectionRow {
+    id: string;
+    environment: string | null;
+    access_token: string | null;
+    api_key: string | null;
+    is_active: boolean | null;
+}
+export interface SyncOptions<TRow> {
+    connection: FloridayConnectionRow;
+    entityType: string;
+    maxEndpoint: string;
+    syncEndpointBase: string;
+    cacheTable: string;
+    conflictTarget: string;
+    mapRow: (record: any, connectionId: string) => TRow;
+}
+export interface SyncResult {
+    ok: boolean;
+    entityType: string;
+    connectionId: string;
+    synced: number;
+    fromSequence: number;
+    toSequence: number;
+}
+export declare function syncBySequence<TRow extends Record<string, any>>(supabase: SupabaseClient, opts: SyncOptions<TRow>): Promise<SyncResult>;
+export declare function loadActiveConnections(supabase: SupabaseClient): Promise<FloridayConnectionRow[]>;
+//# sourceMappingURL=floriday-sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-sync.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW,CAAC,IAAI;IAC/B,UAAU,EAAE,qBAAqB,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAkCD,wBAAsB,cAAc,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnE,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,GACtB,OAAO,CAAC,UAAU,CAAC,CA+FrB;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAOlC"}

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

@@ -0,0 +1,116 @@
+export const FLORIDAY_API_BASES = {
+    staging: "https://api.staging.floriday.io/suppliers-api-2026v1",
+    production: "https://api.floriday.io/suppliers-api-2026v1",
+};
+async function readLastSequence(supabase, connectionId, entityType) {
+    const { data } = await supabase
+        .from("floriday_sync_state")
+        .select("last_sequence_number")
+        .eq("connection_id", connectionId)
+        .eq("entity_type", entityType)
+        .maybeSingle();
+    const v = data?.last_sequence_number;
+    return typeof v === "number" ? v : Number(v ?? 0) || 0;
+}
+async function writeLastSequence(supabase, connectionId, entityType, lastSequenceNumber) {
+    await supabase.from("floriday_sync_state").upsert({
+        connection_id: connectionId,
+        entity_type: entityType,
+        last_sequence_number: lastSequenceNumber,
+        last_synced_at: new Date().toISOString(),
+    }, { onConflict: "connection_id,entity_type" });
+}
+export async function syncBySequence(supabase, opts) {
+    // Lazy import vermijdt circular dependency tussen sync en gateway.
+    const { florydayFetch } = await import("./floriday-gateway.server");
+    const { connection, entityType, maxEndpoint, syncEndpointBase, cacheTable, conflictTarget, mapRow } = opts;
+    let active = connection;
+    const maxCall = await florydayFetch(supabase, active, {
+        method: "GET",
+        path: maxEndpoint,
+    });
+    if (!maxCall.ok) {
+        throw new Error(`Floriday GET ${maxEndpoint} faalde [${maxCall.status}]: ${maxCall.rawText.slice(0, 400)}`);
+    }
+    active = maxCall.connection;
+    const maxRes = maxCall.data;
+    const maxSequence = Number((typeof maxRes === "number" ? maxRes : maxRes?.maxSequenceNumber ?? maxRes?.sequenceNumber ?? 0) ?? 0);
+    const fromSequence = await readLastSequence(supabase, active.id, entityType);
+    let cursor = fromSequence;
+    let synced = 0;
+    let safetyHops = 0;
+    const MAX_HOPS = 1000;
+    let effectiveMax = maxSequence;
+    while (cursor < effectiveMax && safetyHops < MAX_HOPS) {
+        safetyHops += 1;
+        const batchCall = await florydayFetch(supabase, active, {
+            method: "GET",
+            path: `${syncEndpointBase}/${cursor}`,
+        });
+        if (!batchCall.ok) {
+            throw new Error(`Floriday GET ${syncEndpointBase}/${cursor} faalde [${batchCall.status}]: ${batchCall.rawText.slice(0, 400)}`);
+        }
+        active = batchCall.connection;
+        const batch = batchCall.data;
+        let list = [];
+        let respSeq = null;
+        let respMaxSeq = null;
+        if (Array.isArray(batch)) {
+            list = batch;
+        }
+        else if (batch && typeof batch === "object") {
+            list = (batch.results ?? batch.items ?? batch.salesOrders ?? batch.data ?? []);
+            const s = Number(batch.sequenceNumber);
+            const m = Number(batch.maximumSequenceNumber);
+            if (Number.isFinite(s))
+                respSeq = s;
+            if (Number.isFinite(m))
+                respMaxSeq = m;
+        }
+        if (list.length > 0) {
+            const rows = list.map((r) => mapRow(r, active.id));
+            const { error: upErr } = await supabase.from(cacheTable).upsert(rows, { onConflict: conflictTarget });
+            if (upErr)
+                throw new Error(`Upsert ${cacheTable} faalde: ${upErr.message}`);
+            synced += list.length;
+        }
+        const seqs = list
+            .map((r) => Number(r?.sequenceNumber ?? 0))
+            .filter((n) => Number.isFinite(n));
+        const highestInList = seqs.length ? Math.max(...seqs) : -Infinity;
+        let nextCursor = cursor;
+        if (highestInList > cursor)
+            nextCursor = highestInList;
+        else if (respSeq !== null && respSeq > cursor)
+            nextCursor = respSeq;
+        else if (list.length === 0 && respMaxSeq !== null && respMaxSeq > cursor) {
+            nextCursor = respMaxSeq;
+        }
+        else if (list.length === 0) {
+            break;
+        }
+        if (nextCursor <= cursor)
+            break;
+        cursor = nextCursor;
+        await writeLastSequence(supabase, active.id, entityType, cursor);
+        if (respMaxSeq !== null && respMaxSeq > effectiveMax)
+            effectiveMax = respMaxSeq;
+    }
+    return {
+        ok: true,
+        entityType,
+        connectionId: active.id,
+        synced,
+        fromSequence,
+        toSequence: cursor,
+    };
+}
+export async function loadActiveConnections(supabase) {
+    const { data, error } = await supabase
+        .from("floriday_connections")
+        .select("id, environment, access_token, api_key, is_active")
+        .eq("is_active", true);
+    if (error)
+        throw new Error(`floriday_connections lezen faalde: ${error.message}`);
+    return (data ?? []);
+}