@flowselections/floriday-voorraad 1.0.12 → 1.0.14

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

@@ -1,43 +1,241 @@
 import { supabase } from "../integrations/supabase/client";
-async function call(body) {
-    const { data, error } = await supabase.functions.invoke("floriday-api", { body });
-    if (error)
-        throw new Error(error.message);
-    if (data && typeof data === "object" && "error" in data && data.error) {
-        throw new Error(String(data.error));
+import { publishTradeItem, updateTradeItemFn } from "./floriday-writes.functions";
+function summarizePayload(payload) {
+    if (!payload || typeof payload !== "object")
+        return {};
+    return {
+        name: payload?.name ?? payload?.tradeItemName ?? null,
+        vbnCode: payload?.vbnProductCode ?? payload?.vbnCode ?? null,
+        botanicalName: payload?.characteristics?.botanicalName ?? null,
+    };
+}
+async function logPublishAttempt(params) {
+    try {
+        const userRes = await supabase.auth.getUser();
+        const userId = userRes.data.user?.id;
+        if (!userId)
+            return;
+        await supabase.from("voorraad_publish_attempts").insert({
+            user_id: userId,
+            connection_id: params.connectionId,
+            trade_item_id: params.tradeItemId,
+            action: "upsert-trade-item",
+            intent: params.intent,
+            ok: params.ok,
+            gateway_status: params.gatewayStatus,
+            gateway_attempt_id: params.gatewayAttemptId,
+            error: params.error,
+            request_summary: params.summary,
+        });
+    }
+    catch {
+        // Audit-log mag de hoofd-flow nooit breken.
     }
-    return data;
 }
+function pickLocalized(value) {
+    if (!value)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "object") {
+        const obj = value;
+        const v = obj.nl ?? obj.en ?? obj.de ?? Object.values(obj)[0];
+        return typeof v === "string" ? v : "";
+    }
+    return String(value);
+}
+export function normaliseTradeItem(raw) {
+    const photo = raw.photos?.find((p) => p.primary)?.url ??
+        raw.photos?.[0]?.url ??
+        raw.images?.[0]?.url ??
+        raw.imageUrls?.[0] ??
+        null;
+    return {
+        id: raw.id ?? raw.tradeItemId ?? String(raw.sequenceNumber ?? ""),
+        name: pickLocalized(raw.name ?? raw.tradeItemName),
+        articleNumber: raw.supplierArticleCode ?? raw.articleCode ?? raw.gtin ?? "",
+        imageUrl: photo,
+        quantity: raw.physicalStock ?? raw.stock?.physical ?? 0,
+        minQuantity: raw.minimumStock ?? raw.stock?.minimum ?? 0,
+        reservedQuantity: raw.reservedStock ?? raw.stock?.reserved ?? 0,
+        availableQuantity: raw.availableStock ?? raw.stock?.available ?? 0,
+        incomingQuantity: raw.incomingStock ?? raw.stock?.incoming ?? 0,
+        economicQuantity: raw.economicStock ?? raw.stock?.economic ?? 0,
+        raw,
+    };
+}
+/**
+ * Public surface used by the wizard. All writes go through the HMAC-signed
+ * Floriday gateway hosted by the Authentication module. Reads of cached
+ * sequence resources (e.g. classifications) go through the same gateway,
+ * which is backed by the shared Supabase cache.
+ */
 export const floriday = {
-    listConnections: () => call({ action: "listConnections" }).then((r) => r.connections),
-    listTradeItems: (connectionId, limit = 200, offset = 0) => call({
-        action: "listTradeItems",
-        connectionId,
-        limit,
-        offset,
-    }).then((r) => r.items ?? []),
-    listClassifications: (connectionId) => call({
-        action: "listClassifications",
-        connectionId,
-    }),
-    listCustomerOrganizations: (connectionId) => call({
-        action: "listCustomerOrganizations",
-        connectionId,
-    }),
-    listAdditionalServices: (connectionId) => call({
-        action: "listAdditionalServices",
-        connectionId,
-    }),
-    createTradeItem: (connectionId, payload) => call({
-        action: "createTradeItem",
-        connectionId,
-        payload,
-    }),
-    uploadImage: (connectionId, fileBase64, contentType, filename) => call({
-        action: "uploadImage",
-        connectionId,
-        fileBase64,
-        contentType,
-        filename,
-    }),
+    // Note: listClassifications is verwijderd — Floriday Suppliers 2026v1 kent
+    // geen trade-item-classifications resource meer. Karakteristieken komen nu
+    // uit `gatewaySchemaFn({ resource: "trade-item" })` + `gatewayCodeListFn`.
+    createTradeItem: async (connectionId, payload) => {
+        const tradeItemId = payload?.tradeItemId ?? crypto?.randomUUID?.() ?? `${Date.now()}`;
+        const formVersion = payload?.formVersion ?? "v1";
+        try {
+            const res = (await publishTradeItem({
+                data: { tradeItemId, values: payload, formVersion },
+            }));
+            await logPublishAttempt({
+                connectionId,
+                tradeItemId,
+                intent: "create",
+                ok: true,
+                gatewayStatus: res?.status ?? null,
+                gatewayAttemptId: res?.attemptId ?? null,
+                error: null,
+                summary: summarizePayload(payload),
+            });
+            return {
+                ok: true,
+                data: res?.data ?? null,
+                attemptId: res?.attemptId ?? null,
+                tradeItemId,
+            };
+        }
+        catch (e) {
+            await logPublishAttempt({
+                connectionId,
+                tradeItemId,
+                intent: "create",
+                ok: false,
+                gatewayStatus: null,
+                gatewayAttemptId: null,
+                error: e?.message ?? String(e),
+                summary: summarizePayload(payload),
+            });
+            throw e;
+        }
+    },
+    updateTradeItem: async (connectionId, tradeItemId, payload) => {
+        const formVersion = payload?.formVersion ?? "v1";
+        try {
+            const res = (await updateTradeItemFn({
+                data: { tradeItemId, values: payload, formVersion },
+            }));
+            await logPublishAttempt({
+                connectionId,
+                tradeItemId,
+                intent: "update",
+                ok: true,
+                gatewayStatus: res?.status ?? null,
+                gatewayAttemptId: res?.attemptId ?? null,
+                error: null,
+                summary: summarizePayload(payload),
+            });
+            return {
+                ok: true,
+                data: res?.data ?? null,
+                attemptId: res?.attemptId ?? null,
+                tradeItemId,
+            };
+        }
+        catch (e) {
+            await logPublishAttempt({
+                connectionId,
+                tradeItemId,
+                intent: "update",
+                ok: false,
+                gatewayStatus: null,
+                gatewayAttemptId: null,
+                error: e?.message ?? String(e),
+                summary: summarizePayload(payload),
+            });
+            throw e;
+        }
+    },
+    /**
+     * Upload een foto naar Floriday via de interne server-route
+     * `/api/trade-item-photo`. We sturen het bestand als multipart/form-data
+     * en plakken de Supabase-bearer expliciet op de fetch zodat de
+     * `Authorization`-header gegarandeerd meegaat (in tegenstelling tot de
+     * server-fn route, die bij grote base64-JSON payloads soms geen header
+     * meestuurt en resulteert in 401).
+     */
+    uploadImage: async (connectionId, file, _contentType, filename) => {
+        const { data: sessionData } = await supabase.auth.getSession();
+        const token = sessionData.session?.access_token;
+        if (!token) {
+            throw new Error("Geen actieve sessie — log opnieuw in.");
+        }
+        const form = new FormData();
+        form.append("connectionId", connectionId);
+        // Geef het bestand een naam mee — anders krijgt server "blob".
+        const fname = filename ?? file.name ?? `photo-${Date.now()}.jpg`;
+        form.append("file", file, fname);
+        // Stille retry: 2× extra pogingen met exponentiële backoff bij 5xx /
+        // netwerkfouten. Bij client-side fouten (te klein, verkeerd type) tonen
+        // we de server-message meteen aan de gebruiker — geen retry.
+        const GENERIC = "Foto kon niet worden geüpload. Probeer het later opnieuw.";
+        const backoffs = [0, 300, 900];
+        let lastErr = null;
+        for (let attempt = 0; attempt < backoffs.length; attempt++) {
+            if (backoffs[attempt] > 0) {
+                await new Promise((r) => setTimeout(r, backoffs[attempt]));
+            }
+            try {
+                const res = await fetch("/api/trade-item-photo", {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${token}` },
+                    body: form,
+                });
+                const ct = res.headers.get("content-type") ?? "";
+                const text = await res.text();
+                let parsed = null;
+                if (ct.toLowerCase().includes("application/json") && text) {
+                    try {
+                        parsed = JSON.parse(text);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+                if (!res.ok) {
+                    const base = parsed?.message || parsed?.error || GENERIC;
+                    const withDetail = parsed?.detail ? `${base} (${parsed.detail})` : base;
+                    const withStatus = parsed?.gatewayStatus
+                        ? `${withDetail} [status ${parsed.gatewayStatus}]`
+                        : withDetail;
+                    lastErr = new Error(withStatus);
+                    if (res.status >= 500 && attempt < backoffs.length - 1)
+                        continue;
+                    throw lastErr;
+                }
+                if (parsed?.ok === false) {
+                    const base = parsed.message || GENERIC;
+                    const withDetail = parsed.detail ? `${base} (${parsed.detail})` : base;
+                    const withStatus = parsed.gatewayStatus
+                        ? `${withDetail} [status ${parsed.gatewayStatus}]`
+                        : withDetail;
+                    lastErr = new Error(withStatus);
+                    if (parsed.retryable && attempt < backoffs.length - 1)
+                        continue;
+                    throw lastErr;
+                }
+                if (!parsed?.url) {
+                    lastErr = new Error(GENERIC);
+                    if (attempt < backoffs.length - 1)
+                        continue;
+                    throw lastErr;
+                }
+                return {
+                    ok: true,
+                    imageId: (parsed.imageId ?? parsed.mediaId ?? null),
+                    mediaId: parsed.mediaId ?? parsed.imageId ?? null,
+                    url: parsed.url,
+                };
+            }
+            catch (e) {
+                lastErr = e instanceof Error ? e : new Error(String(e));
+                if (attempt >= backoffs.length - 1)
+                    break;
+            }
+        }
+        throw lastErr instanceof Error ? lastErr : new Error(GENERIC);
+    },
 };

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

@@ -0,0 +1,29 @@
+/**
+ * Client-safe environment helpers voor Floriday.
+ *
+ * De Auth-gateway accepteert uitsluitend exact "staging" of "live" in de
+ * request-body. Eén bron van waarheid: de actieve Floriday-connectie
+ * (`floriday_settings.active_environment` of `floriday_connections.environment`).
+ *
+ * `normalizeFloridayEnvironment` is pure en mag overal worden geïmporteerd.
+ * De async resolver die de Supabase-RPC raakt staat in `floriday-env.server.ts`.
+ */
+export type FloridayEnvironment = "staging" | "live";
+export type FloridayEnvErrorCode = "NO_ACTIVE_FLORIDAY_CONNECTION" | "INVALID_FLORIDAY_ENVIRONMENT";
+export declare class FloridayEnvError extends Error {
+    code: FloridayEnvErrorCode;
+    constructor(code: FloridayEnvErrorCode, message: string);
+}
+/**
+ * Mapt een ruwe environment-string uit de DB naar exact "staging" of "live".
+ * Werpt `FloridayEnvError("INVALID_FLORIDAY_ENVIRONMENT")` bij alles wat niet
+ * te mappen valt — geen stille defaults.
+ */
+export declare function normalizeFloridayEnvironment(raw: string | null | undefined): FloridayEnvironment;
+/**
+ * Detecteer een FloridayEnvError aan de hand van de message-prefix.
+ * Bruikbaar in UI-code waar alleen de Error-message beschikbaar is
+ * (server-fn errors worden door TanStack platgeslagen naar `new Error(message)`).
+ */
+export declare function getFloridayEnvErrorCode(err: unknown): FloridayEnvErrorCode | null;
+//# sourceMappingURL=floriday-env.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-env.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD,MAAM,MAAM,oBAAoB,GAC5B,+BAA+B,GAC/B,8BAA8B,CAAC;AAEnC,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,IAAI,EAAE,oBAAoB,CAAC;gBACf,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM;CAOxD;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC7B,mBAAmB,CAQrB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,GACX,oBAAoB,GAAG,IAAI,CAI7B"}

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

@@ -0,0 +1,42 @@
+/**
+ * Client-safe environment helpers voor Floriday.
+ *
+ * De Auth-gateway accepteert uitsluitend exact "staging" of "live" in de
+ * request-body. Eén bron van waarheid: de actieve Floriday-connectie
+ * (`floriday_settings.active_environment` of `floriday_connections.environment`).
+ *
+ * `normalizeFloridayEnvironment` is pure en mag overal worden geïmporteerd.
+ * De async resolver die de Supabase-RPC raakt staat in `floriday-env.server.ts`.
+ */
+export class FloridayEnvError extends Error {
+    constructor(code, message) {
+        // Prefix met code zodat normalize-errors-middleware / safe() de code
+        // intact doorgeeft naar de UI (geen gestructureerde RPC-errors nodig).
+        super(`[${code}] ${message}`);
+        this.code = code;
+        this.name = "FloridayEnvError";
+    }
+}
+/**
+ * Mapt een ruwe environment-string uit de DB naar exact "staging" of "live".
+ * Werpt `FloridayEnvError("INVALID_FLORIDAY_ENVIRONMENT")` bij alles wat niet
+ * te mappen valt — geen stille defaults.
+ */
+export function normalizeFloridayEnvironment(raw) {
+    const v = (raw ?? "").trim().toLowerCase();
+    if (v === "staging" || v === "stg")
+        return "staging";
+    if (v === "live" || v === "production" || v === "prod")
+        return "live";
+    throw new FloridayEnvError("INVALID_FLORIDAY_ENVIRONMENT", `Ongeldige Floriday-environment: "${raw ?? ""}". Verwacht "staging" of "live".`);
+}
+/**
+ * Detecteer een FloridayEnvError aan de hand van de message-prefix.
+ * Bruikbaar in UI-code waar alleen de Error-message beschikbaar is
+ * (server-fn errors worden door TanStack platgeslagen naar `new Error(message)`).
+ */
+export function getFloridayEnvErrorCode(err) {
+    const msg = err instanceof Error ? err.message : String(err ?? "");
+    const m = msg.match(/\[(NO_ACTIVE_FLORIDAY_CONNECTION|INVALID_FLORIDAY_ENVIRONMENT)\]/);
+    return m?.[1] ?? null;
+}

package/dist-lib/lib/floriday-env.server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Server-only resolver voor de actieve Floriday-environment.
+ *
+ * Single source of truth: dezelfde RPC die `useFloridayConnection` client-side
+ * gebruikt (`get_active_floriday_connection_public`). Dit voorkomt dat
+ * cached-list/write/media-upload elk een eigen environment-bron kiezen.
+ *
+ * NOOIT importeren vanuit componenten — filename eindigt op `.server.ts`
+ * en wordt geblokkeerd door de client-bundler.
+ */
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { type FloridayEnvironment } from "./floriday-env";
+export { FloridayEnvError, normalizeFloridayEnvironment, type FloridayEnvironment, } from "./floriday-env";
+export declare function resolveFloridayEnvironment(supabase: SupabaseClient<any, any, any>): Promise<FloridayEnvironment>;
+//# sourceMappingURL=floriday-env.server.d.ts.map

package/dist-lib/lib/floriday-env.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-env.server.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-env.server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,gBAAgB,EAChB,4BAA4B,EAC5B,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAExB,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GACtC,OAAO,CAAC,mBAAmB,CAAC,CAmB9B"}

package/dist-lib/lib/floriday-env.server.js

@@ -0,0 +1,13 @@
+import { FloridayEnvError, normalizeFloridayEnvironment, } from "./floriday-env";
+export { FloridayEnvError, normalizeFloridayEnvironment, } from "./floriday-env";
+export async function resolveFloridayEnvironment(supabase) {
+    const { data, error } = await supabase.rpc("get_active_floriday_connection_public");
+    if (error) {
+        throw new FloridayEnvError("NO_ACTIVE_FLORIDAY_CONNECTION", `Kon actieve Floriday-connectie niet ophalen: ${error.message}`);
+    }
+    const row = (Array.isArray(data) ? data[0] : data);
+    if (!row || !row.id) {
+        throw new FloridayEnvError("NO_ACTIVE_FLORIDAY_CONNECTION", "Geen actieve Floriday-connectie gevonden. Ga naar Instellingen → Floriday.");
+    }
+    return normalizeFloridayEnvironment(row.active_environment);
+}

package/dist-lib/lib/floriday-field-sources.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mapping van Floriday-veldnamen naar hun waarde-bron.
+ *
+ * - CODE_LIST_BY_FIELD: veld met vaste enum-waardes uit /gateway/code-list.
+ * - REF_ENTITY_BY_FIELD: veld dat verwijst naar een rij in een stamdata-cache,
+ *   te lezen via /gateway/cached-list. Waarden zijn kebab-case Floriday-
+ *   resources (GatewayEntity) — NIET de Supabase-tabelnaam.
+ * - REF_TABLE_BY_FIELD: identieke mapping naar de Supabase-cache-tabelnaam,
+ *   uitsluitend voor directe `supabase.from(...)` reads in deze module.
+ */
+import { type GatewayEntity } from "./floriday-gateway-entities";
+export declare const CODE_LIST_BY_FIELD: Record<string, string>;
+export declare const REF_ENTITY_BY_FIELD: Record<string, GatewayEntity>;
+export declare const REF_TABLE_BY_FIELD: Record<string, string>;
+export declare function codeListFor(field: string): string | undefined;
+export declare function refEntityFor(field: string): GatewayEntity | undefined;
+export declare function refTableFor(field: string): string | undefined;
+//# sourceMappingURL=floriday-field-sources.d.ts.map

package/dist-lib/lib/floriday-field-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-field-sources.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-field-sources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEnF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUrD,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAM7D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAMrD,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAErE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7D"}

package/dist-lib/lib/floriday-field-sources.js

@@ -0,0 +1,45 @@
+/**
+ * Mapping van Floriday-veldnamen naar hun waarde-bron.
+ *
+ * - CODE_LIST_BY_FIELD: veld met vaste enum-waardes uit /gateway/code-list.
+ * - REF_ENTITY_BY_FIELD: veld dat verwijst naar een rij in een stamdata-cache,
+ *   te lezen via /gateway/cached-list. Waarden zijn kebab-case Floriday-
+ *   resources (GatewayEntity) — NIET de Supabase-tabelnaam.
+ * - REF_TABLE_BY_FIELD: identieke mapping naar de Supabase-cache-tabelnaam,
+ *   uitsluitend voor directe `supabase.from(...)` reads in deze module.
+ */
+import { GATEWAY_ENTITIES } from "./floriday-gateway-entities";
+export const CODE_LIST_BY_FIELD = {
+    currency: "Currency",
+    salesUnit: "SalesUnit",
+    auctionLocation: "AuctionLocation",
+    supplyType: "SupplyType",
+    loadCarrierType: "SupplyLoadCarrierType",
+    packingType: "PackingType",
+    qualityMark: "QualityMark",
+    country: "Country",
+    countryOfOrigin: "Country",
+};
+export const REF_ENTITY_BY_FIELD = {
+    packingId: GATEWAY_ENTITIES.packings,
+    warehouseId: GATEWAY_ENTITIES.warehouses,
+    deliveryLocationId: GATEWAY_ENTITIES.deliveryLocations,
+    priceGroupId: GATEWAY_ENTITIES.priceGroups,
+    collectionId: GATEWAY_ENTITIES.collections,
+};
+export const REF_TABLE_BY_FIELD = {
+    packingId: "floriday_packings_cache",
+    warehouseId: "floriday_warehouses_cache",
+    deliveryLocationId: "floriday_delivery_locations_cache",
+    priceGroupId: "floriday_price_groups_cache",
+    collectionId: "floriday_collections_cache",
+};
+export function codeListFor(field) {
+    return CODE_LIST_BY_FIELD[field];
+}
+export function refEntityFor(field) {
+    return REF_ENTITY_BY_FIELD[field];
+}
+export function refTableFor(field) {
+    return REF_TABLE_BY_FIELD[field];
+}

package/dist-lib/lib/floriday-gateway-entities.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Whitelist van kebab-case Floriday-resource-namen die de centrale Auth-gateway
+ * accepteert op `/api/public/gateway/cached-list`. 1-op-1 overgenomen uit
+ * `src/routes/api/public/gateway/cached-list.ts` aan Auth-zijde.
+ *
+ * Componenten geven NOOIT een Supabase-tabelnaam (`floriday_<x>_cache`)
+ * door als `entity` — gebruik altijd de kebab-case key uit dit bestand.
+ */
+export declare const GATEWAY_ENTITIES: {
+    readonly salesOrders: "sales-orders";
+    readonly tradeItems: "trade-items";
+    readonly customerOrganizations: "customer-organizations";
+    readonly carriers: "carriers";
+    readonly fulfillmentOrders: "fulfillment-orders";
+    readonly deliveryOrders: "delivery-orders";
+    readonly clockSupplies: "clock-supplies";
+    readonly clockPresales: "clock-presales";
+    readonly contracts: "contracts";
+    readonly blanketOrders: "blanket-orders";
+    readonly warehouses: "warehouses";
+    readonly deliveryLocations: "delivery-locations";
+    readonly packings: "packings";
+    readonly connections: "connections";
+    readonly customerStickers: "customer-stickers";
+    readonly additionalServices: "additional-services";
+    readonly commercialServiceTypes: "commercial-service-types";
+    readonly collections: "collections";
+    readonly priceGroups: "price-groups";
+    readonly deliveryConditionSets: "delivery-condition-sets";
+    readonly salesStrategies: "sales-strategies";
+    readonly baseItems: "base-items";
+    readonly contractTradeItemGroups: "contract-trade-item-groups";
+};
+export type GatewayEntity = (typeof GATEWAY_ENTITIES)[keyof typeof GATEWAY_ENTITIES];
+export declare function isGatewayEntity(value: unknown): value is GatewayEntity;
+/**
+ * Compat-bridge: zet een Supabase-cache-tabelnaam (`floriday_<x>_cache`) om
+ * naar de bijbehorende kebab-case entity. Alleen bedoeld als tijdelijke
+ * helper tijdens de migratie — nieuwe code geeft direct een `GatewayEntity`.
+ *
+ * Retourneert `undefined` wanneer er geen geldige mapping is.
+ */
+export declare function tableToEntity(cacheTable: string): GatewayEntity | undefined;
+//# sourceMappingURL=floriday-gateway-entities.d.ts.map

package/dist-lib/lib/floriday-gateway-entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-gateway-entities.d.ts","sourceRoot":"","sources":["../../src/lib/floriday-gateway-entities.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAwBnB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAIrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAM3E"}

package/dist-lib/lib/floriday-gateway-entities.js

@@ -0,0 +1,51 @@
+/**
+ * Whitelist van kebab-case Floriday-resource-namen die de centrale Auth-gateway
+ * accepteert op `/api/public/gateway/cached-list`. 1-op-1 overgenomen uit
+ * `src/routes/api/public/gateway/cached-list.ts` aan Auth-zijde.
+ *
+ * Componenten geven NOOIT een Supabase-tabelnaam (`floriday_<x>_cache`)
+ * door als `entity` — gebruik altijd de kebab-case key uit dit bestand.
+ */
+export const GATEWAY_ENTITIES = {
+    salesOrders: "sales-orders",
+    tradeItems: "trade-items",
+    customerOrganizations: "customer-organizations",
+    carriers: "carriers",
+    fulfillmentOrders: "fulfillment-orders",
+    deliveryOrders: "delivery-orders",
+    clockSupplies: "clock-supplies",
+    clockPresales: "clock-presales",
+    contracts: "contracts",
+    blanketOrders: "blanket-orders",
+    warehouses: "warehouses",
+    deliveryLocations: "delivery-locations",
+    packings: "packings",
+    connections: "connections",
+    customerStickers: "customer-stickers",
+    additionalServices: "additional-services",
+    commercialServiceTypes: "commercial-service-types",
+    collections: "collections",
+    priceGroups: "price-groups",
+    deliveryConditionSets: "delivery-condition-sets",
+    salesStrategies: "sales-strategies",
+    baseItems: "base-items",
+    contractTradeItemGroups: "contract-trade-item-groups",
+};
+const ALL = new Set(Object.values(GATEWAY_ENTITIES));
+export function isGatewayEntity(value) {
+    return typeof value === "string" && ALL.has(value);
+}
+/**
+ * Compat-bridge: zet een Supabase-cache-tabelnaam (`floriday_<x>_cache`) om
+ * naar de bijbehorende kebab-case entity. Alleen bedoeld als tijdelijke
+ * helper tijdens de migratie — nieuwe code geeft direct een `GatewayEntity`.
+ *
+ * Retourneert `undefined` wanneer er geen geldige mapping is.
+ */
+export function tableToEntity(cacheTable) {
+    const stripped = cacheTable
+        .replace(/^floriday_/, "")
+        .replace(/_cache$/, "")
+        .replace(/_/g, "-");
+    return isGatewayEntity(stripped) ? stripped : undefined;
+}