ggez-banking-sdk 0.2.20 → 0.2.21

package/dist/helper/geoHelper.d.ts

@@ -1,9 +1,49 @@
 import type { GeoCoordinates } from "../types";
 import { IPAddressAndLocationService } from "../api/services/ipAddressAndLocation";
 declare class GeoHelper {
-    static GetGeoCoordinates(locationService: IPAddressAndLocationService): Promise<GeoCoordinates>;
-    static GetIPAddress(locationService: IPAddressAndLocationService): Promise<string>;
-    static GetGeoCoordinatesAndIPAddress(locationService: IPAddressAndLocationService): Promise<{
+    private static readonly CACHE_KEY;
+    private static readonly DEFAULT_TTL_MS;
+    private static cache;
+    /**
+     * Get cached geo coordinates if available and not expired
+     * @param ttlMs Time to live in milliseconds (default: 24 hours)
+     * @returns Cached geo coordinates or null if expired/not found
+     */
+    private static getCachedGeoCoordinates;
+    /**
+     * Cache geo coordinates
+     * @param geo_coordinates Geo coordinates to cache
+     * @param ip_address Optional IP address to cache
+     */
+    private static setCachedGeoCoordinates;
+    /**
+     * Clear cached geo coordinates
+     */
+    static clearCache(): void;
+    /**
+     * Get geo coordinates with caching support
+     * @param locationService IP address and location service
+     * @param ttlMs Time to live in milliseconds (default: 24 hours). Set to 0 to disable cache.
+     * @param forceRefresh Force refresh even if cache is valid
+     * @returns Geo coordinates
+     */
+    static GetGeoCoordinates(locationService: IPAddressAndLocationService, ttlMs?: number, forceRefresh?: boolean): Promise<GeoCoordinates>;
+    /**
+     * Get IP address with caching support
+     * @param locationService IP address and location service
+     * @param ttlMs Time to live in milliseconds (default: 24 hours). Set to 0 to disable cache.
+     * @param forceRefresh Force refresh even if cache is valid
+     * @returns IP address
+     */
+    static GetIPAddress(locationService: IPAddressAndLocationService, ttlMs?: number, forceRefresh?: boolean): Promise<string>;
+    /**
+     * Get geo coordinates and IP address with caching support
+     * @param locationService IP address and location service
+     * @param ttlMs Time to live in milliseconds (default: 24 hours). Set to 0 to disable cache.
+     * @param forceRefresh Force refresh even if cache is valid
+     * @returns Object containing geo coordinates and IP address
+     */
+    static GetGeoCoordinatesAndIPAddress(locationService: IPAddressAndLocationService, ttlMs?: number, forceRefresh?: boolean): Promise<{
         geo_coordinates: GeoCoordinates;
         ip_address: string;
     }>;

package/dist/helper/geoHelper.js

@@ -1,5 +1,98 @@
 class GeoHelper {
-    static async GetGeoCoordinates(locationService) {
+    // Cache configuration
+    static CACHE_KEY = "geo_coordinates_cache";
+    static DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+    static cache = null;
+    /**
+     * Get cached geo coordinates if available and not expired
+     * @param ttlMs Time to live in milliseconds (default: 24 hours)
+     * @returns Cached geo coordinates or null if expired/not found
+     */
+    static getCachedGeoCoordinates(ttlMs = GeoHelper.DEFAULT_TTL_MS) {
+        // Check in-memory cache first
+        if (GeoHelper.cache) {
+            const now = Date.now();
+            const age = now - GeoHelper.cache.timestamp;
+            if (age < ttlMs) {
+                return GeoHelper.cache.geo_coordinates;
+            }
+            // Cache expired, clear it
+            GeoHelper.cache = null;
+        }
+        // Check localStorage cache
+        try {
+            const cachedDataStr = localStorage.getItem(GeoHelper.CACHE_KEY);
+            if (cachedDataStr) {
+                const cachedData = JSON.parse(cachedDataStr);
+                const now = Date.now();
+                const age = now - cachedData.timestamp;
+                if (age < ttlMs) {
+                    // Restore to in-memory cache
+                    GeoHelper.cache = cachedData;
+                    return cachedData.geo_coordinates;
+                }
+                else {
+                    // Cache expired, remove it
+                    localStorage.removeItem(GeoHelper.CACHE_KEY);
+                }
+            }
+        }
+        catch (error) {
+            // If localStorage is not available or parsing fails, continue without cache
+            console.warn("Failed to read geo coordinates from cache:", error);
+        }
+        return null;
+    }
+    /**
+     * Cache geo coordinates
+     * @param geo_coordinates Geo coordinates to cache
+     * @param ip_address Optional IP address to cache
+     */
+    static setCachedGeoCoordinates(geo_coordinates, ip_address) {
+        const cachedData = {
+            geo_coordinates,
+            ip_address,
+            timestamp: Date.now(),
+        };
+        // Store in memory
+        GeoHelper.cache = cachedData;
+        // Store in localStorage for persistence
+        try {
+            localStorage.setItem(GeoHelper.CACHE_KEY, JSON.stringify(cachedData));
+        }
+        catch (error) {
+            // If localStorage is not available, continue with in-memory cache only
+            console.warn("Failed to store geo coordinates in cache:", error);
+        }
+    }
+    /**
+     * Clear cached geo coordinates
+     */
+    static clearCache() {
+        GeoHelper.cache = null;
+        try {
+            localStorage.removeItem(GeoHelper.CACHE_KEY);
+        }
+        catch (error) {
+            // Ignore errors when clearing cache
+        }
+    }
+    /**
+     * Get geo coordinates with caching support
+     * @param locationService IP address and location service
+     * @param ttlMs Time to live in milliseconds (default: 24 hours). Set to 0 to disable cache.
+     * @param forceRefresh Force refresh even if cache is valid
+     * @returns Geo coordinates
+     */
+    static async GetGeoCoordinates(locationService, ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
+        // Check cache first (unless force refresh is requested)
+        if (!forceRefresh && ttlMs > 0) {
+            const cached = GeoHelper.getCachedGeoCoordinates(ttlMs);
+            if (cached) {
+                return cached;
+            }
+        }
+        // Fetch fresh data
         const { data } = await locationService.getIPAddressAndLocation();
         if (data) {
             const ipAddressAndLocation = JSON.parse(data);
@@ -9,20 +102,76 @@ class GeoHelper {
                 longitude: longitude || 0,
                 position_description: `${city || "N/A"}, ${country || "N/A"}`,
             };
+            // Cache the result
+            if (ttlMs > 0) {
+                GeoHelper.setCachedGeoCoordinates(geo_coordinates);
+            }
             return geo_coordinates;
         }
-        return { latitude: 0, longitude: 0, position_description: "N/A, N/A" };
+        const fallback = {
+            latitude: 0,
+            longitude: 0,
+            position_description: "N/A, N/A",
+        };
+        // Cache fallback as well to avoid repeated failed requests
+        if (ttlMs > 0) {
+            GeoHelper.setCachedGeoCoordinates(fallback);
+        }
+        return fallback;
     }
-    static async GetIPAddress(locationService) {
+    /**
+     * Get IP address with caching support
+     * @param locationService IP address and location service
+     * @param ttlMs Time to live in milliseconds (default: 24 hours). Set to 0 to disable cache.
+     * @param forceRefresh Force refresh even if cache is valid
+     * @returns IP address
+     */
+    static async GetIPAddress(locationService, ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
+        // Check cache first (unless force refresh is requested)
+        if (!forceRefresh && ttlMs > 0 && GeoHelper.cache?.ip_address) {
+            const cached = GeoHelper.getCachedGeoCoordinates(ttlMs);
+            if (cached && GeoHelper.cache?.ip_address) {
+                return GeoHelper.cache.ip_address;
+            }
+        }
+        // Fetch fresh data
         const { data } = await locationService.getIPAddressAndLocation();
         if (data) {
             const ipAddressAndLocation = JSON.parse(data);
             const { ip_address } = ipAddressAndLocation;
-            return ip_address;
+            // Cache the result (we need to get geo coordinates too for caching)
+            if (ttlMs > 0 && ip_address) {
+                const { latitude, longitude, city, country } = ipAddressAndLocation;
+                const geo_coordinates = {
+                    latitude: latitude || 0,
+                    longitude: longitude || 0,
+                    position_description: `${city || "N/A"}, ${country || "N/A"}`,
+                };
+                GeoHelper.setCachedGeoCoordinates(geo_coordinates, ip_address);
+            }
+            return ip_address || "";
         }
         return "";
     }
-    static async GetGeoCoordinatesAndIPAddress(locationService) {
+    /**
+     * Get geo coordinates and IP address with caching support
+     * @param locationService IP address and location service
+     * @param ttlMs Time to live in milliseconds (default: 24 hours). Set to 0 to disable cache.
+     * @param forceRefresh Force refresh even if cache is valid
+     * @returns Object containing geo coordinates and IP address
+     */
+    static async GetGeoCoordinatesAndIPAddress(locationService, ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
+        // Check cache first (unless force refresh is requested)
+        if (!forceRefresh && ttlMs > 0) {
+            const cached = GeoHelper.getCachedGeoCoordinates(ttlMs);
+            if (cached && GeoHelper.cache?.ip_address) {
+                return {
+                    geo_coordinates: cached,
+                    ip_address: GeoHelper.cache.ip_address,
+                };
+            }
+        }
+        // Fetch fresh data
         const { data } = await locationService.getIPAddressAndLocation();
         if (data) {
             const ipAddressAndLocation = JSON.parse(data);
@@ -32,9 +181,13 @@ class GeoHelper {
                 longitude: longitude || 0,
                 position_description: `${city || "N/A"}, ${country || "N/A"}`,
             };
-            return { geo_coordinates, ip_address };
+            // Cache the result
+            if (ttlMs > 0) {
+                GeoHelper.setCachedGeoCoordinates(geo_coordinates, ip_address || "");
+            }
+            return { geo_coordinates, ip_address: ip_address || "" };
         }
-        return {
+        const fallback = {
             geo_coordinates: {
                 latitude: 0,
                 longitude: 0,
@@ -42,6 +195,11 @@ class GeoHelper {
             },
             ip_address: "",
         };
+        // Cache fallback as well to avoid repeated failed requests
+        if (ttlMs > 0) {
+            GeoHelper.setCachedGeoCoordinates(fallback.geo_coordinates, fallback.ip_address);
+        }
+        return fallback;
     }
 }
 export { GeoHelper };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggez-banking-sdk",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "description": "A Node.js package to handle GGEZ Banking API endpoints, Simplify the process of managing CRUD operations with this efficient and easy-to-use package.",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",