@flowselections/google-maps-api-installatie-techniek 1.0.2

package/dist-lib/lib/maps-processor.server.js

@@ -0,0 +1,315 @@
+// Server-only wachtrijverwerking voor de kaarten-module.
+// Leest maps_request_queue, geocodet adressen en haalt reistijden op.
+import { createClient } from "@supabase/supabase-js";
+import { computeRouteMatrix, geocodeAddress } from "./google-maps.server";
+const BATCH_SIZE = 50;
+const MAX_ATTEMPTS = 3;
+const MAX_MATRIX_SIDE = 25;
+/** SHA-256 hash via Web Crypto (browser, Node 15+ en Deno). */
+export async function addressHash(raw) {
+    const normalized = raw.trim().toLowerCase().replace(/\s+/g, " ");
+    const buf = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(normalized));
+    return Array.from(new Uint8Array(buf))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+function adminClient() {
+    const url = process.env["SUPABASE_URL"];
+    const key = process.env["SERVICE_ROLE_KEY"] ?? process.env["SUPABASE_SERVICE_ROLE_KEY"];
+    if (!url || !key)
+        throw new Error("Supabase serverconfiguratie ontbreekt.");
+    return createClient(url, key, {
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+}
+const LEASE_JOB = "maps_queue";
+const LEASE_MINUTES = 5;
+/** Claimt de verwerkingslease. Geeft false als er al een run bezig is. */
+export async function claimQueueLease() {
+    const db = adminClient();
+    const now = new Date();
+    const { data } = await db
+        .from("maps_job_lease")
+        .update({ locked_until: new Date(now.getTime() + LEASE_MINUTES * 60000).toISOString() })
+        .eq("job", LEASE_JOB)
+        .lt("locked_until", now.toISOString())
+        .select("job");
+    return Array.isArray(data) && data.length > 0;
+}
+/** Geeft de verwerkingslease weer vrij. */
+export async function releaseQueueLease() {
+    const db = adminClient();
+    await db
+        .from("maps_job_lease")
+        .update({ locked_until: new Date(Date.now() - 1000).toISOString() })
+        .eq("job", LEASE_JOB);
+}
+async function getSettings(db) {
+    const { data } = await db
+        .from("maps_settings")
+        .select("*")
+        .limit(1)
+        .maybeSingle();
+    if (data)
+        return data;
+    const { data: created } = await db
+        .from("maps_settings")
+        .insert({})
+        .select("*")
+        .single();
+    return created;
+}
+async function callsToday(db) {
+    // Alleen echte externe aanroepen tellen mee voor de daglimiet.
+    const { data } = await db
+        .from("maps_usage_log")
+        .select("elements")
+        .in("call_type", ["geocode", "matrix"])
+        .gte("created_at", new Date(Date.now() - 24 * 3600 * 1000).toISOString());
+    const rows = Array.isArray(data) ? data : [];
+    return rows.reduce((sum, row) => sum + (row.elements ?? 0), 0);
+}
+async function logUsage(db, callType, elements, outcome, detail) {
+    await db.from("maps_usage_log").insert({
+        call_type: callType,
+        elements,
+        outcome,
+        detail: detail ?? null,
+    });
+}
+async function ensureAddress(db, raw) {
+    const hash = await addressHash(raw);
+    const { data: existing } = await db
+        .from("maps_addresses")
+        .select("id, lat, lng, status")
+        .eq("address_hash", hash)
+        .maybeSingle();
+    if (existing && existing.status === "resolved" && existing.lat != null) {
+        return { id: existing.id, lat: existing.lat, lng: existing.lng };
+    }
+    if (existing && existing.status === "failed")
+        return null;
+    const id = existing?.id ??
+        (await db
+            .from("maps_addresses")
+            .insert({ address_hash: hash, raw_address: raw, status: "pending" })
+            .select("id")
+            .single()).data?.id;
+    if (!id)
+        return null;
+    try {
+        const result = await geocodeAddress(raw);
+        if (!result) {
+            await db
+                .from("maps_addresses")
+                .update({
+                status: "failed",
+                error_reason: "Geen resultaat van Google",
+                updated_at: new Date().toISOString(),
+            })
+                .eq("id", id);
+            await logUsage(db, "geocode", 1, "no_result", raw);
+            return null;
+        }
+        await db
+            .from("maps_addresses")
+            .update({
+            formatted_address: result.formattedAddress,
+            lat: result.lat,
+            lng: result.lng,
+            place_id: result.placeId,
+            status: "resolved",
+            error_reason: null,
+            resolved_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        })
+            .eq("id", id);
+        await logUsage(db, "geocode", 1, "ok");
+        return { id, lat: result.lat, lng: result.lng };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await db
+            .from("maps_addresses")
+            .update({ status: "failed", error_reason: message, updated_at: new Date().toISOString() })
+            .eq("id", id);
+        await logUsage(db, "geocode", 1, "error", message);
+        throw error;
+    }
+}
+/** Verwerkt een batch uit de wachtrij. Veilig om vaker aan te roepen. */
+export async function processMapsQueueBatch() {
+    const db = adminClient();
+    const settings = await getSettings(db);
+    const result = {
+        processed: 0,
+        geocoded: 0,
+        travelTimes: 0,
+        failed: 0,
+        skipped: null,
+    };
+    const used = await callsToday(db);
+    if (settings && used >= settings.daily_call_limit) {
+        await logUsage(db, "limit", 0, "skipped", "Daglimiet bereikt");
+        result.skipped = "Daglimiet bereikt";
+        return result;
+    }
+    const { data: queue } = await db
+        .from("maps_request_queue")
+        .select("*")
+        .eq("status", "pending")
+        .lt("attempts", MAX_ATTEMPTS)
+        .order("created_at", { ascending: true })
+        .limit(BATCH_SIZE);
+    const items = Array.isArray(queue) ? queue : [];
+    if (items.length === 0)
+        return result;
+    const ids = items.map((item) => item.id);
+    await db
+        .from("maps_request_queue")
+        .update({ status: "processing", updated_at: new Date().toISOString() })
+        .in("id", ids);
+    const ttlDays = settings?.cache_ttl_days ?? 30;
+    const expiresAt = new Date(Date.now() + ttlDays * 86400000).toISOString();
+    const pairs = [];
+    for (const item of items) {
+        try {
+            if (item.kind === "geocode") {
+                const raw = item.raw_origin ?? item.raw_destination;
+                if (!raw)
+                    throw new Error("Geen adres in wachtrijregel");
+                const address = await ensureAddress(db, raw);
+                if (address)
+                    result.geocoded += 1;
+                else
+                    result.failed += 1;
+                await db
+                    .from("maps_request_queue")
+                    .update({
+                    status: address ? "done" : "failed",
+                    attempts: (item.attempts ?? 0) + 1,
+                    last_error: address ? null : "Adres niet gevonden",
+                    processed_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                })
+                    .eq("id", item.id);
+                result.processed += 1;
+                continue;
+            }
+            const origin = item.raw_origin ? await ensureAddress(db, item.raw_origin) : null;
+            const destination = item.raw_destination
+                ? await ensureAddress(db, item.raw_destination)
+                : null;
+            if (!origin || !destination) {
+                result.failed += 1;
+                await db
+                    .from("maps_request_queue")
+                    .update({
+                    status: "failed",
+                    attempts: (item.attempts ?? 0) + 1,
+                    last_error: "Adres kon niet worden omgezet",
+                    processed_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                })
+                    .eq("id", item.id);
+                result.processed += 1;
+                continue;
+            }
+            pairs.push({ item, origin, destination });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            result.failed += 1;
+            await db
+                .from("maps_request_queue")
+                .update({
+                status: (item.attempts ?? 0) + 1 >= MAX_ATTEMPTS ? "failed" : "pending",
+                attempts: (item.attempts ?? 0) + 1,
+                last_error: message,
+                updated_at: new Date().toISOString(),
+            })
+                .eq("id", item.id);
+            await db
+                .from("maps_settings")
+                .update({ last_error: message, last_error_at: new Date().toISOString() })
+                .eq("id", settings.id);
+            result.processed += 1;
+        }
+    }
+    for (let index = 0; index < pairs.length; index += MAX_MATRIX_SIDE) {
+        const chunk = pairs.slice(index, index + MAX_MATRIX_SIDE);
+        const origins = chunk.map((pair) => pair.origin);
+        const destinations = chunk.map((pair) => pair.destination);
+        const mode = chunk[0]?.item.mode ?? "drive";
+        try {
+            const elements = await computeRouteMatrix(origins, destinations, mode);
+            await logUsage(db, "matrix", chunk.length, "ok");
+            for (let position = 0; position < chunk.length; position += 1) {
+                const pair = chunk[position];
+                const element = elements.find((row) => row.originIndex === position && row.destinationIndex === position);
+                if (!element || element.status !== "ok" || element.durationSec == null) {
+                    result.failed += 1;
+                    await db
+                        .from("maps_request_queue")
+                        .update({
+                        status: "failed",
+                        attempts: (pair.item.attempts ?? 0) + 1,
+                        last_error: "Geen route gevonden",
+                        processed_at: new Date().toISOString(),
+                        updated_at: new Date().toISOString(),
+                    })
+                        .eq("id", pair.item.id);
+                    result.processed += 1;
+                    continue;
+                }
+                await db.from("maps_travel_times").upsert({
+                    origin_id: pair.origin.id,
+                    destination_id: pair.destination.id,
+                    mode: pair.item.mode ?? "drive",
+                    duration_sec: element.durationSec,
+                    distance_m: element.distanceM,
+                    source: "google",
+                    expires_at: expiresAt,
+                }, { onConflict: "origin_id,destination_id,mode" });
+                result.travelTimes += 1;
+                result.processed += 1;
+                await db
+                    .from("maps_request_queue")
+                    .update({
+                    status: "done",
+                    attempts: (pair.item.attempts ?? 0) + 1,
+                    last_error: null,
+                    processed_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                })
+                    .eq("id", pair.item.id);
+            }
+            await db
+                .from("maps_settings")
+                .update({ last_success_at: new Date().toISOString() })
+                .eq("id", settings.id);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await logUsage(db, "matrix", chunk.length, "error", message);
+            await db
+                .from("maps_settings")
+                .update({ last_error: message, last_error_at: new Date().toISOString() })
+                .eq("id", settings.id);
+            for (const pair of chunk) {
+                result.failed += 1;
+                result.processed += 1;
+                await db
+                    .from("maps_request_queue")
+                    .update({
+                    status: (pair.item.attempts ?? 0) + 1 >= MAX_ATTEMPTS ? "failed" : "pending",
+                    attempts: (pair.item.attempts ?? 0) + 1,
+                    last_error: message,
+                    updated_at: new Date().toISOString(),
+                })
+                    .eq("id", pair.item.id);
+            }
+        }
+    }
+    return result;
+}