ggez-banking-sdk 0.4.32 → 0.4.33

package/dist/api/context/defaultClientContextProvider.d.ts

@@ -1,4 +1,5 @@
 import type { ClientContextProvider, InitialContext } from "../../types/api/context/clientContext";
+import { GeoHelper } from "../../helper/geoHelper";
 declare class DefaultClientContextProvider implements ClientContextProvider {
     private baseUrl;
     private nodeUrl;
@@ -7,7 +8,9 @@ declare class DefaultClientContextProvider implements ClientContextProvider {
     private installationId;
     private token;
     private userId;
+    private readonly geoHelper;
     constructor(init: InitialContext);
+    getGeoHelper(): GeoHelper;
     getBaseUrl(): string;
     getNodeUrl(): string;
     getProgramId(): number;

package/dist/api/context/defaultClientContextProvider.js

@@ -1,3 +1,4 @@
+import { GeoHelper } from "../../helper/geoHelper";
 class DefaultClientContextProvider {
     baseUrl;
     nodeUrl;
@@ -6,6 +7,7 @@ class DefaultClientContextProvider {
     installationId;
     token;
     userId;
+    geoHelper;
     constructor(init) {
         this.baseUrl = init.baseUrl;
         this.nodeUrl = init.nodeUrl;
@@ -14,6 +16,10 @@ class DefaultClientContextProvider {
         this.installationId = init.installationId ?? "";
         this.token = init.token ?? "";
         this.userId = init.userId ?? 0;
+        this.geoHelper = new GeoHelper(init.baseUrl);
+    }
+    getGeoHelper() {
+        return this.geoHelper;
     }
     getBaseUrl() {
         return this.baseUrl;

package/dist/api/service/baseService.js

@@ -17,7 +17,7 @@ class BaseService {
     }
     // #region "Interceptors Handlers"
     async onRequest(req) {
-        await AxiosHelper.injectBaseHeaders(req, this.context, this.cookiesHelper, this.axiosInstance);
+        await AxiosHelper.injectBaseHeaders(req, this.context, this.cookiesHelper);
         AxiosHelper.injectBaseBodyProperties(req);
         return req;
     }

package/dist/helper/api/axiosHelper.d.ts

@@ -1,4 +1,5 @@
-import { AxiosInstance, InternalAxiosRequestConfig } from "axios";
+import { InternalAxiosRequestConfig } from "axios";
+import type { GeoHelper } from "../geoHelper";
 import type { Bearer, GetLimitedAuthHeaders, GetLimitedToken, InjectBaseHeaders, InjectLimitedToken, TAddAxiosConfigHeader, TGetAuthAxiosConfig, TGetAxiosConfig, TInjectRequest } from "../../types/helper/api/axiosHelper";
 import type { BaseResult } from "../../types/banking/common/baseresult";
 declare class AxiosHelper {
@@ -11,6 +12,6 @@ declare class AxiosHelper {
     static getLimitedToken: GetLimitedToken;
     static getLimitedAuthHeaders: GetLimitedAuthHeaders;
     static injectLimitedToken: InjectLimitedToken;
-    static injectGeoCoordinates: (req: InternalAxiosRequestConfig, axiosInstance: AxiosInstance) => Promise<InternalAxiosRequestConfig>;
+    static injectGeoCoordinates: (req: InternalAxiosRequestConfig, geoHelper: GeoHelper) => Promise<InternalAxiosRequestConfig>;
 }
 export { AxiosHelper };

package/dist/helper/api/axiosHelper.js

@@ -1,7 +1,6 @@
 import { generateSourceID } from "../../utils/data/generation";
 import { isEntityEndpoint } from "../../utils/api/endpointUtils";
 import { DateTimeHelper } from "../dateTimeHelper";
-import { GeoHelper } from "../geoHelper";
 import qs from "qs";
 import { HeaderKeys } from "../../constant/constant";
 class AxiosHelper {
@@ -43,7 +42,7 @@ class AxiosHelper {
             config.headers = {};
         config.headers[key] = value;
     };
-    static injectBaseHeaders = async (req, context, cookiesHelper, axiosInstance) => {
+    static injectBaseHeaders = async (req, context, cookiesHelper) => {
         const token = await cookiesHelper.getAccessToken();
         const userId = await cookiesHelper.getUserId();
         const lang = context.getLang();
@@ -59,7 +58,7 @@ class AxiosHelper {
         if (!req.baseURL)
             req.baseURL = context.getBaseUrl();
         req.headers.set(HeaderKeys.TimeZone, DateTimeHelper.getClientTimeZone());
-        await AxiosHelper.injectGeoCoordinates(req, axiosInstance);
+        await AxiosHelper.injectGeoCoordinates(req, context.getGeoHelper());
         return req;
     };
     static injectBaseBodyProperties = (req) => {
@@ -103,10 +102,9 @@ class AxiosHelper {
         }
         return req;
     };
-    static injectGeoCoordinates = async (req, axiosInstance) => {
+    static injectGeoCoordinates = async (req, geoHelper) => {
         if (!isEntityEndpoint(req.url))
             return req;
-        const geoHelper = new GeoHelper(axiosInstance);
         const geoCoordinates = await geoHelper.getGeoCoordinates();
         if (req.data && typeof req.data === "object") {
             const data = req.data;

package/dist/helper/geoHelper.d.ts

@@ -1,15 +1,19 @@
-import type { AxiosInstance } from "axios";
 import type { GeoCoordinates } from "../types";
 declare class GeoHelper {
-    private static readonly CACHE_KEY;
+    private static readonly CACHE_KEY_PREFIX;
     private static readonly DEFAULT_TTL_MS;
     private static cache;
+    private static pending;
+    private readonly baseUrl;
     private readonly axiosInstance;
-    constructor(axiosInstance: AxiosInstance);
-    private static getCachedGeoCoordinates;
-    private static setCachedGeoCoordinates;
+    constructor(baseUrl: string);
     static clearCache(): void;
+    private static storageKey;
+    private static readCache;
+    private static writeCache;
     private fetchIPAddressAndLocation;
+    private fetchSharedLocation;
+    private loadGeoData;
     private static toGeoCoordinates;
     private static fallbackGeoCoordinates;
     getGeoCoordinates(ttlMs?: number, forceRefresh?: boolean): Promise<GeoCoordinates>;

package/dist/helper/geoHelper.js

@@ -1,71 +1,134 @@
+import axios from "axios";
 import { Endpoints } from "../constant/constant";
 class GeoHelper {
-    static CACHE_KEY = "geo_coordinates_cache";
+    // #region Constants & State
+    static CACHE_KEY_PREFIX = "geo_coordinates_cache";
     static DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
-    static cache = null;
+    static cache = new Map();
+    static pending = new Map();
+    baseUrl;
     axiosInstance;
-    constructor(axiosInstance) {
-        this.axiosInstance = axiosInstance;
+    // #endregion
+    // #region Constructor
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+        this.axiosInstance = axios.create({ baseURL: baseUrl });
     }
-    static getCachedGeoCoordinates(ttlMs = GeoHelper.DEFAULT_TTL_MS) {
-        if (GeoHelper.cache) {
-            const age = Date.now() - GeoHelper.cache.timestamp;
-            if (age < ttlMs)
-                return GeoHelper.cache.geo_coordinates;
-            GeoHelper.cache = null;
-        }
+    // #endregion
+    // #region Cache
+    static clearCache() {
+        GeoHelper.cache.clear();
+        GeoHelper.pending.clear();
         try {
-            const cachedDataStr = localStorage.getItem(GeoHelper.CACHE_KEY);
-            if (cachedDataStr) {
-                const cachedData = JSON.parse(cachedDataStr);
-                const age = Date.now() - cachedData.timestamp;
-                if (age < ttlMs) {
-                    GeoHelper.cache = cachedData;
-                    return cachedData.geo_coordinates;
+            const keysToRemove = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key?.startsWith(GeoHelper.CACHE_KEY_PREFIX)) {
+                    keysToRemove.push(key);
                 }
-                localStorage.removeItem(GeoHelper.CACHE_KEY);
             }
+            keysToRemove.forEach((key) => localStorage.removeItem(key));
         }
-        catch (error) {
-            console.warn("Failed to read geo coordinates from cache:", error);
+        catch {
+            // Ignore errors when clearing cache
         }
-        return null;
     }
-    static setCachedGeoCoordinates(geo_coordinates, ip_address) {
-        const cachedData = {
-            geo_coordinates,
-            ip_address,
-            timestamp: Date.now(),
-        };
-        GeoHelper.cache = cachedData;
+    static storageKey(baseUrl) {
+        return `${GeoHelper.CACHE_KEY_PREFIX}:${baseUrl}`;
+    }
+    static readCache(baseUrl, ttlMs) {
+        const memEntry = GeoHelper.cache.get(baseUrl);
+        if (memEntry) {
+            if (Date.now() - memEntry.timestamp < ttlMs)
+                return memEntry;
+            GeoHelper.cache.delete(baseUrl);
+        }
         try {
-            localStorage.setItem(GeoHelper.CACHE_KEY, JSON.stringify(cachedData));
+            const cachedDataStr = localStorage.getItem(GeoHelper.storageKey(baseUrl));
+            if (!cachedDataStr)
+                return null;
+            const cachedData = JSON.parse(cachedDataStr);
+            if (Date.now() - cachedData.timestamp < ttlMs) {
+                GeoHelper.cache.set(baseUrl, cachedData);
+                return cachedData;
+            }
+            localStorage.removeItem(GeoHelper.storageKey(baseUrl));
         }
         catch (error) {
-            console.warn("Failed to store geo coordinates in cache:", error);
+            console.warn("Failed to read geo coordinates from cache:", error);
         }
+        return null;
     }
-    static clearCache() {
-        GeoHelper.cache = null;
+    static writeCache(baseUrl, data) {
+        GeoHelper.cache.set(baseUrl, data);
         try {
-            localStorage.removeItem(GeoHelper.CACHE_KEY);
+            localStorage.setItem(GeoHelper.storageKey(baseUrl), JSON.stringify(data));
         }
-        catch {
-            // Ignore errors when clearing cache
+        catch (error) {
+            console.warn("Failed to store geo coordinates in cache:", error);
         }
     }
+    // #endregion
+    // #region Helpers
     async fetchIPAddressAndLocation() {
         const response = await this.axiosInstance.get(Endpoints.IPAddress);
         const ipAddressAndLocation = response.data.value;
         if (!ipAddressAndLocation)
             return null;
-        return JSON.parse(ipAddressAndLocation);
+        try {
+            return JSON.parse(ipAddressAndLocation);
+        }
+        catch (error) {
+            console.warn("Failed to parse IP address and location:", error);
+            return null;
+        }
+    }
+    // Dedupes concurrent fetches per baseURL so N callers on cold cache
+    // result in 1 network call instead of N.
+    fetchSharedLocation() {
+        const existing = GeoHelper.pending.get(this.baseUrl);
+        if (existing)
+            return existing;
+        const inflight = this.fetchIPAddressAndLocation();
+        GeoHelper.pending.set(this.baseUrl, inflight);
+        const cleanup = () => {
+            if (GeoHelper.pending.get(this.baseUrl) === inflight) {
+                GeoHelper.pending.delete(this.baseUrl);
+            }
+        };
+        inflight.then(cleanup, cleanup);
+        return inflight;
+    }
+    async loadGeoData(ttlMs, forceRefresh) {
+        if (!forceRefresh && ttlMs > 0) {
+            const cached = GeoHelper.readCache(this.baseUrl, ttlMs);
+            if (cached)
+                return cached;
+        }
+        const location = await this.fetchSharedLocation();
+        // Failed fetch returns fallback but does NOT cache it — a transient
+        // network blip should not poison the cache for 24h.
+        if (!location) {
+            return {
+                geo_coordinates: GeoHelper.fallbackGeoCoordinates(),
+                ip_address: "",
+                timestamp: Date.now(),
+            };
+        }
+        const data = {
+            geo_coordinates: GeoHelper.toGeoCoordinates(location),
+            ip_address: location.ip_address || "",
+            timestamp: Date.now(),
+        };
+        if (ttlMs > 0)
+            GeoHelper.writeCache(this.baseUrl, data);
+        return data;
     }
     static toGeoCoordinates(location) {
         const { latitude, longitude, city, country } = location;
         return {
-            latitude: latitude || 0,
-            longitude: longitude || 0,
+            latitude: latitude ?? 0,
+            longitude: longitude ?? 0,
             position_description: `${city || "N/A"}, ${country || "N/A"}`,
         };
     }
@@ -76,63 +139,22 @@ class GeoHelper {
             position_description: "N/A, N/A",
         };
     }
+    // #endregion
+    // #region Public API
     async getGeoCoordinates(ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
-        if (!forceRefresh && ttlMs > 0) {
-            const cached = GeoHelper.getCachedGeoCoordinates(ttlMs);
-            if (cached)
-                return cached;
-        }
-        const location = await this.fetchIPAddressAndLocation();
-        const geo_coordinates = location
-            ? GeoHelper.toGeoCoordinates(location)
-            : GeoHelper.fallbackGeoCoordinates();
-        if (ttlMs > 0)
-            GeoHelper.setCachedGeoCoordinates(geo_coordinates);
-        return geo_coordinates;
+        const data = await this.loadGeoData(ttlMs, forceRefresh);
+        return data.geo_coordinates;
     }
     async getIPAddress(ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
-        if (!forceRefresh && ttlMs > 0 && GeoHelper.cache?.ip_address) {
-            const cached = GeoHelper.getCachedGeoCoordinates(ttlMs);
-            if (cached && GeoHelper.cache?.ip_address) {
-                return GeoHelper.cache.ip_address;
-            }
-        }
-        const location = await this.fetchIPAddressAndLocation();
-        if (!location)
-            return "";
-        const { ip_address } = location;
-        if (ttlMs > 0 && ip_address) {
-            GeoHelper.setCachedGeoCoordinates(GeoHelper.toGeoCoordinates(location), ip_address);
-        }
-        return ip_address || "";
+        const data = await this.loadGeoData(ttlMs, forceRefresh);
+        return data.ip_address ?? "";
     }
     async getGeoCoordinatesAndIPAddress(ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
-        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,
-                };
-            }
-        }
-        const location = await this.fetchIPAddressAndLocation();
-        if (location) {
-            const geo_coordinates = GeoHelper.toGeoCoordinates(location);
-            const ip_address = location.ip_address || "";
-            if (ttlMs > 0) {
-                GeoHelper.setCachedGeoCoordinates(geo_coordinates, ip_address);
-            }
-            return { geo_coordinates, ip_address };
-        }
-        const fallback = {
-            geo_coordinates: GeoHelper.fallbackGeoCoordinates(),
-            ip_address: "",
+        const data = await this.loadGeoData(ttlMs, forceRefresh);
+        return {
+            geo_coordinates: data.geo_coordinates,
+            ip_address: data.ip_address ?? "",
         };
-        if (ttlMs > 0) {
-            GeoHelper.setCachedGeoCoordinates(fallback.geo_coordinates, fallback.ip_address);
-        }
-        return fallback;
     }
 }
 export { GeoHelper };

package/dist/types/api/context/clientContext.d.ts

@@ -1,3 +1,4 @@
+import type { GeoHelper } from "../../../helper/geoHelper";
 type InitialContext = {
     baseUrl: string;
     nodeUrl: string;
@@ -22,5 +23,6 @@ interface ClientContextProvider {
     getProgramId(): number;
     getLang(): string;
     setLang(lang: string): void;
+    getGeoHelper(): GeoHelper;
 }
 export type { InitialContext, ClientContextProvider };

package/dist/types/helper/api/axiosHelper.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance, AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
+import { AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
 import { ClientContextProvider } from "../..";
 import { CookiesHelper } from "../../..";
 import type { AuthService } from "../../../api/service/authService";
@@ -6,12 +6,11 @@ type TGetAxiosConfig = (token: string, baseURL: string, lang?: string, installat
 type TGetAuthAxiosConfig = (baseURL: string, lang: string, installationId: string) => AxiosRequestConfig;
 type TAddAxiosConfigHeader = (config: AxiosRequestConfig, key: string, value: string) => void;
 type TInjectRequest<D> = (req: InternalAxiosRequestConfig<D>) => InternalAxiosRequestConfig<D>;
-type InjectRequiredHeaders<D> = (req: InternalAxiosRequestConfig, userId: number) => InternalAxiosRequestConfig<D>;
-type InjectBaseHeaders<D> = (req: InternalAxiosRequestConfig, context: ClientContextProvider, cookiesHelper: CookiesHelper, axiosInstance: AxiosInstance) => Promise<InternalAxiosRequestConfig<D>>;
+type InjectBaseHeaders<D> = (req: InternalAxiosRequestConfig, context: ClientContextProvider, cookiesHelper: CookiesHelper) => Promise<InternalAxiosRequestConfig<D>>;
 type InjectLimitedToken = (req: InternalAxiosRequestConfig, authService: AuthService, cookiesHelper: CookiesHelper) => Promise<InternalAxiosRequestConfig>;
 type GetLimitedToken = (authService: AuthService, cookiesHelper: CookiesHelper) => Promise<string | null>;
 type GetLimitedAuthHeaders = (authService: AuthService, cookiesHelper: CookiesHelper) => Promise<{
     Authorization: string;
 } | undefined>;
 type Bearer = (token: string) => string;
-export { TGetAxiosConfig, TGetAuthAxiosConfig, TAddAxiosConfigHeader, TInjectRequest, InjectBaseHeaders, InjectRequiredHeaders, InjectLimitedToken, GetLimitedToken, GetLimitedAuthHeaders, Bearer, };
+export { TGetAxiosConfig, TGetAuthAxiosConfig, TAddAxiosConfigHeader, TInjectRequest, InjectBaseHeaders, InjectLimitedToken, GetLimitedToken, GetLimitedAuthHeaders, Bearer, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggez-banking-sdk",
-  "version": "0.4.32",
+  "version": "0.4.33",
   "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",