@flowselections/floriday-voorraad 1.0.82 → 1.0.86

package/dist-lib/server-hooks/trade-item-photo.js

@@ -0,0 +1,354 @@
+/**
+ * Upload-handler voor artikelfoto's (losse app én Shell via flowselections.serverRoutes).
+ * Alleen ingelogde gebruikers van deze database (sessie-bearer); de gateway-
+ * sleutel blijft server-side. Server-only.
+ *
+ * Flow (§14.11):
+ *  1. Browser POSTet multipart/form-data met `file` en optioneel `tradeItemId`.
+ *  2. Wij verifiëren de Supabase-bearer en bepalen de actieve koppeling zelf.
+ *  3. We sturen de RAW bytes door naar /api/public/gateway/media-upload —
+ *     géén base64-inflatie, géén formData-rebuild. HMAC zit in
+ *     gatewayMediaUpload (server-only secret).
+ */
+import { createClient } from "@supabase/supabase-js";
+function json(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function messageForReason(reason) {
+    switch (reason) {
+        case "image_too_small":
+            return "De foto is te klein. Gebruik een foto van minstens 640 × 640 pixels.";
+        case "image_too_large":
+            return "De foto is te groot. Gebruik een foto van maximaal 5 MB.";
+        case "unsupported_type":
+            return "Dit bestandstype kan niet. Gebruik een JPG- of PNG-foto.";
+        case "invalid_payload":
+            return "Floriday accepteert deze foto niet. Probeer een andere foto.";
+        case "network":
+            return "Floriday is even niet bereikbaar. Probeer het zo opnieuw.";
+        case "not_logged_in":
+            return "Je bent uitgelogd. Log opnieuw in en probeer het nog eens.";
+        case "not_connected":
+        case "config_missing":
+            return "De koppeling met Floriday werkt niet. Neem contact op met Flow Selections.";
+        default:
+            return "Foto kon niet worden geüpload. Probeer het opnieuw.";
+    }
+}
+function classifyGatewayError(status, message) {
+    const m = message.toLowerCase();
+    if (m.includes("resolution") || m.includes("640") || m.includes("too small") || m.includes("dimensions")) {
+        return "image_too_small";
+    }
+    if (m.includes("5mb") || m.includes("too large") || m.includes("size") && m.includes("exceed")) {
+        return "image_too_large";
+    }
+    if (m.includes("unsupported") || m.includes("content-type") || m.includes("media type")) {
+        return "unsupported_type";
+    }
+    if (status && status >= 500)
+        return "network";
+    if (status && status >= 400 && status < 500)
+        return "invalid_payload";
+    return "unknown";
+}
+function sanitizeDetail(msg) {
+    // Verwijder tokens/headers/HMAC uit de error-string voordat we het naar
+    // de browser sturen. Alleen de eerste 240 tekens zijn nuttig voor UX.
+    return msg
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer ***")
+        .replace(/(x-hmac[^:]*:\s*)[A-Fa-f0-9]+/gi, "$1***")
+        .replace(/(authorization[^:]*:\s*)[^\s,]+/gi, "$1***")
+        .slice(0, 240);
+}
+function uploadFailed(reason, extra = {}) {
+    // Bewust géén HTTP 502/5xx naar de browser: Lovable preview toont zulke
+    // route-responses als runtime error/blank screen. De client krijgt een
+    // typed failure terug en beslist zelf over retry + vriendelijke melding.
+    const retryable = reason === "network" || reason === "unknown";
+    return json({
+        ok: false,
+        error: "upload-mislukt",
+        reason,
+        message: messageForReason(reason),
+        retryable,
+        ...extra,
+    }, 200);
+}
+/** Herkent jpg/png aan de eerste bytes (niet aan bestandsnaam of browsertype). */
+function sniffType(b) {
+    if (b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff)
+        return "image/jpeg";
+    if (b.length >= 8 && b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47)
+        return "image/png";
+    return null;
+}
+/** Breedte/hoogte uit PNG-IHDR of JPEG-SOF-marker. */
+export function imageSize(b) {
+    const t = sniffType(b);
+    if (t === "image/png" && b.length >= 24) {
+        const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+        return { w: dv.getUint32(16), h: dv.getUint32(20) };
+    }
+    if (t === "image/jpeg") {
+        let i = 2;
+        while (i + 9 < b.length) {
+            if (b[i] !== 0xff) {
+                i++;
+                continue;
+            }
+            const m = b[i + 1];
+            const len = (b[i + 2] << 8) | b[i + 3];
+            if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) {
+                return { h: (b[i + 5] << 8) | b[i + 6], w: (b[i + 7] << 8) | b[i + 8] };
+            }
+            i += 2 + len;
+        }
+    }
+    return null;
+}
+const MAX_BYTES = 5 * 1024 * 1024;
+const MIN_SIDE = 640;
+export function checkImage(head, size) {
+    if (!sniffType(head))
+        return { reason: "unsupported_type", detail: "geen jpg/png-handtekening" };
+    if (size > MAX_BYTES)
+        return { reason: "image_too_large", detail: `${size} bytes > ${MAX_BYTES}` };
+    const dim = imageSize(head);
+    if (!dim)
+        return { reason: "invalid_payload", detail: "afmeting niet leesbaar" };
+    if (dim.w < MIN_SIDE || dim.h < MIN_SIDE) {
+        return { reason: "image_too_small", detail: `${dim.w}x${dim.h} < ${MIN_SIDE}x${MIN_SIDE}` };
+    }
+    return null;
+}
+function plainFail(reason, status, detail) {
+    return json({ ok: false, reason, message: messageForReason(reason), detail }, status);
+}
+export async function handleTradeItemPhoto(request) {
+    if (request.method === "OPTIONS")
+        return new Response(null, { status: 204 });
+    if (request.method !== "POST")
+        return json({ error: "Method not allowed" }, 405);
+    try {
+        const SUPABASE_URL = process.env.SUPABASE_URL;
+        const SUPABASE_PUBLISHABLE_KEY = process.env.SUPABASE_PUBLISHABLE_KEY;
+        if (!SUPABASE_URL || !SUPABASE_PUBLISHABLE_KEY) {
+            return plainFail("config_missing", 500, "SUPABASE_URL/SUPABASE_PUBLISHABLE_KEY ontbreekt op de server");
+        }
+        // --- 1. Bearer-validatie -------------------------------------------------
+        const authHeader = request.headers.get("authorization");
+        if (!authHeader)
+            return plainFail("not_logged_in", 401, "Unauthorized: geen bearer");
+        if (!authHeader.startsWith("Bearer "))
+            return plainFail("not_logged_in", 401, "Unauthorized: alleen Bearer-tokens");
+        const token = authHeader.slice("Bearer ".length).trim();
+        if (!token)
+            return plainFail("not_logged_in", 401, "Unauthorized: leeg token");
+        const supabase = createClient(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY, {
+            global: { headers: { Authorization: `Bearer ${token}` } },
+            auth: { storage: undefined, persistSession: false, autoRefreshToken: false },
+        });
+        const { data: claimsData, error: claimsErr } = await supabase.auth.getClaims(token);
+        if (claimsErr || !claimsData?.claims?.sub) {
+            return plainFail("not_logged_in", 401, "Unauthorized: token ongeldig");
+        }
+        // --- 2. Multipart body ---------------------------------------------------
+        let form;
+        try {
+            form = await request.formData();
+        }
+        catch {
+            return json({ error: "Bad request: multipart/form-data verwacht" }, 400);
+        }
+        // Oude clients kunnen nog een connectionId meesturen. Deze waarde is
+        // nooit leidend: de actieve koppeling wordt hieronder server-side
+        // bepaald. Zo kan een browser nooit een koppeling/account kiezen.
+        const clientConnectionId = String(form.get("connectionId") ?? "").trim();
+        const tradeItemId = form.get("tradeItemId")
+            ? String(form.get("tradeItemId"))
+            : null;
+        const file = form.get("file");
+        if (!(file instanceof Blob))
+            return json({ error: "file ontbreekt of geen Blob" }, 400);
+        if (file.size === 0)
+            return json({ error: "Leeg bestand" }, 400);
+        const filename = file.name ||
+            `photo-${Date.now()}.${(file.type || "image/jpeg").split("/")[1] ?? "jpg"}`;
+        const headBytes = new Uint8Array(await file.slice(0, 256 * 1024).arrayBuffer());
+        const check = checkImage(headBytes, file.size);
+        if (check)
+            return uploadFailed(check.reason, { detail: check.detail });
+        const contentType = sniffType(headBytes) ?? "image/jpeg";
+        // --- 3. Actieve koppeling + omgeving via de gedeelde bron ---------------
+        let environment;
+        try {
+            const { checkFloridayReadiness } = await import("../lib/floriday-readiness.server.js");
+            const readiness = await checkFloridayReadiness(supabase);
+            if (!readiness.ready || !readiness.connectionId || !readiness.environment) {
+                return plainFail("not_connected", 409, `FLORIDAY_NOT_READY: ${readiness.message}`);
+            }
+            if (clientConnectionId && readiness.connectionId !== clientConnectionId) {
+                return json({
+                    error: "De verbinding is gewijzigd. Vernieuw de pagina en probeer opnieuw.",
+                }, 409);
+            }
+            environment = readiness.environment;
+        }
+        catch (e) {
+            const { FloridayEnvError } = await import("../lib/floriday-env.js");
+            if (e instanceof FloridayEnvError) {
+                return plainFail("not_connected", 400, `${e.code}: ${e.message}`);
+            }
+            throw e;
+        }
+        // --- 4. Raw bytes doorsturen naar de centrale gateway -------------------
+        const buf = new Uint8Array(await file.arrayBuffer());
+        const hashBuf = await crypto.subtle.digest("SHA-256", buf);
+        const hashHex = Array.from(new Uint8Array(hashBuf))
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("");
+        const idempotencyKey = `inventory:image:${tradeItemId ?? "anon"}:${hashHex.slice(0, 16)}`;
+        // Floriday Suppliers API 2026v1: POST /media (operatie AddImage),
+        // multipart/form-data met verplicht form-veld "image".
+        // LET OP: de gateway plakt het pad achter https://api.[staging.]floriday.io
+        // ZONDER versie-prefix — die moet dus in het pad zelf zitten.
+        const path = "/suppliers-api-2026v1/media";
+        const requestTimestamp = Date.now();
+        const clientUserId = claimsData.claims.sub;
+        const reportFailure = async (info) => {
+            // (a) push naar Auth-module diagnostics-endpoint
+            try {
+                const { reportGatewayFailure } = await import("../lib/floriday-gateway.server.js");
+                await reportGatewayFailure({
+                    module: "inventory",
+                    action: "media-upload",
+                    environment,
+                    path,
+                    referenceId: tradeItemId ?? null,
+                    idempotencyKey,
+                    attemptNumber: info.attemptNumber,
+                    requestTimestamp,
+                    requestBodyHash: hashHex,
+                    fileMeta: {
+                        filename,
+                        contentType,
+                        sizeBytes: buf.byteLength,
+                    },
+                    responseStatus: info.responseStatus ?? null,
+                    responseContentType: info.responseContentType ?? null,
+                    responseSnippet: info.responseSnippet?.slice(0, 500) ?? null,
+                    errorMessage: info.errorMessage,
+                    clientUserId,
+                });
+            }
+            catch (e) {
+                console.warn("[trade-item-photo] reportGatewayFailure faalde", e);
+            }
+            // (b) eigen audit-tabel (zonder snippet)
+            try {
+                const { getAdminClient } = await import("../lib/supabase-admin.server.js");
+                const supabaseAdmin = getAdminClient();
+                const { error: insErr } = await supabaseAdmin
+                    .from("voorraad_media_upload_failures")
+                    .insert({
+                    environment,
+                    path,
+                    reference_id: tradeItemId ?? null,
+                    idempotency_key: idempotencyKey,
+                    attempt_number: info.attemptNumber,
+                    request_timestamp: requestTimestamp,
+                    request_body_hash: hashHex,
+                    filename,
+                    content_type: contentType,
+                    size_bytes: buf.byteLength,
+                    response_status: info.responseStatus ?? null,
+                    response_content_type: info.responseContentType ?? null,
+                    error_message: info.errorMessage,
+                    client_user_id: clientUserId,
+                });
+                if (insErr) {
+                    console.error("[trade-item-photo] audit-insert error", insErr.message, insErr.details);
+                }
+            }
+            catch (e) {
+                console.warn("[trade-item-photo] audit-insert faalde", e);
+            }
+        };
+        try {
+            const { gatewayMediaUpload } = await import("../lib/floriday-gateway.server.js");
+            const res = await gatewayMediaUpload({
+                caller: "voorraad",
+                environment: environment,
+                path,
+                method: "POST",
+                filename,
+                contentType,
+                bytes: buf,
+                formField: "image", // Floriday POST /media vereist form-veld "image"
+                referenceId: tradeItemId ?? undefined,
+                idempotencyKey,
+            });
+            // Floriday 2026v1 levert { mediaId: "<uuid>" } terug op POST /media.
+            const mediaId = (res.data &&
+                (res.data.mediaId ||
+                    res.data.imageId ||
+                    res.data.id)) ||
+                null;
+            const host = environment === "live"
+                ? "https://image.floriday.io"
+                : "https://image.staging.floriday.io";
+            // Docs: https://image.[staging.]floriday.io/{mediaId}.{ext}
+            const ext = contentType === "image/png" ? "png" : "jpg";
+            const url = mediaId
+                ? `${host}/${mediaId}.${ext}`
+                : (res.data && (res.data.url || res.data.imageUrl)) || null;
+            if (!mediaId || !url) {
+                const snippet = JSON.stringify(res.data ?? {}).slice(0, 500);
+                console.error("[trade-item-photo] geen mediaId", { status: res.status, snippet, filename, contentType, size: buf.byteLength });
+                await reportFailure({
+                    attemptNumber: 1,
+                    responseStatus: res.status ?? null,
+                    responseContentType: "application/json",
+                    responseSnippet: snippet,
+                    errorMessage: "Gateway leverde geen mediaId terug",
+                });
+                return uploadFailed("invalid_payload", {
+                    attemptId: res.attemptId ?? null,
+                    gatewayStatus: res.status ?? null,
+                    detail: sanitizeDetail(snippet),
+                });
+            }
+            return json({ ok: true, url, imageId: mediaId, mediaId, attemptId: res.attemptId });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            // Probeer status/content-type uit de error-tekst te halen (gateway
+            // gooit messages als "gateway media-upload → niet-JSON antwoord
+            // (status=502)").
+            const statusMatch = /status=(\d{3})/.exec(msg);
+            const responseStatus = statusMatch ? Number(statusMatch[1]) : null;
+            const reason = classifyGatewayError(responseStatus, msg);
+            console.error("[trade-item-photo] gateway-fout", { reason, responseStatus, msg, filename, contentType, size: buf.byteLength, tradeItemId });
+            await reportFailure({
+                attemptNumber: 1,
+                responseStatus,
+                responseContentType: null,
+                responseSnippet: msg.slice(0, 500),
+                errorMessage: msg,
+            });
+            return uploadFailed(reason, {
+                gatewayStatus: responseStatus,
+                detail: sanitizeDetail(msg),
+            });
+        }
+    }
+    catch (outer) {
+        const msg = outer instanceof Error ? outer.message : String(outer);
+        console.error("[trade-item-photo] unhandled", msg, outer?.stack);
+        return plainFail("unknown", 500, sanitizeDetail(`Interne fout: ${msg}`));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowselections/floriday-voorraad",
-  "version": "1.0.82",
+  "version": "1.0.86",
   "sideEffects": false,
   "type": "module",
   "main": "./dist-lib/index.js",
@@ -158,6 +158,15 @@
           "POST",
           "OPTIONS"
         ]
+      },
+      {
+        "routePath": "/api/trade-item-photo",
+        "import": "@flowselections/floriday-voorraad/hooks",
+        "handler": "handleTradeItemPhoto",
+        "methods": [
+          "POST",
+          "OPTIONS"
+        ]
       }
     ]
   }