@flowselections/floriday-authenticatie-module 1.0.24 → 1.0.26

package/dist-lib/lib/gateway/supply-line.js

@@ -0,0 +1,261 @@
+// Gateway module: catalogusaanbod / prijs publiceren voor een trade-item.
+// Spiegel van src/routes/api/public/gateway/supply-line.ts.
+import { resolveGatewayEnvironment } from "./shared";
+import { florydayWrite, getActiveFlorydayCredentials } from "../floriday.functions";
+function pickNumber(...vals) {
+    for (const v of vals) {
+        if (typeof v === "number" && isFinite(v))
+            return v;
+        if (typeof v === "string" && v.trim() !== "") {
+            const n = Number(v.replace(",", "."));
+            if (isFinite(n))
+                return n;
+        }
+    }
+    return undefined;
+}
+function pickString(...vals) {
+    for (const v of vals)
+        if (typeof v === "string" && v.trim())
+            return v.trim();
+    return undefined;
+}
+function weekOfYear(date = new Date()) {
+    const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+    d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const week = Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    return { year: d.getUTCFullYear(), week };
+}
+function defaultPeriod() {
+    const start = new Date();
+    start.setUTCHours(0, 0, 0, 0);
+    const end = new Date(start);
+    end.setUTCDate(end.getUTCDate() + 7);
+    return { startDateTime: start.toISOString(), endDateTime: end.toISOString() };
+}
+function toFloridayPacking(config) {
+    if (!config || typeof config !== "object")
+        return undefined;
+    return {
+        loadCarrier: config.loadCarrier,
+        vbnPackageCode: config.vbnPackageCode ?? config.package?.vbnPackageCode,
+        packagesPerLayer: config.packagesPerLayer,
+        piecesPerPackage: config.piecesPerPackage,
+        layersPerLoadCarrier: config.layersPerLoadCarrier,
+    };
+}
+async function loadPrimaryPackingFromTradeItem(supabase, tradeItemId) {
+    const { data, error } = await supabase
+        .from("floriday_trade_items_cache")
+        .select("data")
+        .eq("floriday_id", tradeItemId)
+        .maybeSingle();
+    if (error || !data?.data)
+        return null;
+    const configs = data.data?.packingConfigurations;
+    if (!Array.isArray(configs) || configs.length === 0)
+        return null;
+    return toFloridayPacking(configs.find((c) => c?.primary) ?? configs[0]) ?? null;
+}
+async function loadUserIdForMapping(supabase, connectionId, tradeItemId) {
+    const { data } = await supabase
+        .from("trade_item_stock")
+        .select("user_id")
+        .eq("connection_id", connectionId)
+        .eq("trade_item_key", tradeItemId)
+        .limit(1)
+        .maybeSingle();
+    return data?.user_id ?? null;
+}
+async function persistSupplyMapping(supabase, row) {
+    const { data: existing } = await supabase
+        .from("trade_item_supply_lines")
+        .select("id")
+        .eq("connection_id", row.connection_id)
+        .eq("trade_item_id", row.trade_item_id)
+        .eq("supply_type", row.supply_type)
+        .eq("endpoint_family", row.endpoint_family)
+        .eq("year", row.year)
+        .eq("week", row.week)
+        .limit(1)
+        .maybeSingle();
+    if (existing?.id) {
+        await supabase.from("trade_item_supply_lines").update(row).eq("id", existing.id);
+        return;
+    }
+    if (row.user_id)
+        await supabase.from("trade_item_supply_lines").insert(row);
+}
+async function logGatewayStep(supabase, payload) {
+    await supabase.from("floriday_write_log").insert({
+        connection_id: payload.connection_id ?? null,
+        module: "gateway",
+        action: String(payload.action ?? "supply-line-step"),
+        resource: "gateway",
+        floriday_id: String(payload.tradeItemId ?? payload.supplyLineId ?? "") || null,
+        request: payload,
+        response: null,
+        http_status: payload.status ?? 0,
+        ok: Boolean(payload.ok),
+        error: payload.error ? String(payload.error).slice(0, 500) : null,
+        idempotency_key: null,
+        caller: String(payload.caller ?? "self"),
+    }).then(() => undefined, () => undefined);
+}
+export async function runSupplyLine(supabase, input) {
+    const raw = input.raw;
+    const caller = input.caller;
+    const tradeItemId = pickString(raw.tradeItemId, raw.trade_item_id, raw.itemId);
+    const pricePerPiece = pickNumber(raw.pricePerPiece, raw.price, raw.unitPrice, raw?.priceInformation?.pricePerPiece);
+    const availableQuantity = pickNumber(raw.availableQuantity, raw.quantity, raw.stock, raw.available);
+    const supplyType = raw.supplyType === "BATCH_PRICE" ? "BATCH_PRICE" : "CATALOG_PRICE";
+    const currency = pickString(raw.currency, raw?.priceInformation?.currency) ?? "EUR";
+    const salesUnit = pickString(raw.salesUnit) ?? "PIECE";
+    const missing = [];
+    if (!tradeItemId)
+        missing.push("tradeItemId");
+    if (pricePerPiece === undefined)
+        missing.push("pricePerPiece (of `price`)");
+    if (availableQuantity === undefined)
+        missing.push("availableQuantity (of `quantity` / `stock`)");
+    if (missing.length) {
+        return { status: 400, payload: { ok: false, error: `Ontbrekende velden: ${missing.join(", ")}.`, missing } };
+    }
+    try {
+        const environment = await resolveGatewayEnvironment(supabase, input.environment ?? raw.environment);
+        const conn = await getActiveFlorydayCredentials(supabase, environment);
+        if (!conn) {
+            return { status: 409, payload: { ok: false, error: `Geen actieve Floriday-koppeling voor ${environment}` } };
+        }
+        const customerIds = Array.isArray(raw.customerOrganizationIds)
+            ? raw.customerOrganizationIds.filter((v) => typeof v === "string" && v)
+            : [];
+        const userId = await loadUserIdForMapping(supabase, conn.id, tradeItemId);
+        // Structureel pad voor catalogusprijzen: geen supplyLineId, dus ook geen stale-id fallback meer.
+        if (supplyType === "CATALOG_PRICE") {
+            const explicitYear = pickNumber(raw.year, raw?.tradePeriod?.year);
+            const explicitWeek = pickNumber(raw.week, raw?.tradePeriod?.week);
+            const computed = weekOfYear(pickString(raw.periodStart, raw?.supplyPeriod?.periodStart) ? new Date(pickString(raw.periodStart, raw?.supplyPeriod?.periodStart)) : new Date());
+            const year = Math.trunc(explicitYear ?? computed.year);
+            const week = Math.trunc(explicitWeek ?? computed.week);
+            const baseSupplyBody = {
+                basePricePerPiece: { value: pricePerPiece, currency },
+                numberOfPieces: Math.max(0, Math.trunc(availableQuantity)),
+            };
+            const baseResult = await florydayWrite(supabase, environment, {
+                module: "catalog",
+                action: "upsert-weekly-base-supply",
+                method: "PUT",
+                path: `/trade-items/${encodeURIComponent(tradeItemId)}/base-supply/${year}/${week}`,
+                referenceId: tradeItemId,
+                body: baseSupplyBody,
+                caller,
+                idempotencyKey: `weekly-base-supply:${environment}:${tradeItemId}:${year}:${week}:${pricePerPiece}:${availableQuantity}`,
+            });
+            let availabilityResult = null;
+            if (raw.usesCatalogAvailability !== false) {
+                availabilityResult = await florydayWrite(supabase, environment, {
+                    module: "catalog",
+                    action: "set-trade-item-customer-offer-availability",
+                    method: "PUT",
+                    path: `/trade-items/${encodeURIComponent(tradeItemId)}/availability-for-customer-offers?isAvailableForCustomerOffers=true`,
+                    referenceId: tradeItemId,
+                    caller,
+                    idempotencyKey: `trade-item-offer-availability:${environment}:${tradeItemId}:true`,
+                });
+            }
+            await persistSupplyMapping(supabase, {
+                connection_id: conn.id,
+                user_id: userId,
+                environment,
+                trade_item_id: tradeItemId,
+                supply_type: supplyType,
+                endpoint_family: "weekly-base-supply",
+                supply_line_id: null,
+                year,
+                week,
+                price_per_piece: pricePerPiece,
+                available_quantity: availableQuantity,
+                currency,
+                sales_unit: salesUnit,
+                last_status: baseResult.status,
+                last_error: baseResult.error ?? null,
+                updated_at: new Date().toISOString(),
+            });
+            await logGatewayStep(supabase, {
+                action: "supply-line-resolved",
+                ok: baseResult.ok,
+                status: baseResult.status,
+                caller,
+                connection_id: conn.id,
+                environment,
+                tradeItemId,
+                oldEndpoint: "/supply-lines/{id}",
+                endpoint: `/trade-items/${tradeItemId}/base-supply/${year}/${week}`,
+                oldSupplyLineId: pickString(raw.supplyLineId, raw.id) ?? null,
+                newSupplyLineId: null,
+                mapping: { endpoint_family: "weekly-base-supply", year, week },
+                payload: baseSupplyBody,
+                error: baseResult.error ?? null,
+            });
+            return {
+                status: baseResult.ok ? 200 : baseResult.status || 500,
+                payload: {
+                    ok: baseResult.ok && (!availabilityResult || availabilityResult.ok),
+                    status: baseResult.status,
+                    environment,
+                    endpointFamily: "weekly-base-supply",
+                    tradeItemId,
+                    supplyLineId: null,
+                    year,
+                    week,
+                    attemptId: baseResult.attemptId,
+                    availabilityAttemptId: availabilityResult?.attemptId ?? null,
+                    error: baseResult.error ?? availabilityResult?.error,
+                    data: { baseSupply: baseResult.data, customerOfferAvailability: availabilityResult?.data ?? null },
+                },
+            };
+        }
+        // Batch-prijs blijft volgens 2026v1 via POST /supply-lines lopen.
+        const period = defaultPeriod();
+        const packingConfiguration = raw.packingConfiguration && typeof raw.packingConfiguration === "object"
+            ? toFloridayPacking(raw.packingConfiguration)
+            : await loadPrimaryPackingFromTradeItem(supabase, tradeItemId);
+        if (!packingConfiguration) {
+            return { status: 409, payload: { ok: false, error: "Kon geen fust-configuratie vinden voor dit product." } };
+        }
+        const supplyLineId = pickString(raw.supplyLineId, raw.id) ?? crypto.randomUUID();
+        const batchBody = {
+            supplyLineId,
+            batchId: pickString(raw.batchId) ?? supplyLineId,
+            tradeItemId,
+            pricePerPiece: { value: pricePerPiece, currency },
+            orderPeriod: raw.orderPeriod ?? period,
+            deliveryPeriod: raw.deliveryPeriod ?? period,
+            includedServices: Array.isArray(raw.includedServices) ? raw.includedServices : [],
+            packingConfigurations: [packingConfiguration],
+            allowedCustomerOrganizationIds: customerIds,
+            assignedNumberOfPieces: Math.max(0, Math.trunc(availableQuantity)),
+            onlyAsapDelivery: Boolean(raw.onlyAsapDelivery ?? false),
+        };
+        const result = await florydayWrite(supabase, environment, {
+            module: "catalog",
+            action: "create-batch-supply-line",
+            method: "POST",
+            path: "/supply-lines",
+            referenceId: supplyLineId,
+            body: batchBody,
+            caller,
+        });
+        return {
+            status: result.ok ? 200 : result.status || 500,
+            payload: { ok: result.ok, status: result.status, environment, endpointFamily: "batch-supply-line", supplyLineId, attemptId: result.attemptId, error: result.error, data: result.data },
+        };
+    }
+    catch (e) {
+        const msg = String(e?.message ?? e);
+        console.error("[gateway/supply-line] crashed:", msg);
+        return { status: 500, payload: { ok: false, error: msg } };
+    }
+}

package/dist-lib/lib/gateway/write.d.ts

@@ -0,0 +1,18 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export interface GatewayWriteBody {
+    environment: "staging" | "live";
+    module: string;
+    action: string;
+    method: "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    body?: unknown;
+    referenceId?: string;
+    idempotencyKey?: string;
+    validateEnums?: Array<{
+        field: string;
+        listName: string;
+    }>;
+}
+export declare function isValidGatewayWriteBody(input: unknown): input is GatewayWriteBody;
+export declare function runWrite(supabase: SupabaseClient, parsed: GatewayWriteBody, caller: string): Promise<import("../floriday.functions").FlorydayWriteResult>;
+//# sourceMappingURL=write.d.ts.map

package/dist-lib/lib/gateway/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../src/lib/gateway/write.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,SAAS,GAAG,MAAM,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CASjF;AAED,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,MAAM,gEAaf"}

package/dist-lib/lib/gateway/write.js

@@ -0,0 +1,32 @@
+// Gateway module: generieke schrijfactie naar Floriday.
+// Spiegel van src/routes/api/public/gateway/write.ts (business-logica).
+import { florydayWrite } from "../floriday.functions";
+export function isValidGatewayWriteBody(input) {
+    if (!input || typeof input !== "object")
+        return false;
+    const o = input;
+    if (o.environment !== "staging" && o.environment !== "live")
+        return false;
+    if (typeof o.module !== "string" || !o.module)
+        return false;
+    if (typeof o.action !== "string" || !o.action)
+        return false;
+    if (typeof o.path !== "string" || !o.path)
+        return false;
+    if (!["POST", "PUT", "PATCH", "DELETE"].includes(o.method))
+        return false;
+    return true;
+}
+export async function runWrite(supabase, parsed, caller) {
+    return florydayWrite(supabase, parsed.environment, {
+        module: parsed.module,
+        action: parsed.action,
+        method: parsed.method,
+        path: parsed.path,
+        body: parsed.body,
+        referenceId: parsed.referenceId,
+        idempotencyKey: parsed.idempotencyKey,
+        validateEnums: parsed.validateEnums,
+        caller,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowselections/floriday-authenticatie-module",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "sideEffects": false,
   "type": "module",
   "main": "./dist-lib/index.js",