@sanvika/geolocation 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanvika/geolocation",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "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",
@@ -8,14 +8,30 @@
   "exports": {
     ".": "./src/index.js",
     "./server": "./src/server/index.js",
-    "./client": "./src/client/index.js"
+    "./client": "./src/client/index.js",
+    "./react-native": "./src/react-native/index.js"
+  },
+  "peerDependencies": {
+    "react-native": "*",
+    "@react-native-async-storage/async-storage": "*",
+    "@react-native-community/geolocation": "*",
+    "react-native-permissions": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native": { "optional": true },
+    "@react-native-async-storage/async-storage": { "optional": true },
+    "@react-native-community/geolocation": { "optional": true },
+    "react-native-permissions": { "optional": true }
   },
   "files": [
     "src",
     "README.md"
   ],
   "dependencies": {
-    "@sanvika/logger": ">=0.2"
+    "@sanvika/geolocation": "0.5.0",
+    "@sanvika/lang": "0.6.0",
+    "@sanvika/logger": ">=0.2",
+    "@sanvika/realtime": "0.7.0"
   },
   "keywords": [
     "sanvika",
@@ -33,4 +49,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/client/index.js

@@ -4,7 +4,7 @@
 //
 // Env vars (read from process.env in Next.js / similar):
 //   NEXT_PUBLIC_GEOLOCATION_URL=https://geolocation.sanvikaproduction.com
-//   NEXT_PUBLIC_PROJECT_NAME=<slug>     (universal, Phase 2 — ecosystem rule §21)
+//   NEXT_PUBLIC_CLIENT_ID=<slug>     (universal)
 //   (fallback) NEXT_PUBLIC_GEOLOCATION_CLIENT_ID
 //
 // Consumer projects NO LONGER need proxy routes for geolocation.
@@ -23,7 +23,7 @@ function _geoUrl() {
 function _clientId() {
   // Phase 2 universal first, then legacy fallback (Next.js requires static access)
   if (typeof process === "undefined" || !process.env) return "";
-  return process.env.NEXT_PUBLIC_PROJECT_NAME
+  return process.env.NEXT_PUBLIC_CLIENT_ID
       || process.env.NEXT_PUBLIC_GEOLOCATION_CLIENT_ID
       || "";
 }

package/src/client/loadGoogleMapsScript.js

@@ -50,10 +50,17 @@ export async function loadGoogleMapsScript({
   if (window.google?.maps?.Map) return window.google;
   if (inflight) return inflight;
 
-  const apiBase = (apiBaseInput || readEnv("NEXT_PUBLIC_GEOLOCATION_URL") || "").replace(/\/$/, "");
-  const clientId = clientIdInput || readEnv("NEXT_PUBLIC_GEOLOCATION_CLIENT_ID");
-  if (!apiBase || !clientId) {
-    throw new Error("loadGoogleMapsScript: NEXT_PUBLIC_GEOLOCATION_URL and NEXT_PUBLIC_GEOLOCATION_CLIENT_ID are required");
+  const apiBase = (
+    apiBaseInput ||
+    readEnv("NEXT_PUBLIC_GEOLOCATION_URL") ||
+    "https://geolocation.sanvikaproduction.com"
+  ).replace(/\/$/, "");
+  const clientId =
+    clientIdInput ||
+    readEnv("NEXT_PUBLIC_CLIENT_ID") ||
+    readEnv("NEXT_PUBLIC_GEOLOCATION_CLIENT_ID");
+  if (!clientId) {
+    throw new Error("loadGoogleMapsScript: NEXT_PUBLIC_CLIENT_ID (or NEXT_PUBLIC_GEOLOCATION_CLIENT_ID) is required");
   }
 
   inflight = (async () => {

package/src/react-native/asyncStorageTTL.js

@@ -0,0 +1,33 @@
+// react-native/asyncStorageTTL.js — AsyncStorage-backed TTL cache (mirrors localStorageTTL.js)
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+export const TTL = {
+  ONE_HOUR: 60 * 60 * 1000,
+  SIX_HOURS: 6 * 60 * 60 * 1000,
+  ONE_DAY: 24 * 60 * 60 * 1000,
+};
+
+export async function setWithTTL(key, value, ttlMs) {
+  try {
+    await AsyncStorage.setItem(key, JSON.stringify({ value, expiresAt: Date.now() + ttlMs }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getWithTTL(key) {
+  try {
+    const raw = await AsyncStorage.getItem(key);
+    if (!raw) { return null; }
+    const item = JSON.parse(raw);
+    if (Date.now() > item.expiresAt) {
+      await AsyncStorage.removeItem(key);
+      return null;
+    }
+    return item.value;
+  } catch {
+    try { await AsyncStorage.removeItem(key); } catch { /* ignore */ }
+    return null;
+  }
+}

package/src/react-native/index.js

@@ -0,0 +1,21 @@
+// @sanvika/geolocation/react-native — RN subpath entry
+// Universal server-side helpers (no browser deps)
+export {
+  INDIAN_STATES,
+  INDIAN_UNION_TERRITORIES,
+  ALL_INDIAN_REGIONS,
+  STATE_NAME_ALIASES,
+  normalizeStateName,
+  isValidIndianState,
+  isPrivateIp,
+  clearLocationCache,
+  clearStateCache,
+  getStateCacheStats,
+} from "../server/index.js";
+
+// AsyncStorage-backed TTL cache (mirrors ./client localStorageTTL)
+export { setWithTTL, getWithTTL, TTL } from "./asyncStorageTTL.js";
+
+// RN-native resolveLocation (replaces local mobile utils/location/resolveLocation.js)
+export { resolveLocation } from "./resolveLocation.js";
+export { resolveLocation as default } from "./resolveLocation.js";

package/src/react-native/resolveLocation.js

@@ -0,0 +1,129 @@
+// react-native/resolveLocation.js
+// RN equivalent of mobile's local utils/location/resolveLocation.js.
+// Uses @react-native-community/geolocation (already installed in consumer).
+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";
+
+const FAPK_API = "https://freeadpostkaro.com/api";
+
+const PRIORITY = { USER_DATABASE: 1, DEVICE: 2, IP: 3 };
+
+const ensureLog = (log) => log || createLogger({ namespace: "resolveLocation" });
+
+const isValidCoord = (v) => typeof v === "number" && Number.isFinite(v);
+
+function normalizeCoords(lat, lng) {
+  const latitude = typeof lat === "string" ? parseFloat(lat) : lat;
+  const longitude = typeof lng === "string" ? parseFloat(lng) : lng;
+  return isValidCoord(latitude) && isValidCoord(longitude) ? { latitude, longitude } : null;
+}
+
+async function fetchUserDatabaseLocation(uid, apiBaseUrl, log) {
+  try {
+    const url = `${apiBaseUrl}/location/getUserLocation`;
+    const res = await fetch(`${url}?uid=${encodeURIComponent(uid)}`, {
+      headers: { uid, Accept: "application/json" },
+    });
+    if (!res.ok) { return null; }
+    const data = await res.json();
+    if (!data?.success || !data?.data) { return null; }
+    const coords = normalizeCoords(data.data.latitude, data.data.longitude);
+    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 });
+    return null;
+  }
+}
+
+async function fetchDeviceLocation(log) {
+  try {
+    const permType =
+      Platform.OS === "ios"
+        ? PERMISSIONS.IOS.LOCATION_WHEN_IN_USE
+        : PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION;
+
+    const result = await request(permType);
+    if (result !== RESULTS.GRANTED) {
+      log.warn("Device location permission denied", { status: result });
+      return null;
+    }
+
+    const position = await new Promise((resolve, reject) => {
+      Geolocation.getCurrentPosition(resolve, reject, {
+        enableHighAccuracy: true,
+        timeout: 10000,
+        maximumAge: 1000,
+      });
+    });
+
+    const coords = normalizeCoords(position?.coords?.latitude, position?.coords?.longitude);
+    if (!coords) { return null; }
+
+    return {
+      ...coords,
+      accuracy: position?.coords?.accuracy,
+      timestamp: position?.timestamp || Date.now(),
+      source: "device_geolocation",
+      priority: PRIORITY.DEVICE,
+    };
+  } catch (err) {
+    log.warn("Device geolocation failed", { message: err?.message });
+    return null;
+  }
+}
+
+async function fetchIpLocation(apiBaseUrl, log) {
+  try {
+    const res = await fetch(`${apiBaseUrl}/location/getIpLocation`, {
+      headers: { Accept: "application/json" },
+    });
+    if (!res.ok) { return null; }
+    const data = await res.json();
+    if (!data?.success || !data?.location) { return null; }
+    const coords = normalizeCoords(data.location.latitude, data.location.longitude);
+    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 });
+    return null;
+  }
+}
+
+/**
+ * Resolve the best available location.
+ * @param {{ userUid?: string, apiBaseUrl?: string, useDeviceLocation?: boolean, useIpFallback?: boolean, logger?: object }} opts
+ */
+export async function resolveLocation({
+  userUid,
+  apiBaseUrl = FAPK_API,
+  useDeviceLocation = false,
+  useIpFallback = false,
+  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;
+  }
+
+  if (useDeviceLocation) {
+    const deviceLocation = await fetchDeviceLocation(log);
+    if (deviceLocation) { return deviceLocation; }
+  }
+
+  if (useIpFallback) {
+    const ipLocation = await fetchIpLocation(apiBaseUrl, log);
+    if (ipLocation) { return ipLocation; }
+  }
+
+  log.warn("All location sources exhausted");
+  return null;
+}
+
+export default resolveLocation;

package/src/server/serviceClient.js

@@ -1,7 +1,7 @@
 // packages/sanvika-geolocation-sdk/src/server/serviceClient.js
 // HTTP client for geolocation.sanvikaproduction.com — used by all server-side helpers.
 // Universal S2S Auth Pattern (ecosystem rule §21):
-//   PROJECT_NAME                  — clientId
+//   CLIENT_ID                     — clientId
 //   SANVIKA_SERVICE_KEY           — Tier 1 trust
 //   GEOLOCATION_URL (or GEO_URL)  — service endpoint
 //   GEOLOCATION_CLIENT_SECRET     — (optional, Tier 2 fallback for 3rd-party)
@@ -24,11 +24,11 @@ export class GeolocationServiceClient {
 
   constructor({ url, clientId, serviceKey, secret } = {}) {
     const finalUrl = url || readEnv("GEOLOCATION_URL") || readEnv("GEO_URL");
-    const finalClientId = clientId || readEnv("PROJECT_NAME") || readEnv("GEOLOCATION_CLIENT_ID");
+    const finalClientId = clientId || readEnv("CLIENT_ID") || readEnv("GEOLOCATION_CLIENT_ID");
     const finalServiceKey = serviceKey || readEnv("SANVIKA_SERVICE_KEY") || "";
     const finalSecret = secret || readEnv("GEOLOCATION_CLIENT_SECRET") || "";  // Tier 2 fallback (optional)
     if (!finalUrl || !finalClientId) {
-      throw new Error("@sanvika/geolocation/server: GEOLOCATION_URL and PROJECT_NAME are required");
+      throw new Error("@sanvika/geolocation/server: GEOLOCATION_URL and CLIENT_ID are required");
     }
     this.#url = finalUrl.replace(/\/$/, "");
     this.#clientId = finalClientId;