@sanvika/geolocation 0.6.2 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanvika/geolocation",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Sanvika ecosystem geolocation SDK — fully centralized via geolocation.sanvikaproduction.com. IP lookup, reverse/forward geocoding, Places autocomplete + details, Maps JS loader. Zero Google API keys in consumer projects.",
   "type": "module",
   "main": "./src/index.js",

package/src/client/loadGoogleMapsScript.js

@@ -16,7 +16,7 @@ import { createLogger } from "@sanvika/logger";
 const logger = createLogger({ namespace: "SanvikaGeolocation.MapsLoader" });
 
 let inflight = null;
-let cachedConfig = null;
+const cachedConfigByPlatform = new Map();
 
 function readEnv(key) {
   try {
@@ -26,17 +26,22 @@ function readEnv(key) {
   }
 }
 
-async function fetchMapsConfig({ apiBase, clientId, mapsConfigPath }) {
-  if (cachedConfig) return cachedConfig;
+async function fetchMapsConfig({ apiBase, clientId, mapsConfigPath, platform = "web" }) {
+  const cacheKey = `${clientId}:${platform}`;
+  if (cachedConfigByPlatform.has(cacheKey)) return cachedConfigByPlatform.get(cacheKey);
   const configPath = mapsConfigPath || "/api/v1/mapsjs/config";
-  const url = `${apiBase}${configPath}?clientId=${encodeURIComponent(clientId)}`;
+  const params = new URLSearchParams({
+    clientId,
+    platform,
+  });
+  const url = `${apiBase}${configPath}?${params.toString()}`;
   const res = await fetch(url, { credentials: "omit" });
   const data = await res.json().catch(() => ({}));
   if (!res.ok || !data?.success) {
     throw new Error(`mapsjs/config failed: ${data?.error || `HTTP_${res.status}`}`);
   }
-  cachedConfig = data.config;
-  return cachedConfig;
+  cachedConfigByPlatform.set(cacheKey, data.config);
+  return data.config;
 }
 
 export async function loadGoogleMapsScript({
@@ -45,6 +50,7 @@ export async function loadGoogleMapsScript({
   apiBase: apiBaseInput,
   clientId: clientIdInput,
   mapsConfigPath,
+  platform = "web",
 } = {}) {
   if (typeof window === "undefined") {
     throw new Error("loadGoogleMapsScript must run in the browser");
@@ -66,7 +72,7 @@ export async function loadGoogleMapsScript({
   }
 
   inflight = (async () => {
-    const config = await fetchMapsConfig({ apiBase, clientId, mapsConfigPath });
+    const config = await fetchMapsConfig({ apiBase, clientId, mapsConfigPath, platform });
 
     return new Promise((resolve, reject) => {
       const callbackName = `__sanvika_maps_cb_${Date.now()}`;
@@ -120,11 +126,15 @@ export async function loadGoogleMapsScript({
   }
 }
 
-export function getMapsConfig() {
-  return cachedConfig;
+export function getMapsConfig(platform = "web") {
+  const clientId =
+    readEnv("NEXT_PUBLIC_CLIENT_ID") ||
+    readEnv("NEXT_PUBLIC_GEOLOCATION_CLIENT_ID") ||
+    "default";
+  return cachedConfigByPlatform.get(`${clientId}:${platform}`) || null;
 }
 
 export function resetMapsLoader() {
-  cachedConfig = null;
+  cachedConfigByPlatform.clear();
   inflight = null;
 }

package/src/react-native/configureGeolocationClient.js

@@ -0,0 +1,22 @@
+// Module-level RN runtime — same pattern as @sanvika/realtime/chat configureChatClient.
+
+/** @type {{ getAccessToken?: () => (string | null | Promise<string | null>) }} */
+let geolocationRuntimeConfig = {
+  getAccessToken: null,
+};
+
+/**
+ * Configure React Native geolocation client (call once at app start, e.g. App.js).
+ * Required when resolveLocation({ userUid }) calls authenticated FAPK routes.
+ *
+ * @param {{ getAccessToken?: () => (string | null | Promise<string | null>) }} opts
+ */
+export function configureGeolocationClient(opts = {}) {
+  if (typeof opts.getAccessToken === "function") {
+    geolocationRuntimeConfig.getAccessToken = opts.getAccessToken;
+  }
+}
+
+export function getGeolocationRuntimeConfig() {
+  return geolocationRuntimeConfig;
+}

package/src/react-native/index.js

@@ -17,5 +17,6 @@ export {
 export { setWithTTL, getWithTTL, TTL } from "./asyncStorageTTL.js";
 
 // RN-native resolveLocation (replaces local mobile utils/location/resolveLocation.js)
+export { configureGeolocationClient } from "./configureGeolocationClient.js";
 export { resolveLocation } from "./resolveLocation.js";
 export { resolveLocation as default } from "./resolveLocation.js";

package/src/react-native/resolveLocation.js

@@ -5,6 +5,7 @@ import Geolocation from "@react-native-community/geolocation";
 import { Platform } from "react-native";
 import { request, PERMISSIONS, RESULTS } from "react-native-permissions";
 import { createLogger } from "@sanvika/logger";
+import { getGeolocationRuntimeConfig } from "./configureGeolocationClient.js";
 
 const FAPK_API = "https://freeadpostkaro.com/api";
 
@@ -20,17 +21,48 @@ function normalizeCoords(lat, lng) {
   return isValidCoord(latitude) && isValidCoord(longitude) ? { latitude, longitude } : null;
 }
 
-async function fetchUserDatabaseLocation(uid, apiBaseUrl, log) {
+async function resolveAccessToken(getAccessTokenOverride) {
+  const getter =
+    getAccessTokenOverride || getGeolocationRuntimeConfig().getAccessToken;
+  if (typeof getter !== "function") {
+    return null;
+  }
+  try {
+    const token = await getter();
+    return token ? String(token).trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+async function fetchUserDatabaseLocation(uid, apiBaseUrl, log, getAccessTokenOverride) {
   try {
+    const token = await resolveAccessToken(getAccessTokenOverride);
+    if (!token) {
+      log.warn("User DB location requires Bearer token — configureGeolocationClient({ getAccessToken })", {
+        uid,
+      });
+      return null;
+    }
+
     const url = `${apiBaseUrl}/location/getUserLocation`;
-    const res = await fetch(`${url}?uid=${encodeURIComponent(uid)}`, {
-      headers: { uid, Accept: "application/json" },
+    const res = await fetch(url, {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`,
+      },
     });
-    if (!res.ok) { return null; }
+    if (!res.ok) {
+      return null;
+    }
     const data = await res.json();
-    if (!data?.success || !data?.data) { return null; }
+    if (!data?.success || !data?.data) {
+      return null;
+    }
     const coords = normalizeCoords(data.data.latitude, data.data.longitude);
-    if (!coords) { return null; }
+    if (!coords) {
+      return null;
+    }
     return { ...data.data, ...coords, source: "user_database", priority: PRIORITY.USER_DATABASE };
   } catch (err) {
     log.error("User DB location fetch failed", { uid, message: err?.message });
@@ -60,7 +92,9 @@ async function fetchDeviceLocation(log) {
     });
 
     const coords = normalizeCoords(position?.coords?.latitude, position?.coords?.longitude);
-    if (!coords) { return null; }
+    if (!coords) {
+      return null;
+    }
 
     return {
       ...coords,
@@ -80,11 +114,17 @@ async function fetchIpLocation(apiBaseUrl, log) {
     const res = await fetch(`${apiBaseUrl}/location/getIpLocation`, {
       headers: { Accept: "application/json" },
     });
-    if (!res.ok) { return null; }
+    if (!res.ok) {
+      return null;
+    }
     const data = await res.json();
-    if (!data?.success || !data?.location) { return null; }
+    if (!data?.success || !data?.location) {
+      return null;
+    }
     const coords = normalizeCoords(data.location.latitude, data.location.longitude);
-    if (!coords) { return null; }
+    if (!coords) {
+      return null;
+    }
     return { ...data.location, ...coords, source: "ip_location", priority: PRIORITY.IP };
   } catch (err) {
     log.warn("IP location fetch failed", { message: err?.message });
@@ -94,32 +134,50 @@ async function fetchIpLocation(apiBaseUrl, log) {
 
 /**
  * Resolve the best available location.
- * @param {{ userUid?: string, apiBaseUrl?: string, useDeviceLocation?: boolean, useIpFallback?: boolean, logger?: object }} opts
+ * @param {{
+ *   userUid?: string,
+ *   apiBaseUrl?: string,
+ *   useDeviceLocation?: boolean,
+ *   useIpFallback?: boolean,
+ *   getAccessToken?: () => (string | null | Promise<string | null>),
+ *   logger?: object,
+ * }} opts
  */
 export async function resolveLocation({
   userUid,
   apiBaseUrl = FAPK_API,
   useDeviceLocation = false,
   useIpFallback = false,
+  getAccessToken,
   logger,
 } = {}) {
   const log = ensureLog(logger);
 
   if (userUid) {
-    const dbLocation = await fetchUserDatabaseLocation(userUid, apiBaseUrl, log);
-    if (dbLocation) { return dbLocation; }
-    log.warn("User DB location unavailable", { uid: userUid });
-    return null;
+    const dbLocation = await fetchUserDatabaseLocation(
+      userUid,
+      apiBaseUrl,
+      log,
+      getAccessToken,
+    );
+    if (dbLocation) {
+      return dbLocation;
+    }
+    log.warn("User DB location unavailable — falling back to device/IP", { uid: userUid });
   }
 
   if (useDeviceLocation) {
     const deviceLocation = await fetchDeviceLocation(log);
-    if (deviceLocation) { return deviceLocation; }
+    if (deviceLocation) {
+      return deviceLocation;
+    }
   }
 
   if (useIpFallback) {
     const ipLocation = await fetchIpLocation(apiBaseUrl, log);
-    if (ipLocation) { return ipLocation; }
+    if (ipLocation) {
+      return ipLocation;
+    }
   }
 
   log.warn("All location sources exhausted");

package/src/server/index.js

@@ -96,6 +96,14 @@ export async function placesDetails(placeId, { language = "en", fields, sessionT
   });
 }
 
+/** S2S — resolve platform-specific Google Map ID (web | android | ios | static). */
+export async function getMapsPlatformConfig(platform = "web") {
+  return getServiceClient().request("/api/v1/maps/config", {
+    method: "GET",
+    query: { platform },
+  });
+}
+
 /**
  * Detect Indian state + city from coordinates.
  * Now proxied through reverseGeocode (which calls geolocation service) — no Google key in consumer env.