@sanvika/geolocation 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanvika/geolocation",
-  "version": "0.3.0",
+  "version": "0.4.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",

package/src/client/index.js

@@ -5,10 +5,114 @@
 // Env vars (read from process.env in Next.js / similar):
 //   NEXT_PUBLIC_GEOLOCATION_URL=https://geolocation.sanvikaproduction.com
 //   NEXT_PUBLIC_GEOLOCATION_CLIENT_ID=fapk
+//
+// Consumer projects NO LONGER need proxy routes for geolocation.
+// All calls go directly to geolocation.sanvikaproduction.com via public clientId auth.
+// Only getUserLocation / updateUserLocation still need FAPK routes (they use SA SSO auth).
 
 import { createLogger } from "@sanvika/logger";
 import { setWithTTL, getWithTTL, TTL } from "./localStorageTTL.js";
 
+// ─── Direct service helpers (no consumer proxy routes needed) ────────────────
+
+function _geoUrl() {
+  return (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_GEOLOCATION_URL)
+    || "https://geolocation.sanvikaproduction.com";
+}
+
+function _clientId() {
+  return (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_GEOLOCATION_CLIENT_ID) || "";
+}
+
+async function _servicePost(path, body) {
+  const clientId = _clientId();
+  const qs = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+  try {
+    const res = await fetch(`${_geoUrl()}${path}${qs}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    return res.ok ? res.json() : { success: false };
+  } catch {
+    return { success: false };
+  }
+}
+
+/**
+ * Reverse geocode lat/lng → address parts via geolocation service directly.
+ * Replaces fetch("/api/location/getLocationDetails") in consumer projects.
+ */
+export async function reverseGeocode(latitude, longitude, opts = {}) {
+  const r = await _servicePost("/api/v1/geocode/reverse", { lat: latitude, lng: longitude });
+  if (!r.success || !r.found) return null;
+  return {
+    country: r.country || "",
+    state: r.normalizedState || r.state || "",
+    city: r.city || "",
+    nearbyLandmark: r.sublocality || "",
+    postalCode: r.postalCode || "",
+    fullAddress: r.fullAddress || "",
+    latitude: Number(latitude),
+    longitude: Number(longitude),
+    geoLocation: { type: "Point", coordinates: [Number(longitude), Number(latitude)] },
+    placeId: r.placeId || "",
+    source: opts.source || "reverse_geocode",
+  };
+}
+
+/**
+ * Forward geocode address → lat/lng via geolocation service directly.
+ * Replaces fetch("/api/location/getCoordinates") in consumer projects.
+ */
+export async function forwardGeocode(address, { country = "IN" } = {}) {
+  return _servicePost("/api/v1/geocode/forward", { address, country });
+}
+
+/**
+ * IP-based location lookup via geolocation service directly from browser.
+ * Replaces fetch("/api/location/getIpLocation") in consumer projects.
+ * Browser's real IP is detected server-side by the geolocation service.
+ */
+export async function getIpLocation() {
+  try {
+    const clientId = _clientId();
+    const qs = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+    const res = await fetch(`${_geoUrl()}/api/v1/locate${qs}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data.success || !data.location) return null;
+    const l = data.location;
+    return { latitude: l.lat ?? null, longitude: l.lng ?? null, city: l.city || "Unknown", state: l.region || "", country: l.country || "India", source: "ip" };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Places autocomplete via geolocation service directly.
+ * Replaces fetch("/api/location/places/autocomplete") in consumer projects.
+ */
+export async function placesAutocomplete(input, { country = "IN", types = "geocode", language = "en", sessionToken } = {}) {
+  if (!input || input.trim().length < 2) return { success: true, predictions: [] };
+  return _servicePost("/api/v1/places/autocomplete", { input: input.trim(), country, types, language, sessionToken });
+}
+
+/**
+ * Place details by placeId via geolocation service directly.
+ * Replaces fetch("/api/location/places/details") in consumer projects.
+ */
+export async function placesDetails(placeId, { language = "en", sessionToken } = {}) {
+  if (!placeId) return { success: false };
+  return _servicePost("/api/v1/places/details", { placeId, language, sessionToken });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
 export {
   loadGoogleMapsScript,
   getMapsConfig,
@@ -35,17 +139,11 @@ async function tryFallbacks(options) {
 
   if (options.useIpFallback) {
     try {
-      const res = await fetch(options.ipFallbackUrl || "/api/location/getIpLocation");
-      const data = await res.json();
-      if (data.success && data.location) {
+      // Call geolocation service directly — no FAPK proxy needed
+      const ipLoc = await getIpLocation();
+      if (ipLoc?.latitude && ipLoc?.longitude) {
         logger.info("Using IP fallback for location");
-        return {
-          latitude: data.location.latitude,
-          longitude: data.location.longitude,
-          accuracy: 20000,
-          source: "ip",
-          timestamp: Date.now(),
-        };
+        return { latitude: ipLoc.latitude, longitude: ipLoc.longitude, accuracy: 20000, source: "ip", timestamp: Date.now() };
       }
     } catch { /* silent */ }
   }
@@ -116,19 +214,10 @@ export async function getFullLocationDetails(options = {}) {
   const locationData = await getLocationPromise(options);
   if (!locationData.latitude || !locationData.longitude) return locationData;
 
-  const detailsUrl = options.detailsUrl || "/api/location/getLocationDetails";
   try {
-    const res = await fetch(detailsUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        latitude: locationData.latitude,
-        longitude: locationData.longitude,
-        source: locationData.source,
-      }),
-    });
-    const data = await res.json();
-    if (data.success) return { ...data.location, source: locationData.source, timestamp: locationData.timestamp };
+    // Call geolocation service directly — no FAPK proxy needed
+    const details = await reverseGeocode(locationData.latitude, locationData.longitude, { source: locationData.source });
+    if (details) return { ...details, source: locationData.source, timestamp: locationData.timestamp };
   } catch (error) {
     logger.error("Error fetching location details", error);
   }
@@ -167,18 +256,13 @@ export function getCachedLocation() {
   return getWithTTL(LOCATION_CACHE_KEY);
 }
 
-export async function getCityFromCoordinates(latitude, longitude, options = {}) {
+export async function getCityFromCoordinates(latitude, longitude) {
   const cached = getCachedLocation();
-  if (cached?.city) return cached.city;
-  const detailsUrl = options.detailsUrl || "/api/location/getLocationDetails";
+  if (cached?.address?.city) return cached.address.city;
   try {
-    const res = await fetch(detailsUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ latitude, longitude, source: "city_fetch" }),
-    });
-    const data = await res.json();
-    if (data.success && data.location?.city) return data.location.city;
+    // Call geolocation service directly — no FAPK proxy needed
+    const details = await reverseGeocode(latitude, longitude);
+    if (details?.city) return details.city;
   } catch (error) {
     logger.error("Error getting city from coordinates:", error);
   }

package/src/server/serviceClient.js

@@ -1,6 +1,10 @@
 // packages/sanvika-geolocation-sdk/src/server/serviceClient.js
 // HTTP client for geolocation.sanvikaproduction.com — used by all server-side helpers.
-// Env vars: GEOLOCATION_URL, GEOLOCATION_CLIENT_SECRET (or pass to constructor).
+// Universal S2S Auth Pattern (ecosystem rule §21):
+//   PROJECT_NAME                  — clientId
+//   SANVIKA_SERVICE_KEY           — Tier 1 trust
+//   GEOLOCATION_URL (or GEO_URL)  — service endpoint
+//   GEOLOCATION_CLIENT_SECRET     — (optional, Tier 2 fallback for 3rd-party)
 
 const DEFAULT_TIMEOUT_MS = 6000;
 
@@ -14,15 +18,21 @@ function readEnv(key) {
 
 export class GeolocationServiceClient {
   #url;
+  #clientId;
+  #serviceKey;
   #secret;
 
-  constructor({ url, secret } = {}) {
-    const finalUrl = url || readEnv("GEOLOCATION_URL");
-    const finalSecret = secret || readEnv("GEOLOCATION_CLIENT_SECRET");
-    if (!finalUrl || !finalSecret) {
-      throw new Error("@sanvika/geolocation/server: GEOLOCATION_URL and GEOLOCATION_CLIENT_SECRET are required");
+  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 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");
     }
     this.#url = finalUrl.replace(/\/$/, "");
+    this.#clientId = finalClientId;
+    this.#serviceKey = finalServiceKey;
     this.#secret = finalSecret;
   }
 
@@ -35,7 +45,11 @@ export class GeolocationServiceClient {
     const qs = query ? "?" + new URLSearchParams(query).toString() : "";
     const init = {
       method,
-      headers: { "x-client-secret": this.#secret },
+      headers: {
+        "x-client-id": this.#clientId,
+        "x-service-key": this.#serviceKey,
+        "x-client-secret": this.#secret,
+      },
       signal: controller.signal,
     };
     if (body !== undefined) {