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

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

@@ -0,0 +1,65 @@
+// Server-only Google-client. Alle Google-aanroepen van FlowSelections lopen
+// via dit bestand. Authenticatie gebeurt met de Google Maps API-key die de
+// centrale auth-module levert (provider google_maps).
+import { getGoogleAccessToken } from "./central-auth.server";
+const PLACES_SEARCH_URL = "https://places.googleapis.com/v1/places:searchText";
+const ROUTE_MATRIX_URL = "https://routes.googleapis.com/distanceMatrix/v2:computeRouteMatrix";
+async function googleFetch(url, body, fieldMask) {
+    const apiKey = await getGoogleAccessToken();
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "X-Goog-Api-Key": apiKey,
+            "Content-Type": "application/json",
+            "X-Goog-FieldMask": fieldMask,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(`Google API-fout (status ${response.status}): ${detail.slice(0, 300)}`);
+    }
+    return response.json();
+}
+/** Zet één adres om naar coördinaten via Places Text Search. */
+export async function geocodeAddress(rawAddress) {
+    const data = (await googleFetch(PLACES_SEARCH_URL, { textQuery: rawAddress, maxResultCount: 1, languageCode: "nl" }, "places.id,places.formattedAddress,places.location"));
+    const place = Array.isArray(data?.places) ? data.places[0] : undefined;
+    const lat = place?.location?.latitude;
+    const lng = place?.location?.longitude;
+    if (!place || typeof lat !== "number" || typeof lng !== "number")
+        return null;
+    return {
+        formattedAddress: place.formattedAddress ?? rawAddress,
+        lat,
+        lng,
+        placeId: place.id ?? "",
+    };
+}
+const TRAVEL_MODES = {
+    drive: "DRIVE",
+    bicycle: "BICYCLE",
+    walk: "WALK",
+    transit: "TRANSIT",
+};
+/** Reistijdmatrix (max 25x25 elementen per aanroep). */
+export async function computeRouteMatrix(origins, destinations, mode = "drive") {
+    const waypoint = (point) => ({
+        waypoint: { location: { latLng: { latitude: point.lat, longitude: point.lng } } },
+    });
+    const data = (await googleFetch(ROUTE_MATRIX_URL, {
+        origins: origins.map(waypoint),
+        destinations: destinations.map(waypoint),
+        travelMode: TRAVEL_MODES[mode] ?? "DRIVE",
+    }, "originIndex,destinationIndex,duration,distanceMeters,condition"));
+    const rows = Array.isArray(data) ? data : [];
+    return rows.map((row) => ({
+        originIndex: row.originIndex ?? 0,
+        destinationIndex: row.destinationIndex ?? 0,
+        durationSec: typeof row.duration === "string"
+            ? Number.parseInt(row.duration.replace("s", ""), 10)
+            : null,
+        distanceM: typeof row.distanceMeters === "number" ? row.distanceMeters : null,
+        status: row.condition === "ROUTE_EXISTS" ? "ok" : "unreachable",
+    }));
+}

package/dist-lib/lib/maps-admin.server.d.ts

@@ -0,0 +1,17 @@
+import type { MapsOverview } from "./maps.functions";
+export declare function getMapsOverviewData(): Promise<MapsOverview>;
+export declare function saveMapsSettings(input: {
+    cacheTtlDays: number;
+    dailyCallLimit: number;
+    allowEstimateFallback: boolean;
+    provider: "free" | "google";
+}): Promise<{
+    ok: boolean;
+}>;
+export declare function clearCache(): Promise<{
+    ok: boolean;
+}>;
+export declare function purgeExpired(): Promise<{
+    ok: boolean;
+}>;
+//# sourceMappingURL=maps-admin.server.d.ts.map

package/dist-lib/lib/maps-admin.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps-admin.server.d.ts","sourceRoot":"","sources":["../../src/lib/maps-admin.server.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAiCrD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,YAAY,CAAC,CAuEjE;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC7B;;GAeA;AAED,wBAAsB,UAAU;;GAK/B;AAED,wBAAsB,YAAY;;GAQjC"}

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

@@ -0,0 +1,121 @@
+// Server-only beheerlogica voor de kaarten-module.
+import { createClient } from "@supabase/supabase-js";
+import { getGoogleConnectionStatus } from "./central-auth.server";
+// Ruwe schatting: Routes/Places kosten ~ USD 5 per 1000 elementen.
+// Alleen relevant zodra de betaalde Google-provider actief is.
+const COST_PER_ELEMENT = 0.005;
+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 },
+    });
+}
+async function ensureSettings(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 count(db, table, apply) {
+    let query = db.from(table).select("id", { count: "exact", head: true });
+    if (apply)
+        query = apply(query);
+    const { count: total } = await query;
+    return total ?? 0;
+}
+export async function getMapsOverviewData() {
+    const db = adminClient();
+    const settings = await ensureSettings(db);
+    const status = await getGoogleConnectionStatus();
+    const now = new Date();
+    const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate()).toISOString();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1).toISOString();
+    const { data: monthRows } = await db
+        .from("maps_usage_log")
+        .select("elements, cache_hits, outcome, call_type, created_at")
+        .gte("created_at", startOfMonth);
+    const rows = Array.isArray(monthRows) ? monthRows : [];
+    // Alleen echte externe aanroepen tellen als "elementen".
+    const isRealCall = (row) => row.call_type === "geocode" || row.call_type === "matrix";
+    const billable = rows.filter((row) => isRealCall(row) && row.outcome === "ok");
+    const elementsMonth = billable.reduce((sum, row) => sum + (row.elements ?? 0), 0);
+    const elementsToday = billable
+        .filter((row) => row.created_at >= startOfDay)
+        .reduce((sum, row) => sum + (row.elements ?? 0), 0);
+    const cacheHitsMonth = rows.reduce((sum, row) => sum + (row.cache_hits ?? 0), 0);
+    const fallbacksMonth = rows.filter((row) => row.outcome === "fallback" || row.outcome === "skipped").length;
+    const errorsMonth = rows.filter((row) => isRealCall(row) && (row.outcome === "error" || row.outcome === "no_result")).length;
+    const [queuePending, queueFailed, addressCount, travelTimeCount, expiredCount] = await Promise.all([
+        count(db, "maps_request_queue", (q) => q.eq("status", "pending")),
+        count(db, "maps_request_queue", (q) => q.eq("status", "failed")),
+        count(db, "maps_addresses"),
+        count(db, "maps_travel_times"),
+        count(db, "maps_travel_times", (q) => q.lt("expires_at", now.toISOString())),
+    ]);
+    return {
+        connected: status.connected,
+        connectionReason: status.reason,
+        settings: settings
+            ? {
+                id: settings.id,
+                cacheTtlDays: settings.cache_ttl_days,
+                dailyCallLimit: settings.daily_call_limit,
+                allowEstimateFallback: settings.allow_estimate_fallback,
+                provider: settings.provider === "google" ? "google" : "free",
+                lastSuccessAt: settings.last_success_at,
+                lastErrorAt: settings.last_error_at,
+                lastError: settings.last_error,
+            }
+            : null,
+        queuePending,
+        queueFailed,
+        addressCount,
+        travelTimeCount,
+        expiredCount,
+        elementsToday,
+        elementsMonth,
+        cacheHitsMonth,
+        fallbacksMonth,
+        errorsMonth,
+        estimatedCostMonth: settings?.provider === "google"
+            ? Number((elementsMonth * COST_PER_ELEMENT).toFixed(2))
+            : null,
+    };
+}
+export async function saveMapsSettings(input) {
+    const db = adminClient();
+    const settings = await ensureSettings(db);
+    const { error } = await db
+        .from("maps_settings")
+        .update({
+        cache_ttl_days: input.cacheTtlDays,
+        daily_call_limit: input.dailyCallLimit,
+        allow_estimate_fallback: input.allowEstimateFallback,
+        provider: input.provider,
+        updated_at: new Date().toISOString(),
+    })
+        .eq("id", settings.id);
+    if (error)
+        throw new Error(error.message);
+    return { ok: true };
+}
+export async function clearCache() {
+    const db = adminClient();
+    await db.from("maps_travel_times").delete().neq("id", "00000000-0000-0000-0000-000000000000");
+    await db.from("maps_addresses").delete().neq("id", "00000000-0000-0000-0000-000000000000");
+    return { ok: true };
+}
+export async function purgeExpired() {
+    const db = adminClient();
+    const { error } = await db
+        .from("maps_travel_times")
+        .delete()
+        .lt("expires_at", new Date().toISOString());
+    if (error)
+        throw new Error(error.message);
+    return { ok: true };
+}

package/dist-lib/lib/maps-diagnostics.server.d.ts

@@ -0,0 +1,4 @@
+import { type MapsDiagnosticsReport } from "./central-auth.server";
+/** Volledige diagnose uitvoeren. */
+export declare function runMapsDiagnostics(): Promise<MapsDiagnosticsReport>;
+//# sourceMappingURL=maps-diagnostics.server.d.ts.map

package/dist-lib/lib/maps-diagnostics.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps-diagnostics.server.d.ts","sourceRoot":"","sources":["../../src/lib/maps-diagnostics.server.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,uBAAuB,CAAC;AAqI/B,oCAAoC;AACpC,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAEzE"}

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

@@ -0,0 +1,137 @@
+// Server-only diagnose-logica voor de kaarten-module.
+// Bouwt de diagnosestappen op met de Google-client en Supabase-toegang,
+// via collectMapsDiagnostics uit central-auth.server.
+import { createClient } from "@supabase/supabase-js";
+import { collectMapsDiagnostics, } from "./central-auth.server";
+import { geocodeAddress, computeRouteMatrix } from "./google-maps.server";
+const TEST_ADDRESS = "Damrak 70, Amsterdam";
+function errSummary(error) {
+    return error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200);
+}
+/** Probe-stap voor een Google-API-aanroep (Geocoding of Routes). */
+async function probeGoogle(stepName, target) {
+    try {
+        if (stepName.includes("Geocoding")) {
+            const result = await geocodeAddress(TEST_ADDRESS);
+            if (!result) {
+                return {
+                    name: stepName,
+                    ok: false,
+                    target,
+                    httpStatus: null,
+                    summary: "Google gaf geen adresresultaat terug.",
+                    body: null,
+                    code: "no_result",
+                    hint: "Controleer of het testadres geldig is en of de Places-API is ingeschakeld voor het Google-project.",
+                };
+            }
+            return {
+                name: stepName,
+                ok: true,
+                target,
+                httpStatus: 200,
+                summary: `Geocoded naar "${result.formattedAddress}" (${result.lat}, ${result.lng}).`,
+                body: null,
+            };
+        }
+        // Routes-test: 1×1 matrix tussen twee bekende punten.
+        const origin = { lat: 52.3731, lng: 4.8937 }; // Amsterdam Damrak
+        const destination = { lat: 52.3702, lng: 4.8952 }; // Amsterdam Centraal
+        const elements = await computeRouteMatrix([origin], [destination], "drive");
+        const el = Array.isArray(elements) ? elements[0] : null;
+        if (!el || el.status !== "ok") {
+            return {
+                name: stepName,
+                ok: false,
+                target,
+                httpStatus: null,
+                summary: "Google gaf geen route terug tussen de testpunten.",
+                body: null,
+                code: "no_route",
+                hint: "Controleer of de Routes-API is ingeschakeld voor het Google-project.",
+            };
+        }
+        return {
+            name: stepName,
+            ok: true,
+            target,
+            httpStatus: 200,
+            summary: `Route gevonden: ${el.durationSec ?? 0}s / ${el.distanceM ?? 0}m.`,
+            body: null,
+        };
+    }
+    catch (error) {
+        return {
+            name: stepName,
+            ok: false,
+            target,
+            httpStatus: null,
+            summary: errSummary(error),
+            body: null,
+            code: "google_error",
+            hint: "Controleer de Google-API-status en of billing is ingeschakeld voor de Routes/Places-API.",
+        };
+    }
+}
+/** Probe-stap voor Supabase-toegang tot de maps_*-tabellen. */
+async function probeSupabase() {
+    const target = "SELECT count(*) FROM maps_settings";
+    try {
+        const url = process.env["SUPABASE_URL"];
+        const key = process.env["SERVICE_ROLE_KEY"] ?? process.env["SUPABASE_SERVICE_ROLE_KEY"];
+        if (!url || !key) {
+            return {
+                name: "Supabase-toegang",
+                ok: false,
+                target,
+                httpStatus: null,
+                summary: "SUPABASE_URL of SERVICE_ROLE_KEY ontbreekt.",
+                body: null,
+                code: "supabase_config",
+                hint: "Voeg SUPABASE_URL en SERVICE_ROLE_KEY toe aan de server-omgeving.",
+            };
+        }
+        const db = createClient(url, key, {
+            auth: { persistSession: false, autoRefreshToken: false },
+        });
+        const { count, error } = await db
+            .from("maps_settings")
+            .select("id", { count: "exact", head: true });
+        if (error) {
+            return {
+                name: "Supabase-toegang",
+                ok: false,
+                target,
+                httpStatus: null,
+                summary: `Supabase-fout: ${error.message.slice(0, 200)}`,
+                body: null,
+                code: "supabase_error",
+                hint: "Controleer of de maps_*-tabellen bestaan en of de service-role sleutel toegang heeft.",
+            };
+        }
+        return {
+            name: "Supabase-toegang",
+            ok: true,
+            target,
+            httpStatus: null,
+            summary: `maps_settings bereikbaar (${count ?? 0} rijen).`,
+            body: null,
+        };
+    }
+    catch (error) {
+        return {
+            name: "Supabase-toegang",
+            ok: false,
+            target,
+            httpStatus: null,
+            summary: errSummary(error),
+            body: null,
+            code: "supabase_error",
+            hint: "Controleer de Supabase-configuratie van de server.",
+        };
+    }
+}
+/** Volledige diagnose uitvoeren. */
+export async function runMapsDiagnostics() {
+    return collectMapsDiagnostics(probeGoogle, probeSupabase);
+}

package/dist-lib/lib/maps-processor.server.d.ts

@@ -0,0 +1,16 @@
+export interface ProcessResult {
+    processed: number;
+    geocoded: number;
+    travelTimes: number;
+    failed: number;
+    skipped: string | null;
+}
+/** SHA-256 hash via Web Crypto (browser, Node 15+ en Deno). */
+export declare function addressHash(raw: string): Promise<string>;
+/** Claimt de verwerkingslease. Geeft false als er al een run bezig is. */
+export declare function claimQueueLease(): Promise<boolean>;
+/** Geeft de verwerkingslease weer vrij. */
+export declare function releaseQueueLease(): Promise<void>;
+/** Verwerkt een batch uit de wachtrij. Veilig om vaker aan te roepen. */
+export declare function processMapsQueueBatch(): Promise<ProcessResult>;
+//# sourceMappingURL=maps-processor.server.d.ts.map

package/dist-lib/lib/maps-processor.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps-processor.server.d.ts","sourceRoot":"","sources":["../../src/lib/maps-processor.server.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,+DAA+D;AAC/D,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAS9D;AAcD,0EAA0E;AAC1E,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAUxD;AAED,2CAA2C;AAC3C,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAMvD;AAgHD,yEAAyE;AACzE,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,aAAa,CAAC,CAmMpE"}