@sanvika/geolocation 0.1.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@sanvika/geolocation",
+  "version": "0.1.0",
+  "description": "Sanvika ecosystem geolocation SDK — server-side IP lookup (ip-api.com) + client-side browser geolocation with cache/IP fallback",
+  "type": "module",
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./server": "./src/server/index.js",
+    "./client": "./src/client/index.js"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@sanvika/logger": ">=0.1"
+  },
+  "keywords": ["sanvika", "geolocation", "ip", "location", "india"],
+  "author": "Sanvika Production",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sanvikaproduction/sanvika-geolocation.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/client/index.js

@@ -0,0 +1,181 @@
+// packages/sanvika-geolocation-sdk/src/client/index.js
+// Client-side (browser) geolocation with HTML5 GPS + cache/IP fallback
+// Usage: import { getLocationPromise, getFullLocationDetails } from "@sanvika/geolocation/client"
+
+import { createLogger } from "@sanvika/logger";
+import { setWithTTL, getWithTTL, TTL } from "./localStorageTTL.js";
+
+const logger = createLogger({ namespace: "SanvikaGeolocation" });
+const LOCATION_CACHE_KEY = "sanvika_location_cache";
+
+// ─── Internal helpers ────────────────────────────────────────────────────────
+
+async function tryFallbacks(options) {
+  if (options.useCachedFallback) {
+    const cached = getWithTTL(LOCATION_CACHE_KEY);
+    if (cached?.coords) {
+      logger.info("Using cached location fallback");
+      return {
+        latitude: cached.coords.latitude,
+        longitude: cached.coords.longitude,
+        accuracy: cached.coords.accuracy || 10000,
+        source: "cached",
+        timestamp: cached.timestamp,
+      };
+    }
+  }
+
+  if (options.useIpFallback) {
+    try {
+      const res = await fetch("/api/location/getIpLocation");
+      const data = await res.json();
+      if (data.success && data.location) {
+        logger.info("Using IP fallback for location");
+        return {
+          latitude: data.location.latitude,
+          longitude: data.location.longitude,
+          accuracy: 20000,
+          source: "ip",
+          timestamp: Date.now(),
+        };
+      }
+    } catch { /* silent — will throw below */ }
+  }
+
+  throw new Error("All location methods failed");
+}
+
+// ─── Main exports ────────────────────────────────────────────────────────────
+
+export function getLocationPromise(options = {}) {
+  const finalOptions = {
+    enableHighAccuracy: true,
+    timeout: 10000,
+    maximumAge: 0,
+    useIpFallback: true,
+    useCachedFallback: true,
+    ...options,
+  };
+
+  return new Promise((resolve, reject) => {
+    if (!navigator.geolocation) {
+      logger.warn("Geolocation API not supported — using fallback");
+      tryFallbacks(finalOptions).then(resolve).catch(reject);
+      return;
+    }
+
+    navigator.geolocation.getCurrentPosition(
+      (position) => {
+        if (finalOptions.useCachedFallback) {
+          setWithTTL(
+            LOCATION_CACHE_KEY,
+            {
+              coords: {
+                latitude: position.coords.latitude,
+                longitude: position.coords.longitude,
+                accuracy: position.coords.accuracy,
+              },
+              timestamp: Date.now(),
+              source: "browser_geolocation",
+            },
+            TTL.ONE_HOUR
+          );
+        }
+        resolve({
+          latitude: position.coords.latitude,
+          longitude: position.coords.longitude,
+          accuracy: position.coords.accuracy,
+          source: "html5_geo",
+          timestamp: position.timestamp || Date.now(),
+        });
+      },
+      (error) => {
+        const code = error.code;
+        if (code === 1) logger.warn("GPS permission denied — using fallback");
+        else if (code === 2) logger.warn("GPS unavailable — using fallback");
+        else if (code === 3) logger.warn("GPS timeout — using fallback");
+        else logger.error("GPS error:", error);
+        tryFallbacks(finalOptions).then(resolve).catch(reject);
+      },
+      {
+        enableHighAccuracy: finalOptions.enableHighAccuracy,
+        timeout: finalOptions.timeout,
+        maximumAge: finalOptions.maximumAge,
+      }
+    );
+  });
+}
+
+export async function getFullLocationDetails(options = {}) {
+  const locationData = await getLocationPromise(options);
+  if (!locationData.latitude || !locationData.longitude) return locationData;
+
+  try {
+    const res = await fetch("/api/location/getLocationDetails", {
+      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 };
+  } catch (error) {
+    logger.error("Error fetching location details", error);
+  }
+  return locationData;
+}
+
+export function cacheLocationData(locationData) {
+  try {
+    setWithTTL(
+      LOCATION_CACHE_KEY,
+      {
+        coords: {
+          latitude: locationData.latitude ?? locationData.coords?.latitude,
+          longitude: locationData.longitude ?? locationData.coords?.longitude,
+          accuracy: locationData.accuracy ?? locationData.coords?.accuracy,
+        },
+        address: {
+          city: locationData.city,
+          state: locationData.state,
+          country: locationData.country,
+          postalCode: locationData.postalCode,
+          fullAddress: locationData.fullAddress,
+        },
+        timestamp: Date.now(),
+        source: locationData.source || "manual",
+      },
+      TTL.ONE_HOUR
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getCachedLocation() {
+  return getWithTTL(LOCATION_CACHE_KEY);
+}
+
+export async function getCityFromCoordinates(latitude, longitude) {
+  const cached = getCachedLocation();
+  if (cached?.city) return cached.city;
+
+  try {
+    const res = await fetch("/api/location/getLocationDetails", {
+      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;
+  } catch (error) {
+    logger.error("Error getting city from coordinates:", error);
+  }
+  return "Unknown";
+}
+
+export default getLocationPromise;

package/src/client/localStorageTTL.js

@@ -0,0 +1,33 @@
+// packages/sanvika-geolocation-sdk/src/client/localStorageTTL.js
+// Minimal localStorage TTL helper for client-side geolocation cache
+
+export const TTL = {
+  ONE_HOUR: 60 * 60 * 1000,
+  SIX_HOURS: 6 * 60 * 60 * 1000,
+  ONE_DAY: 24 * 60 * 60 * 1000,
+};
+
+export function setWithTTL(key, value, ttlMs) {
+  try {
+    localStorage.setItem(key, JSON.stringify({ value, expiresAt: Date.now() + ttlMs }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getWithTTL(key) {
+  try {
+    const raw = localStorage.getItem(key);
+    if (!raw) return null;
+    const item = JSON.parse(raw);
+    if (Date.now() > item.expiresAt) {
+      localStorage.removeItem(key);
+      return null;
+    }
+    return item.value;
+  } catch {
+    try { localStorage.removeItem(key); } catch { /* ignore */ }
+    return null;
+  }
+}

package/src/index.js

@@ -0,0 +1,6 @@
+// packages/sanvika-geolocation-sdk/src/index.js
+// Public entry point for @sanvika/geolocation
+// Server exports: import from "@sanvika/geolocation/server"
+// Client exports: import from "@sanvika/geolocation/client"
+
+export { getLocationFromIp, clearLocationCache, isPrivateIp } from "./server/index.js";

package/src/server/index.js

@@ -0,0 +1,91 @@
+// packages/sanvika-geolocation-sdk/src/server/index.js
+// Server-side IP geolocation via ip-api.com (free, no API key, 45 req/min)
+
+import { createLogger } from "@sanvika/logger";
+
+const logger = createLogger({ namespace: "SanvikaGeolocation" });
+
+const locationCache = new Map();
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+
+export function isPrivateIp(ip) {
+  const privateRanges = [
+    /^127\./,
+    /^10\./,
+    /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+    /^192\.168\./,
+    /^::1$/,
+    /^fe80:/i,
+    /^fc00:/i,
+    /^fd00:/i,
+  ];
+  return privateRanges.some((r) => r.test(ip));
+}
+
+function getDefaultLocation() {
+  return {
+    city: "Unknown",
+    state: "Unknown",
+    country: "India",
+    countryCode: "IN",
+    zipCode: null,
+    latitude: null,
+    longitude: null,
+    timezone: "Asia/Kolkata",
+    source: "default",
+  };
+}
+
+export async function getLocationFromIp(ip) {
+  if (!ip || ip === "unknown" || isPrivateIp(ip)) {
+    return getDefaultLocation();
+  }
+
+  const cached = locationCache.get(ip);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.data;
+  }
+
+  try {
+    const response = await fetch(
+      `http://ip-api.com/json/${ip}?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone`,
+      {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(3000),
+      }
+    );
+
+    if (!response.ok) throw new Error(`ip-api returned ${response.status}`);
+
+    const data = await response.json();
+
+    if (data.status === "fail") {
+      logger.warn("IP lookup failed", { ip, message: data.message });
+      return getDefaultLocation();
+    }
+
+    const location = {
+      city: data.city || "Unknown",
+      state: data.regionName || data.region || "Unknown",
+      country: data.country || "India",
+      countryCode: data.countryCode || "IN",
+      zipCode: data.zip || null,
+      latitude: data.lat || null,
+      longitude: data.lon || null,
+      timezone: data.timezone || "Asia/Kolkata",
+      source: "ip_api",
+    };
+
+    locationCache.set(ip, { data: location, timestamp: Date.now() });
+    logger.info("IP location resolved", { city: location.city });
+    return location;
+  } catch (error) {
+    logger.warn("IP geolocation failed", { error: error.message });
+    return getDefaultLocation();
+  }
+}
+
+export function clearLocationCache() {
+  locationCache.clear();
+}