@sanvika/geolocation 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanvika/geolocation",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "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",
@@ -17,13 +17,7 @@
   "dependencies": {
     "@sanvika/logger": ">=0.2"
   },
-  "keywords": [
-    "sanvika",
-    "geolocation",
-    "ip",
-    "location",
-    "india"
-  ],
+  "keywords": ["sanvika", "geolocation", "ip", "location", "india"],
   "author": "Sanvika Production",
   "license": "UNLICENSED",
   "repository": {
@@ -33,4 +27,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

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);
   }