@flowselections/floriday-authenticatie-module 1.0.31 → 1.0.35

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

@@ -104,65 +104,56 @@ export async function getActiveFlorydayCredentials(supabase, env) {
         throw new Error(`Kan Floriday-credentials niet laden: ${error.message}`);
     return data;
 }
+// In-memory tokencache. Central Auth is de token-broker: die cachet en grant
+// zelf opnieuw. Deze module bewaart daarom niets in de database en heeft geen
+// eigen refresh-timer; hoogstens een procesgebonden cache tot kort voor
+// `expires_at`. Scoped tokens (smallere scope dan de standaard) worden bewust
+// NIET gecacht — die worden per gebruik opgevraagd.
+const tokenCache = new Map();
 export async function getFlorydayAccessToken(supabase, env, options = {}) {
-    const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
     const row = await getActiveFlorydayCredentials(supabase, env);
-    if (!row)
-        throw new Error(`Geen actieve Floriday-koppeling voor ${env}`);
     const requestedScope = options.scope ?? DEFAULT_SCOPE;
-    const canReuseStoredToken = requestedScope === DEFAULT_SCOPE;
+    const isDefaultScope = requestedScope === DEFAULT_SCOPE;
+    const cacheKey = `${env}:${requestedScope}`;
     const now = Date.now();
-    const expiresAt = row.token_expires_at ? Date.parse(row.token_expires_at) : 0;
-    if (canReuseStoredToken && !options.forceRefresh && row.access_token && expiresAt - TOKEN_REFRESH_LEEWAY_S * 1000 > now) {
-        return row.access_token;
-    }
-    // Concurrency-guard: vlak voor de tokenrequest opnieuw lezen — een parallelle worker
-    // kan zojuist een fresh token hebben geschreven en dan hoeven we niet nóg eens te refreshen.
-    if (canReuseStoredToken && !options.forceRefresh) {
-        const { data: fresh } = await supabaseAdmin
-            .from("floriday_connections")
-            .select("access_token, token_expires_at")
-            .eq("id", row.id)
-            .maybeSingle();
-        const freshExp = fresh?.token_expires_at ? Date.parse(fresh.token_expires_at) : 0;
-        if (fresh?.access_token && freshExp - TOKEN_REFRESH_LEEWAY_S * 1000 > now) {
-            return fresh.access_token;
+    if (isDefaultScope && !options.forceRefresh) {
+        const hit = tokenCache.get(cacheKey);
+        if (hit && hit.expiresAt - TOKEN_REFRESH_LEEWAY_S * 1000 > now) {
+            return hit.token;
         }
     }
-    let accessToken;
-    let newExpiresAt;
     try {
         const { getFlorydayTokenFromCentral } = await import("./central-auth.server.js");
-        const result = await getFlorydayTokenFromCentral(env, requestedScope);
+        const result = await getFlorydayTokenFromCentral(env, options.scope, "default");
         if (!result.ok) {
             throw createFlorydayTokenError(result.raw.status, result.raw.body, requestedScope);
         }
-        accessToken = result.access_token;
-        newExpiresAt = result.expires_at;
-        if (canReuseStoredToken) {
-            await supabaseAdmin
-                .from("floriday_connections")
-                .update({ access_token: accessToken, token_expires_at: newExpiresAt })
-                .eq("id", row.id);
+        const accessToken = result.access_token;
+        const newExpiresAt = result.expires_at;
+        if (isDefaultScope) {
+            tokenCache.set(cacheKey, {
+                token: accessToken,
+                expiresAt: Date.parse(newExpiresAt) || now,
+            });
         }
         // Best-effort logging (faalt nooit hard).
         await supabase.from("floriday_token_refresh_log").insert({
-            connection_id: row.id,
+            connection_id: row?.id ?? null,
             environment: env,
             ok: true,
             expires_at: newExpiresAt,
         }).then(() => undefined, () => undefined);
+        return accessToken;
     }
     catch (e) {
         await supabase.from("floriday_token_refresh_log").insert({
-            connection_id: row.id,
+            connection_id: row?.id ?? null,
             environment: env,
             ok: false,
             error: String(e?.message ?? e).slice(0, 500),
         }).then(() => undefined, () => undefined);
         throw e;
     }
-    return accessToken;
 }
 function createFlorydayTokenError(status, body, scope) {
     const normalized = body.toLowerCase();
@@ -181,8 +172,38 @@ function createFlorydayTokenError(status, body, scope) {
             return new Error(FLORYDAY_CONTRACT_PERMISSION_MESSAGE);
         }
     }
+    // Central Auth antwoordt opaak en in het Engels; hier vertalen we naar een
+    // melding waar een beheerder iets mee kan. Status én body blijven gelogd in
+    // central-auth.server.ts.
+    const centralMessage = mapCentralAuthError(status, normalized);
+    if (centralMessage)
+        return new Error(centralMessage);
     return new Error(`Floriday token-aanvraag mislukt [${status}]: ${body.slice(0, 300)}`);
 }
+function mapCentralAuthError(status, normalizedBody) {
+    if (status === 401) {
+        return "Central Auth weigert dit bearer-secret. Controleer CENTRAL_AUTH_SECRET van deze omgeving.";
+    }
+    if (status === 404) {
+        return "Central Auth is niet gevonden op dit adres. Controleer CENTRAL_AUTH_URL (basis-URL van de Central Auth-module, zonder pad).";
+    }
+    if (status === 409 || normalizedBody.includes("not_connected")) {
+        return "Er is nog geen actieve Floriday-credential voor deze omgeving in Central Auth. De beheerder moet die daar invoeren.";
+    }
+    if (status === 400 && normalizedBody.includes("ambiguous_account")) {
+        return "Central Auth vond meerdere Floriday-accounts voor deze omgeving; er moet een specifieke account_key worden meegestuurd.";
+    }
+    if (status === 400) {
+        return "Central Auth wees de aanvraag af als ongeldig (ongeldige omgeving of scope-formaat).";
+    }
+    if (status === 502 || normalizedBody.includes("upstream_error")) {
+        return "Floriday weigerde de tokenaanvraag via Central Auth. Controleer de Floriday-credential van deze omgeving in Central Auth.";
+    }
+    if (status >= 500) {
+        return "Central Auth is tijdelijk niet beschikbaar; de volgende ronde probeert het automatisch opnieuw.";
+    }
+    return null;
+}
 async function fetchAndStoreFlorydayOrganizationName(supabase, env, connectionId) {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
     try {
@@ -324,9 +345,28 @@ export const getFlorydayTokenHealth = createServerFn({ method: "GET" })
         .select("connection_id, attempted_at, ok, error, expires_at")
         .order("attempted_at", { ascending: false })
         .limit(20);
+    // Central Auth is de bron van de tokenstatus. Bij client_credentials
+    // betekent een verlopen expiry alleen "recent niet gebruikt" — nooit
+    // "kapot" — dus geven we die informatie apart mee.
+    const { getFlorydayAccountsFromCentral } = await import("./central-auth.server.js");
+    const central = {};
+    for (const env of ["staging", "live"]) {
+        try {
+            const res = await getFlorydayAccountsFromCentral(env);
+            central[env] = res.ok
+                ? { ok: true, accounts: res.accounts }
+                : { ok: false, status: res.raw.status };
+        }
+        catch (e) {
+            central[env] = { ok: false, error: String(e?.message ?? e).slice(0, 200) };
+        }
+    }
     return {
         connections: conns ?? [],
         recent: log ?? [],
+        central,
+        broker: "central-auth",
+        note: "Tokens worden door Central Auth beheerd; een verlopen expiry betekent alleen dat het token recent niet is gebruikt.",
     };
 });
 export const forceRefreshFlorydayToken = createServerFn({ method: "POST" })
@@ -338,15 +378,17 @@ export const forceRefreshFlorydayToken = createServerFn({ method: "POST" })
     return input;
 })
     .handler(async ({ data, context }) => {
-    const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
+    // Vraagt Central Auth om een fris token; niets wordt in de database bewaard.
     await getFlorydayAccessToken(context.supabase, data.environment, { forceRefresh: true });
-    const { data: row } = await supabaseAdmin
-        .from("floriday_connections")
-        .select("token_expires_at")
+    const { data: log } = await context.supabase
+        .from("floriday_token_refresh_log")
+        .select("expires_at")
         .eq("environment", data.environment)
-        .eq("is_active", true)
+        .eq("ok", true)
+        .order("attempted_at", { ascending: false })
+        .limit(1)
         .maybeSingle();
-    return { ok: true, expires_at: row?.token_expires_at ?? null };
+    return { ok: true, expires_at: log?.expires_at ?? null };
 });
 export const upsertFlorydayConnection = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
@@ -533,14 +575,15 @@ export const testFlorydayConnection = createServerFn({ method: "POST" })
  * Volgorde (eerste hit wint):
  *  1. `FLORIDAY_CRON_BASE_URL`  — custom domain of override
  *  2. `LOVABLE_PROJECT_ID`      → `https://project--{id}.lovable.app`
- *  3. Hardcoded fallback voor dít project
+ *
+ * Geen hardcoded fallback: in een nieuwe shell moet dit zichtbaar falen in
+ * plaats van stil naar een ander project te schrijven.
  *
  * Bewust NIET terugvallen op `VITE_SUPABASE_PROJECT_ID` /
  * `SUPABASE_PROJECT_ID`: die bevatten de Supabase project-ref, niet de
  * Lovable project-ID — gebruik daarvan was de oorzaak van een stille
  * cron-mismatch waardoor tokens nooit werden ververst.
  */
-const HARDCODED_LOVABLE_PROJECT_ID = "27b6733b-2e2f-4518-b204-681958559055";
 const MANAGED_FLORYDAY_CRON_JOB_NAMES = new Set([
     "refresh-floriday-tokens-hourly",
     "floriday-connections-sync-twice-daily",
@@ -569,12 +612,14 @@ const MANAGED_FLORYDAY_CRON_JOB_NAMES = new Set([
     "floriday-contract-trade-item-groups-sync-hourly",
     // Referentiedata (schema + code-lijsten)
     "floriday-reference-data-refresh-daily",
+    // Voorraad-wachtrij
+    "floriday-stock-queue-process",
 ]);
 export function resolveFlorydayCronBaseUrl() {
     const custom = process.env.FLORIDAY_CRON_BASE_URL?.trim();
     if (custom)
         return custom.replace(/\/+$/, "");
-    const lovableId = process.env.LOVABLE_PROJECT_ID?.trim() || HARDCODED_LOVABLE_PROJECT_ID;
+    const lovableId = process.env.LOVABLE_PROJECT_ID?.trim();
     if (!lovableId) {
         throw new Error("Kan cron-URL niet bepalen: zet FLORIDAY_CRON_BASE_URL of LOVABLE_PROJECT_ID");
     }
@@ -599,7 +644,10 @@ export const setupFlorydayTokenRefreshCron = createServerFn({ method: "POST" })
 export const getFlorydaySettings = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
-    const env = await getActiveFlorydayEnvironment(context.supabase);
+    // `floriday_settings` staat onder default-deny RLS; lezen met de user-client
+    // levert stil 0 rijen op (en dus de "staging"-fallback). Service-role lezen.
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
+    const env = await getActiveFlorydayEnvironment(supabaseAdmin);
     return { active_environment: env };
 });
 export const setFlorydayActiveEnvironment = createServerFn({ method: "POST" })
@@ -611,7 +659,8 @@ export const setFlorydayActiveEnvironment = createServerFn({ method: "POST" })
     return input;
 })
     .handler(async ({ data, context }) => {
-    const { error } = await context.supabase
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
+    const { error } = await supabaseAdmin
         .from("floriday_settings")
         .upsert({ id: 1, active_environment: data.environment });
     if (error)
@@ -996,6 +1045,22 @@ export const setupFlorydayConnectionsSyncCron = createServerFn({ method: "POST"
     const { jobid, url } = await scheduleFlorydayConnectionsSyncInternal(context.supabase);
     return { ok: true, jobid, url };
 });
+async function scheduleFlorydayStockQueueInternal(supabase) {
+    const apikey = process.env.SUPABASE_PUBLISHABLE_KEY ?? process.env.VITE_SUPABASE_PUBLISHABLE_KEY;
+    if (!apikey)
+        throw new Error("Supabase anon key ontbreekt in server-env");
+    const url = `${resolveFlorydayCronBaseUrl()}/api/public/cron/process-stock-queue`;
+    const { data, error } = await supabase.rpc("schedule_floriday_stock_queue_process", { p_url: url, p_apikey: apikey });
+    if (error)
+        throw new Error(error.message);
+    return { jobid: data, url };
+}
+export const setupFlorydayStockQueueCron = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { jobid, url } = await scheduleFlorydayStockQueueInternal(context.supabase);
+    return { ok: true, jobid, url };
+});
 /**
  * Geeft een snapshot van de geplande Floriday-cron jobs zodat de UI kan
  * tonen welke URL is ingepland (zo zien we direct als er een verkeerde
@@ -1021,7 +1086,7 @@ export const getFlorydayCronStatus = createServerFn({ method: "GET" })
     return { ok: true, jobs, expectedBase };
 });
 /**
- * Herinstalleert beide Floriday-crons in één call met de correct
+ * Herinstalleert de Floriday-crons in één call met de correct
  * gedetecteerde base-URL. Idempotent: bestaande jobs worden overschreven.
  */
 export const reinstallFlorydayCrons = createServerFn({ method: "POST" })
@@ -1029,7 +1094,8 @@ export const reinstallFlorydayCrons = createServerFn({ method: "POST" })
     .handler(async ({ context }) => {
     const token = await scheduleFlorydayTokenRefreshInternal(context.supabase);
     const conn = await scheduleFlorydayConnectionsSyncInternal(context.supabase);
-    return { ok: true, token, connections: conn };
+    const stockQueue = await scheduleFlorydayStockQueueInternal(context.supabase);
+    return { ok: true, token, connections: conn, stockQueue };
 });
 function redactHeadersForWriteLog(headers) {
     const out = {};