@futdevpro/nts-dynamo 1.15.153 → 1.15.155

package/src/_services/shared.static-service.spec.ts

@@ -1,11 +1,14 @@
-import { DyNTS_Shared } from './shared.static-service';
-import { Request } from 'express';
-import * as GeoIp from 'geoip-lite';
+import { Request } from 'express';
+
+import { DyFM_GeoIpLocation } from '@futdevpro/fsm-dynamo/location';
+
+import { DyNTS_Shared } from './shared.static-service';
 
 describe('| DyNTS_Shared', () => {
   describe('| getIpFromRequest', () => {
-    it('| should extract IP from x-forwarded-for header', () => {
-      const mockRequest = {
+    it('| should extract IP from x-forwarded-for header', () => {
+      const consoleLogSpy: jasmine.Spy = spyOn(console, 'log');
+      const mockRequest = {
         headers: {
           'x-forwarded-for': '192.168.1.1, 10.0.0.1, 172.16.0.1',
         },
@@ -15,8 +18,9 @@ describe('| DyNTS_Shared', () => {
       } as any as Request;
 
       const ip = DyNTS_Shared.getIpFromRequest(mockRequest);
-
-      expect(ip).toBe('172.16.0.1');
+
+      expect(ip).toBe('172.16.0.1');
+      expect(consoleLogSpy).not.toHaveBeenCalled();
     });
 
     it('| should extract IP from socket.remoteAddress when x-forwarded-for is not present', () => {
@@ -63,22 +67,52 @@ describe('| DyNTS_Shared', () => {
     });
   });
 
-  // Skip geoip tests - GeoIp.lookup is not writable/mockable
-  describe('| getLocationDataByRequest', () => {
-    it('| should return location data for request IP', () => {
-      // Skipped - GeoIp.lookup cannot be mocked
-    });
-  });
-
-  describe('| getLocationByIp', () => {
-    it('| should return location data for IP address', () => {
-      // Skipped - GeoIp.lookup cannot be mocked
-    });
-
-    it('| should return null for invalid IP', () => {
-      // Skipped - GeoIp.lookup cannot be mocked
-    });
-  });
+  describe('| getLocationDataByRequest', () => {
+    it('| should return null without logging the request IP when provider is unavailable', () => {
+      const consoleLogSpy: jasmine.Spy = spyOn(console, 'log');
+
+      spyOn<any>(DyNTS_Shared, 'getGeoIpProvider').and.returnValue(null);
+      const mockRequest = {
+        headers: {
+          'x-forwarded-for': '198.51.100.17',
+        },
+        socket: {
+          remoteAddress: '127.0.0.1',
+        },
+      } as any as Request;
+
+      expect(DyNTS_Shared.getLocationDataByRequest(mockRequest)).toBeNull();
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('| getLocationByIp', () => {
+    it('| should use the optional local provider when available', () => {
+      const location: DyFM_GeoIpLocation = {
+        range: [ 0, 1 ],
+        country: 'HU',
+        region: '',
+        eu: '1',
+        timezone: 'Europe/Budapest',
+        city: 'Budapest',
+        ll: [ 47.4979, 19.0402 ],
+        metro: 0,
+        area: 10,
+      };
+      const lookupSpy: jasmine.Spy = jasmine.createSpy('lookup').and.returnValue(location);
+
+      spyOn<any>(DyNTS_Shared, 'getGeoIpProvider').and.returnValue({ lookup: lookupSpy });
+
+      expect(DyNTS_Shared.getLocationByIp('203.0.113.7')).toEqual(location);
+      expect(lookupSpy).toHaveBeenCalledOnceWith('203.0.113.7');
+    });
+
+    it('| should return null when the optional provider is unavailable', () => {
+      spyOn<any>(DyNTS_Shared, 'getGeoIpProvider').and.returnValue(null);
+
+      expect(DyNTS_Shared.getLocationByIp('203.0.113.7')).toBeNull();
+    });
+  });
 
   describe('| prompt', () => {
     it('| should be accessible', () => {

package/src/_services/shared.static-service.ts

@@ -1,10 +1,16 @@
 
-import * as ReadLine from 'readline';
-import * as GeoIp from 'geoip-lite';
-import { Request } from 'express';
+import * as ReadLine from 'readline';
+import { createRequire } from 'module';
+import { Request } from 'express';
 
 import { DyFM_Object } from '@futdevpro/fsm-dynamo';
-import { DyFM_GeoIpLocation } from '@futdevpro/fsm-dynamo/location';
+import { DyFM_GeoIpLocation } from '@futdevpro/fsm-dynamo/location';
+
+interface DyNTS_GeoIpProvider {
+  lookup(ip: string): DyFM_GeoIpLocation | null;
+}
+
+const DyNTS_optionalRequire: NodeJS.Require = createRequire(__filename);
 
 /**
  * Collection of static helper utilities shared across modules.
@@ -20,11 +26,10 @@ export class DyNTS_Shared extends DyFM_Object {
   static getIpFromRequest(request: Request): string {
     let ip: string;
 
-    if (request?.headers?.['x-forwarded-for']) {
-      const route: string[] = (request.headers['x-forwarded-for'] as string).split(', ');
-
-      console.log('TESTTTT route:', route);
-      ip = route[route.length - 1];
+    if (request?.headers?.['x-forwarded-for']) {
+      const route: string[] = (request.headers['x-forwarded-for'] as string).split(', ');
+
+      ip = route[route.length - 1];
     } else {
       ip = request.socket.remoteAddress;
     }
@@ -36,21 +41,45 @@ export class DyNTS_Shared extends DyFM_Object {
    * Lookup the Geo location of a request based on its IP address.
    *
    * @param request Incoming request
-   * @returns Resolved geo location information
-   */
-  static getLocationDataByRequest(request: Request): DyFM_GeoIpLocation {
-    return GeoIp.lookup(this.getIpFromRequest(request));
-  }
+   * The optional GeoIP provider is loaded only for this capability. When it is not installed,
+   * the method returns `null` and does not transmit or log the address.
+   *
+   * @returns Resolved geo location information, or `null` when unavailable
+   */
+  static getLocationDataByRequest(request: Request): DyFM_GeoIpLocation | null {
+    return this.getLocationByIp(this.getIpFromRequest(request));
+  }
 
   /**
    * Lookup the Geo location of a raw IP address.
    *
    * @param ip IP address string
-   * @returns Geo location information
-   */
-  static getLocationByIp(ip: string): DyFM_GeoIpLocation {
-    return GeoIp.lookup(ip);
-  }
+   * The lookup is local-only: the IP address is never sent to an external service. The optional
+   * provider may be omitted by consumers that do not use geolocation.
+   *
+   * @returns Geo location information, or `null` when unavailable
+   */
+  static getLocationByIp(ip: string): DyFM_GeoIpLocation | null {
+    const geoIpProvider: DyNTS_GeoIpProvider | null = this.getGeoIpProvider();
+
+    return geoIpProvider?.lookup(ip) ?? null;
+  }
+
+  private static getGeoIpProvider(): DyNTS_GeoIpProvider | null {
+    let geoIpModulePath: string;
+
+    try {
+      geoIpModulePath = DyNTS_optionalRequire.resolve('geoip-lite');
+    } catch (error: unknown) {
+      if (error instanceof Error && 'code' in error && error.code === 'MODULE_NOT_FOUND') {
+        return null;
+      }
+
+      throw error;
+    }
+
+    return DyNTS_optionalRequire(geoIpModulePath);
+  }
 
   /**
    * Simple CLI helper to prompt the user for input.