@flowselections/floriday-voorraad 1.0.12 → 1.0.14

package/dist-lib/hooks/useFloriday.js

@@ -0,0 +1,298 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect } from "react";
+import { gatewaySchemaFn, gatewayCodeListFn, gatewayCachedListFn, } from "../lib/floriday-gateway.functions";
+import { unmappedRequiredFields } from "../lib/wizard-step-fields";
+import { useFloridayConnection } from "./useFloridayConnection";
+import { normalizeFloridayEnvironment } from "../lib/floriday-env";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function arrayFromCodeListValue(value) {
+    if (Array.isArray(value))
+        return value;
+    if (!isRecord(value))
+        return [];
+    const candidates = [
+        value.values,
+        value.items,
+        value.rows,
+        value.data,
+        value.payload,
+        value.entries,
+    ];
+    for (const c of candidates) {
+        if (Array.isArray(c))
+            return c;
+    }
+    // Sommige gateway-implementaties geven een codelijst als dictionary terug:
+    // { "S62": { description: "..." }, "S98": "..." }. Maak daar alsnog
+    // entries van. Een object dat zelf één entry is (heeft code/id/value) laten
+    // we ongemoeid om dubbele parsing te voorkomen.
+    if (value.code != null || value.id != null || value.value != null)
+        return [value];
+    return Object.entries(value).map(([code, entry]) => isRecord(entry) ? { code, ...entry } : { code, label: entry });
+}
+function canonicalCodeListName(name) {
+    const kebab = name
+        .trim()
+        .replace(/_/g, "-")
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLowerCase();
+    const aliases = {
+        vbnproductgroup: "vbn-product-group",
+        "vbn-productgroup": "vbn-product-group",
+        "vbn-product-groups": "vbn-product-group",
+        characteristics: "characteristic",
+        "characteristic-type": "characteristic",
+        "characteristic-types": "characteristic",
+        packagingtype: "packaging-type",
+        countryoforigin: "country-of-origin",
+        lengthunit: "length-unit",
+    };
+    return aliases[kebab] ?? aliases[kebab.replace(/-/g, "")] ?? kebab;
+}
+function pickCode(value) {
+    if (!isRecord(value))
+        return String(value ?? "").trim();
+    const payload = isRecord(value.payload) ? value.payload : isRecord(value.data) ? value.data : undefined;
+    const raw = value.code ??
+        value.id ??
+        value.value ??
+        value.vbnProductCode ??
+        value.productCode ??
+        value.vbnCode ??
+        value.record_id ??
+        payload?.code ??
+        payload?.id ??
+        payload?.vbnProductCode ??
+        payload?.productCode ??
+        payload?.vbnCode ??
+        payload?.record_id;
+    return String(raw ?? "").trim();
+}
+function pickLabel(value, code) {
+    if (!isRecord(value))
+        return code || String(value ?? "").trim() || null;
+    const payload = isRecord(value.payload) ? value.payload : isRecord(value.data) ? value.data : undefined;
+    const raw = value.label ??
+        value.description ??
+        value.name ??
+        value.displayName ??
+        value.title ??
+        payload?.label ??
+        payload?.description ??
+        payload?.name ??
+        payload?.displayName ??
+        payload?.title;
+    return raw == null ? (code || null) : String(raw);
+}
+function normalizeCodeListEntries(value) {
+    return arrayFromCodeListValue(value)
+        .map((entry) => {
+        const code = pickCode(entry);
+        if (!code)
+            return null;
+        const label = pickLabel(entry, code);
+        const payload = isRecord(entry)
+            ? entry.payload ?? entry.data ?? entry
+            : entry;
+        return { code, label, description: label, payload };
+    })
+        .filter(Boolean);
+}
+function normalizeCodeLists(raw) {
+    const root = isRecord(raw) ? raw : {};
+    const data = isRecord(root.data) ? root.data : undefined;
+    const payload = isRecord(root.payload) ? root.payload : undefined;
+    const result = isRecord(root.result) ? root.result : undefined;
+    const included = isRecord(root.included) ? root.included : undefined;
+    const containers = [
+        root.codeLists,
+        root.code_lists,
+        root.includedCodeLists,
+        root.included_code_lists,
+        data?.codeLists,
+        data?.code_lists,
+        data?.includedCodeLists,
+        data?.included_code_lists,
+        isRecord(data?.payload) ? data?.payload?.codeLists ?? data?.payload?.code_lists : undefined,
+        payload?.codeLists,
+        payload?.code_lists,
+        result?.codeLists,
+        result?.code_lists,
+        included?.codeLists,
+        included?.code_lists,
+    ];
+    const out = {};
+    for (const container of containers) {
+        if (Array.isArray(container)) {
+            for (const list of container) {
+                if (!isRecord(list))
+                    continue;
+                const name = canonicalCodeListName(String(list.name ?? list.listName ?? list.key ?? list.resource ?? ""));
+                if (!name)
+                    continue;
+                const entries = normalizeCodeListEntries(list.values ?? list.items ?? list.rows ?? list.data ?? list.payload);
+                if (entries.length)
+                    out[name] = entries;
+            }
+            continue;
+        }
+        if (!isRecord(container))
+            continue;
+        for (const [name, value] of Object.entries(container)) {
+            const canonicalName = canonicalCodeListName(name);
+            const entries = normalizeCodeListEntries(value);
+            if (entries.length)
+                out[canonicalName] = entries;
+        }
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function normalizeSchemaResponse(raw) {
+    const root = isRecord(raw) ? raw : {};
+    const data = isRecord(root.data) ? root.data : undefined;
+    const payload = isRecord(root.payload) ? root.payload : undefined;
+    const source = data && (data.fields || data.requiredFields || data.schema || data.enums || data.codeLists || data.code_lists)
+        ? data
+        : payload && (payload.fields || payload.requiredFields || payload.schema || payload.enums || payload.codeLists || payload.code_lists)
+            ? payload
+            : root;
+    const rawSchema = source.schema ?? source.jsonSchema ?? source.openApiSchema ?? source.swaggerSchema;
+    const codeLists = normalizeCodeLists(raw);
+    return {
+        ...source,
+        ok: Boolean(root.ok ?? source.ok),
+        resource: String(source.resource ?? root.resource ?? "trade-item"),
+        version: String(source.version ?? root.version ?? ""),
+        requiredFields: Array.isArray(source.requiredFields)
+            ? source.requiredFields.map(String)
+            : Array.isArray(source.required)
+                ? source.required.map(String)
+                : [],
+        fields: Array.isArray(source.fields) ? source.fields : [],
+        enums: isRecord(source.enums) ? source.enums : undefined,
+        schema: rawSchema,
+        codeLists,
+    };
+}
+/**
+ * Cache-segment per environment zodat een latere live/staging-switch geen
+ * stale data uit de andere environment toont. De server resolved de echte
+ * environment uit de actieve connectie; deze key is puur voor de query-cache.
+ */
+function useEnvKey() {
+    const { environment } = useFloridayConnection();
+    try {
+        return environment ? normalizeFloridayEnvironment(environment) : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function useFloridaySchema(resource, params) {
+    const envKey = useEnvKey();
+    const paramsKey = params ? JSON.stringify(params) : "";
+    const q = useQuery({
+        queryKey: ["floriday-schema", resource, paramsKey, envKey],
+        queryFn: async () => (await gatewaySchemaFn({
+            data: { resource, ...(params ?? {}) },
+        })),
+        staleTime: 60 * 60 * 1000,
+    });
+    useEffect(() => {
+        if (!q.data?.requiredFields)
+            return;
+        const missing = unmappedRequiredFields(q.data.requiredFields);
+        if (missing.length && import.meta.env.DEV) {
+            console.warn(`[floriday-schema] ${resource}: required fields zonder step-mapping:`, missing);
+        }
+    }, [q.data?.requiredFields, resource]);
+    return q;
+}
+/**
+ * §15.2 — één HMAC-call die het `trade-item`-schema én alle voor het
+ * "Nieuw artikel"-formulier benodigde code-lists meelevert. Vervangt een
+ * losse `useFloridaySchema("trade-item")` + meerdere `useCodeList(...)`
+ * round-trips bij wizard-open.
+ *
+ * Fail-closed: gooit als de gateway geen `ok: true` teruggeeft.
+ */
+const TRADE_ITEM_INCLUDE_CODE_LISTS = [
+    "vbn-product-group",
+    "vbn-product-code",
+    "vbn-characteristic",
+    "vbn-characteristic-value",
+    "characteristic",
+    "packaging-type",
+    "country-of-origin",
+    "length-unit",
+];
+export function useTradeItemFormSchema() {
+    const envKey = useEnvKey();
+    const q = useQuery({
+        queryKey: ["floriday-trade-item-schema", envKey],
+        queryFn: async () => {
+            const raw = await gatewaySchemaFn({
+                data: {
+                    resource: "trade-item",
+                    environment: envKey === "live" ? "live" : "staging",
+                    includeCodeLists: [...TRADE_ITEM_INCLUDE_CODE_LISTS],
+                },
+            });
+            const res = normalizeSchemaResponse(raw);
+            if (!res || res.ok !== true) {
+                throw new Error(res?.error ??
+                    "Floriday trade-item schema niet beschikbaar (gateway gaf geen ok=true terug)");
+            }
+            const vbnList = res.codeLists?.["vbn-product-group"] ?? [];
+            if (vbnList.length === 0) {
+                throw new Error("Floriday schema-call is incompleet: codeLists['vbn-product-group'] ontbreekt. Daardoor kunnen VBN-specifieke karakteristieken niet betrouwbaar worden bepaald.");
+            }
+            return res;
+        },
+        staleTime: 60 * 60 * 1000,
+    });
+    useEffect(() => {
+        if (!q.data?.requiredFields)
+            return;
+        const missing = unmappedRequiredFields(q.data.requiredFields);
+        if (missing.length && import.meta.env.DEV) {
+            console.warn(`[floriday-schema] trade-item: required fields zonder step-mapping:`, missing);
+        }
+    }, [q.data?.requiredFields]);
+    return q;
+}
+export function useCodeList(listName) {
+    const envKey = useEnvKey();
+    return useQuery({
+        queryKey: ["floriday-code-list", listName ?? "", envKey],
+        queryFn: async () => (await gatewayCodeListFn({ data: { listName: listName } })),
+        staleTime: 60 * 60 * 1000,
+        enabled: Boolean(listName),
+    });
+}
+export function useCachedList(entity, limit = 1000) {
+    const envKey = useEnvKey();
+    return useQuery({
+        queryKey: ["floriday-cached-list", entity ?? "", limit, envKey],
+        queryFn: async () => (await gatewayCachedListFn({ data: { entity: entity, limit } })),
+        staleTime: 5 * 60 * 1000,
+        enabled: Boolean(entity),
+    });
+}
+/**
+ * Invalideert alle floriday-* queries wanneer de actieve connectie
+ * (en dus mogelijk de environment) wijzigt. Voorkomt cache-bleed
+ * tussen staging en live bij een toekomstige switcher.
+ */
+export function useInvalidateFloridayOnConnectionChange() {
+    const { activeId, environment } = useFloridayConnection();
+    const qc = useQueryClient();
+    useEffect(() => {
+        qc.invalidateQueries({ queryKey: ["floriday-cached-list"] });
+        qc.invalidateQueries({ queryKey: ["floriday-code-list"] });
+        qc.invalidateQueries({ queryKey: ["floriday-schema"] });
+        qc.invalidateQueries({ queryKey: ["floriday-trade-item-schema"] });
+    }, [activeId, environment, qc]);
+}

package/dist-lib/hooks/useFloridayConnection.d.ts

@@ -1,9 +1,14 @@
-import { type FloridayConnection } from "../lib/floriday-client";
+import type { FloridayActiveConnection } from "../lib/floriday-client";
+/**
+ * Reads the single active Floriday connection for the currently selected
+ * environment (staging/live) via the Auth-module's
+ * `get_active_floriday_connection_public` RPC. No tokens or secrets are
+ * exposed.
+ */
 export declare function useFloridayConnection(): {
-    connections: FloridayConnection[];
+    activeConnection: FloridayActiveConnection | null;
     activeId: string | null;
-    setActiveId: (id: string) => void;
-    activeConnection: FloridayConnection | null;
+    environment: string | null;
     loading: boolean;
     error: string | null;
 };

package/dist-lib/hooks/useFloridayConnection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFloridayConnection.d.ts","sourceRoot":"","sources":["../../src/hooks/useFloridayConnection.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAI3E,wBAAgB,qBAAqB;;;sBAyBV,MAAM;;;;EAahC"}
+{"version":3,"file":"useFloridayConnection.d.ts","sourceRoot":"","sources":["../../src/hooks/useFloridayConnection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAEvE;;;;;GAKG;AACH,wBAAgB,qBAAqB;;;;;;EA+BpC"}

package/dist-lib/hooks/useFloridayConnection.js

@@ -1,39 +1,39 @@
 import { useEffect, useState } from "react";
-import { floriday } from "../lib/floriday-client";
-const STORAGE_KEY = "voorraad.activeFloridayConnection";
+import { supabase } from "../integrations/supabase/client";
+/**
+ * Reads the single active Floriday connection for the currently selected
+ * environment (staging/live) via the Auth-module's
+ * `get_active_floriday_connection_public` RPC. No tokens or secrets are
+ * exposed.
+ */
 export function useFloridayConnection() {
-    const [connections, setConnections] = useState([]);
-    const [activeId, setActiveIdState] = useState(null);
+    const [activeConnection, setActive] = useState(null);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     useEffect(() => {
         let mounted = true;
-        floriday
-            .listConnections()
-            .then((rows) => {
+        (async () => {
+            const { data, error } = await supabase.rpc("get_active_floriday_connection_public");
             if (!mounted)
                 return;
-            setConnections(rows);
-            const stored = typeof window !== "undefined" ? localStorage.getItem(STORAGE_KEY) : null;
-            const pick = rows.find((r) => r.id === stored) ?? rows[0];
-            setActiveIdState(pick?.id ?? null);
-        })
-            .catch((e) => setError(e.message))
-            .finally(() => mounted && setLoading(false));
+            if (error) {
+                setError(error.message);
+                setActive(null);
+            }
+            else {
+                const row = (data ?? [])[0];
+                setActive(row && row.id ? row : null);
+            }
+            setLoading(false);
+        })();
         return () => {
             mounted = false;
         };
     }, []);
-    const setActiveId = (id) => {
-        setActiveIdState(id);
-        if (typeof window !== "undefined")
-            localStorage.setItem(STORAGE_KEY, id);
-    };
     return {
-        connections,
-        activeId,
-        setActiveId,
-        activeConnection: connections.find((c) => c.id === activeId) ?? null,
+        activeConnection,
+        activeId: activeConnection?.id ?? null,
+        environment: activeConnection?.active_environment ?? null,
         loading,
         error,
     };

package/dist-lib/hooks/useFlorydayCustomers.d.ts

@@ -0,0 +1,17 @@
+export interface FloridayCustomer {
+    id: string;
+    name: string;
+    hasRealName: boolean;
+}
+/**
+ * Reads buyer organisations from the shared `floriday_connections_cache`
+ * (which contains buyer org id + name per supplier connection).
+ * If `buyer_organization_name` is NULL (Auth-module hasn't synced names yet),
+ * we fall back to a short, readable label so the UI never shows a raw UUID.
+ */
+export declare function useFlorydayCustomers(connectionId: string | null): {
+    customers: FloridayCustomer[];
+    loading: boolean;
+    error: string | null;
+};
+//# sourceMappingURL=useFlorydayCustomers.d.ts.map

package/dist-lib/hooks/useFlorydayCustomers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlorydayCustomers.d.ts","sourceRoot":"","sources":["../../src/hooks/useFlorydayCustomers.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;CACtB;AAMD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;;;;EAoD/D"}

package/dist-lib/hooks/useFlorydayCustomers.js

@@ -0,0 +1,65 @@
+import { useEffect, useState } from "react";
+import { supabase } from "../integrations/supabase/client";
+function shortId(id) {
+    return `Klant ${id.slice(0, 8)}…${id.slice(-4)}`;
+}
+/**
+ * Reads buyer organisations from the shared `floriday_connections_cache`
+ * (which contains buyer org id + name per supplier connection).
+ * If `buyer_organization_name` is NULL (Auth-module hasn't synced names yet),
+ * we fall back to a short, readable label so the UI never shows a raw UUID.
+ */
+export function useFlorydayCustomers(connectionId) {
+    const [customers, setCustomers] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let mounted = true;
+        if (!connectionId) {
+            setCustomers([]);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        supabase
+            .from("floriday_connections_cache")
+            .select("buyer_organization_id,buyer_organization_name")
+            .eq("connection_id", connectionId)
+            .eq("is_deleted", false)
+            .then(({ data, error }) => {
+            if (!mounted)
+                return;
+            if (error) {
+                setError(error.message);
+                setCustomers([]);
+                return;
+            }
+            const seen = new Set();
+            const out = [];
+            for (const row of data ?? []) {
+                const id = row.buyer_organization_id;
+                if (!id || seen.has(id))
+                    continue;
+                seen.add(id);
+                const real = (row.buyer_organization_name ?? "").trim();
+                out.push({
+                    id,
+                    name: real.length > 0 ? real : shortId(id),
+                    hasRealName: real.length > 0,
+                });
+            }
+            // Real names first (alphabetical), then fallback labels.
+            out.sort((a, b) => {
+                if (a.hasRealName !== b.hasRealName)
+                    return a.hasRealName ? -1 : 1;
+                return a.name.localeCompare(b.name);
+            });
+            setCustomers(out);
+        })
+            .then(() => mounted && setLoading(false));
+        return () => {
+            mounted = false;
+        };
+    }, [connectionId]);
+    return { customers, loading, error };
+}

package/dist-lib/hooks/useLocalTradeItems.d.ts

@@ -0,0 +1,38 @@
+import type { WizardData } from "../lib/floriday-payload";
+import type { FloridayLinkStatus, TradeItem } from "../lib/floriday-client";
+export interface LocalTradeItemRow {
+    id: string;
+    connection_id: string | null;
+    data: WizardData;
+    updated_at: string;
+    created_at: string;
+    floriday_link_status?: FloridayLinkStatus;
+    floriday_id?: string | null;
+    floriday_link_error?: string | null;
+    missing_required_fields?: string[] | null;
+    last_floriday_sync_at?: string | null;
+    source?: string | null;
+}
+export declare function useLocalTradeItems(connectionId: string | null): {
+    items: TradeItem[];
+    loading: boolean;
+    reload: () => Promise<void>;
+};
+export declare function getLocalTradeItem(id: string): Promise<LocalTradeItemRow | null>;
+export interface DraftMeta {
+    floridayLinkStatus?: FloridayLinkStatus;
+    floridayId?: string | null;
+    floridayLinkError?: string | null;
+    missingRequiredFields?: string[];
+    lastFloridaySyncAt?: string | null;
+    source?: "manual" | "excel_import";
+}
+export declare function upsertLocalTradeItem(params: {
+    id?: string;
+    connectionId: string;
+    data: WizardData;
+    meta?: DraftMeta;
+}): Promise<string>;
+export declare function updateDraftMeta(id: string, meta: DraftMeta): Promise<void>;
+export declare function deleteLocalTradeItem(id: string): Promise<void>;
+//# sourceMappingURL=useLocalTradeItems.d.ts.map

package/dist-lib/hooks/useLocalTradeItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalTradeItems.d.ts","sourceRoot":"","sources":["../../src/hooks/useLocalTradeItems.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAE5E,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,CAAC,EAAE,kBAAkB,CAAC;IAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,uBAAuB,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC1C,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAgCD,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;;;;EA+B7D;AAED,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAQrF;AAED,MAAM,WAAW,SAAS;IACxB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,CAAC;CACpC;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2ClB;AAED,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhF;AAED,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGpE"}

package/dist-lib/hooks/useLocalTradeItems.js

@@ -0,0 +1,144 @@
+import { useCallback, useEffect, useState } from "react";
+import { supabase } from "../integrations/supabase/client";
+function draftToTradeItem(row) {
+    const d = row.data ?? {};
+    const firstImage = Array.isArray(d.images) && d.images.length > 0 ? d.images[0] : null;
+    const imageUrl = (firstImage && (firstImage.url || firstImage.previewUrl)) ?? null;
+    return {
+        id: `local:${row.id}`,
+        localId: row.id,
+        name: d.name || d.vbnName || "(naamloos)",
+        articleNumber: d.articleCode || d.gtin || "",
+        imageUrl,
+        quantity: 0,
+        minQuantity: 0,
+        reservedQuantity: 0,
+        availableQuantity: 0,
+        incomingQuantity: 0,
+        economicQuantity: 0,
+        raw: row,
+        published: false,
+        linkStatus: row.floriday_link_status ?? "unlinked",
+        missingFields: row.missing_required_fields ?? [],
+        linkError: row.floriday_link_error ?? null,
+        lastSyncAt: row.last_floriday_sync_at ?? null,
+        floridayId: row.floriday_id ?? null,
+    };
+}
+const SELECT_COLS = "id,connection_id,data,updated_at,created_at,floriday_link_status,floriday_id,floriday_link_error,missing_required_fields,last_floriday_sync_at,source";
+export function useLocalTradeItems(connectionId) {
+    const [items, setItems] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const load = useCallback(async () => {
+        if (!connectionId) {
+            setItems([]);
+            return;
+        }
+        setLoading(true);
+        try {
+            const { data, error } = await supabase
+                .from("trade_item_drafts")
+                .select(SELECT_COLS)
+                .eq("connection_id", connectionId)
+                .order("updated_at", { ascending: false })
+                .limit(1000);
+            if (error)
+                throw error;
+            setItems((data ?? []).map((r) => draftToTradeItem(r)));
+        }
+        catch {
+            setItems([]);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [connectionId]);
+    useEffect(() => {
+        load();
+    }, [load]);
+    return { items, loading, reload: load };
+}
+export async function getLocalTradeItem(id) {
+    const { data, error } = await supabase
+        .from("trade_item_drafts")
+        .select(SELECT_COLS)
+        .eq("id", id)
+        .maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    return data ?? null;
+}
+export async function upsertLocalTradeItem(params) {
+    const userRes = await supabase.auth.getUser();
+    const userId = userRes.data.user?.id;
+    if (!userId)
+        throw new Error("Niet ingelogd");
+    const metaRow = {};
+    const m = params.meta;
+    if (m) {
+        if (m.floridayLinkStatus !== undefined)
+            metaRow.floriday_link_status = m.floridayLinkStatus;
+        if (m.floridayId !== undefined)
+            metaRow.floriday_id = m.floridayId;
+        if (m.floridayLinkError !== undefined)
+            metaRow.floriday_link_error = m.floridayLinkError;
+        if (m.missingRequiredFields !== undefined)
+            metaRow.missing_required_fields = m.missingRequiredFields;
+        if (m.lastFloridaySyncAt !== undefined)
+            metaRow.last_floriday_sync_at = m.lastFloridaySyncAt;
+        if (m.source !== undefined)
+            metaRow.source = m.source;
+    }
+    if (params.id) {
+        const patch = {
+            data: params.data,
+            connection_id: params.connectionId,
+            updated_at: new Date().toISOString(),
+            ...metaRow,
+        };
+        const { error } = await supabase
+            .from("trade_item_drafts")
+            .update(patch)
+            .eq("id", params.id);
+        if (error)
+            throw new Error(error.message);
+        return params.id;
+    }
+    const insertRow = {
+        user_id: userId,
+        connection_id: params.connectionId,
+        data: params.data,
+        ...metaRow,
+    };
+    const { data, error } = await supabase
+        .from("trade_item_drafts")
+        .insert(insertRow)
+        .select("id")
+        .single();
+    if (error)
+        throw new Error(error.message);
+    return data.id;
+}
+export async function updateDraftMeta(id, meta) {
+    const row = {};
+    if (meta.floridayLinkStatus !== undefined)
+        row.floriday_link_status = meta.floridayLinkStatus;
+    if (meta.floridayId !== undefined)
+        row.floriday_id = meta.floridayId;
+    if (meta.floridayLinkError !== undefined)
+        row.floriday_link_error = meta.floridayLinkError;
+    if (meta.missingRequiredFields !== undefined)
+        row.missing_required_fields = meta.missingRequiredFields;
+    if (meta.lastFloridaySyncAt !== undefined)
+        row.last_floriday_sync_at = meta.lastFloridaySyncAt;
+    if (Object.keys(row).length === 0)
+        return;
+    const { error } = await supabase.from("trade_item_drafts").update(row).eq("id", id);
+    if (error)
+        throw new Error(error.message);
+}
+export async function deleteLocalTradeItem(id) {
+    const { error } = await supabase.from("trade_item_drafts").delete().eq("id", id);
+    if (error)
+        throw new Error(error.message);
+}