@flowselections/floriday-voorraad 1.0.30 → 1.0.32

package/dist-lib/lib/module-runtime.server.js

@@ -0,0 +1,184 @@
+/**
+ * Zelfregistratie van de module in de database waarin hij draait.
+ *
+ * De cron-functies `run_logistics_tasks_dispatch()` en
+ * `run_floriday_continuous_stock_sync()` bevatten geen hardgecodeerde host:
+ * ze lezen `module_runtime_config.voorraad_base_url` en
+ * `module_runtime_config.voorraad_hook_apikey`. Dit bestand schrijft die twee
+ * waarden weg zodra de module ergens een request afhandelt, zodat de cron
+ * out-of-the-box werkt in elke shell/database waar de module wordt gehangen —
+ * zonder handmatige instellingen en zonder iets in de UI.
+ *
+ * Server-only: nooit importeren vanuit componenten of client-code.
+ */
+const BASE_URL_KEY = "voorraad_base_url";
+const APIKEY_KEY = "voorraad_hook_apikey";
+/** Niet vaker dan eens per 5 minuten per worker-instantie schrijven. */
+const THROTTLE_MS = 5 * 60000;
+let lastRunAt = 0;
+let inFlight = null;
+function normalizeOrigin(raw) {
+    const trimmed = String(raw ?? "").trim();
+    if (!trimmed)
+        return null;
+    try {
+        const u = new URL(trimmed);
+        if (u.protocol !== "https:" && u.protocol !== "http:")
+            return null;
+        const host = u.hostname.toLowerCase();
+        // Lokale dev-origins nooit registreren: pg_net kan die niet bereiken.
+        if (host === "localhost" ||
+            host === "127.0.0.1" ||
+            host === "0.0.0.0" ||
+            host === "::1" ||
+            host.endsWith(".local")) {
+            return null;
+        }
+        return `${u.protocol}//${u.host}`;
+    }
+    catch {
+        return null;
+    }
+}
+function originFromRequest(request) {
+    if (!request)
+        return null;
+    const forwardedHost = request.headers.get("x-forwarded-host") ?? request.headers.get("host");
+    if (forwardedHost) {
+        const proto = request.headers.get("x-forwarded-proto") ?? "https";
+        const fromHeaders = normalizeOrigin(`${proto}://${forwardedHost}`);
+        if (fromHeaders)
+            return fromHeaders;
+    }
+    return normalizeOrigin(request.url);
+}
+/** Pad dat de cron aanroept; wordt ook gebruikt om een host te verifiëren. */
+const PROBE_PATH = "/api/public/hooks/floriday-continuous-stock";
+/**
+ * Controleert of een host deze module écht bedient.
+ *
+ * Zonder deze check kan een shell-host worden vastgelegd die de module niet
+ * host: de cron krijgt dan eeuwig een 404-HTML-pagina terug en de wachtrij
+ * blijft ongemerkt staan. Zonder apikey hoort het endpoint 401 te geven —
+ * dat bewijst dat de route bestaat, zonder iets te verwerken.
+ */
+async function servesModule(baseUrl) {
+    try {
+        const res = await fetch(`${baseUrl}${PROBE_PATH}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: "{}",
+            signal: AbortSignal.timeout(8000),
+        });
+        return res.status === 401 || res.status === 200;
+    }
+    catch {
+        return false;
+    }
+}
+/** Kandidaten, in volgorde: PUBLIC_BASE_URL → request-origin → centrale shell-host. */
+async function baseUrlCandidates(request) {
+    const out = [];
+    const push = (v) => {
+        if (v && !out.includes(v))
+            out.push(v);
+    };
+    push(normalizeOrigin(process.env.PUBLIC_BASE_URL));
+    push(originFromRequest(request));
+    try {
+        const { getShellHost } = await import("./centralSecrets.server");
+        push(normalizeOrigin(await getShellHost()));
+    }
+    catch {
+        // centrale module niet bereikbaar
+    }
+    return out;
+}
+/**
+ * Resolutie met verificatie: de eerste kandidaat die de module daadwerkelijk
+ * bedient wint. Bedient geen enkele kandidaat de module, dan wordt er niets
+ * geregistreerd (de bestaande, werkende waarde blijft staan).
+ */
+export async function resolveModuleBaseUrl(request) {
+    const candidates = await baseUrlCandidates(request);
+    for (const candidate of candidates) {
+        if (await servesModule(candidate))
+            return candidate;
+    }
+    return null;
+}
+function hookApiKey() {
+    const key = process.env.SUPABASE_PUBLISHABLE_KEY ??
+        process.env.SUPABASE_ANON_KEY ??
+        process.env.VITE_SUPABASE_PUBLISHABLE_KEY ??
+        "";
+    return key.trim() ? key.trim() : null;
+}
+async function upsertConfig(supabaseAdmin, key, value) {
+    const { data: existing } = await supabaseAdmin
+        .from("module_runtime_config")
+        .select("value")
+        .eq("key", key)
+        .maybeSingle();
+    if (existing?.value === value)
+        return false;
+    const { error } = await supabaseAdmin
+        .from("module_runtime_config")
+        .upsert({ key, value, updated_at: new Date().toISOString() }, { onConflict: "key" });
+    if (error)
+        throw new Error(error.message);
+    return true;
+}
+/** Schrijft basis-URL + hook-apikey weg (idempotent, schrijft alleen bij wijziging). */
+export async function registerModuleRuntime(request) {
+    const baseUrl = await resolveModuleBaseUrl(request);
+    if (!baseUrl) {
+        return { ok: false, baseUrl: null, changed: false, reason: "geen origin resolvbaar" };
+    }
+    try {
+        const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+        let changed = await upsertConfig(supabaseAdmin, BASE_URL_KEY, baseUrl);
+        const apikey = hookApiKey();
+        if (apikey) {
+            const apikeyChanged = await upsertConfig(supabaseAdmin, APIKEY_KEY, apikey);
+            changed = changed || apikeyChanged;
+        }
+        return { ok: true, baseUrl, changed };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            baseUrl,
+            changed: false,
+            reason: e?.message ?? String(e),
+        };
+    }
+}
+/**
+ * Fire-and-forget variant met throttle; veilig om bij élk request aan te roepen.
+ * Faalt nooit hard en logt alleen bij een echte fout.
+ */
+export function ensureModuleRuntimeRegistered(request) {
+    const now = Date.now();
+    if (inFlight || now - lastRunAt < THROTTLE_MS)
+        return;
+    lastRunAt = now;
+    inFlight = registerModuleRuntime(request)
+        .then((res) => {
+        if (!res.ok) {
+            // Mislukt: throttle resetten zodat een volgend request het opnieuw probeert.
+            lastRunAt = 0;
+            console.warn(`[voorraad] zelfregistratie mislukt: ${res.reason ?? "onbekend"}`);
+        }
+        else if (res.changed) {
+            console.info(`[voorraad] runtime geregistreerd op ${res.baseUrl}`);
+        }
+    })
+        .catch((e) => {
+        lastRunAt = 0;
+        console.warn("[voorraad] zelfregistratie fout:", e?.message ?? e);
+    })
+        .finally(() => {
+        inFlight = null;
+    });
+}