dms-middleware-auth 1.1.3 → 1.1.4

package/dist/auth.middleware.d.ts

@@ -21,6 +21,7 @@ export declare class AuthMiddleware implements NestMiddleware, OnModuleInit {
     private static shutdownInitiated;
     private static readonly licenceExpiredMessage;
     private static readonly CLOCK_TOLERANCE_MS;
+    private static readonly MAX_INT32;
     private readonly logger;
     constructor(cacheManager: Cache, options: AuthMiddlewareOptions);
     onModuleInit(): Promise<void>;

package/dist/auth.middleware.js

@@ -90,7 +90,9 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
             if (!clientToken) {
                 clientToken = await this.clientLogin();
                 const decodedToken = jwt.decode(clientToken);
-                const ttl = (decodedToken.exp - Math.floor(Date.now() / 1000)) * 1000;
+                const ttlRaw = (decodedToken.exp - Math.floor(Date.now() / 1000)) * 1000;
+                const ttl = Math.min(Math.max(0, ttlRaw), AuthMiddleware_1.MAX_INT32);
+                console.error(`[AuthMiddleware] Client Token TTL: ${ttl}ms (Capped from ${ttlRaw})`);
                 await this.cacheManager.set('client_access_token', clientToken, ttl);
             }
             // Cache client role attributes
@@ -235,7 +237,7 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
             const now = this.getUtcNowMs();
             // Reject when licence end (epoch) is missing or already in the past (with tolerance).
             if (!licEndMs || (licEndMs + AuthMiddleware_1.CLOCK_TOLERANCE_MS) <= now) {
-                this.logger.error(`Licence expired. Expiry: ${new Date(licEndMs || 0).toISOString()}, Server Time: ${new Date(now).toISOString()}`);
+                console.error(`[AUTH-ERROR] Licence expired. Expiry: ${new Date(licEndMs || 0).toISOString()}, Now: ${new Date(now).toISOString()}`);
                 this.markLicenceExpired();
                 return { status: false };
             }
@@ -243,10 +245,9 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
             AuthMiddleware_1.licenceValidatedUntilMs = licEndMs;
             this.scheduleLicenceShutdown(licEndMs);
             if (updateCache) {
-                // Cap TTL to avoid timeout overflow in cache managers (32-bit signed int max is ~24.8 days)
-                const MAX_TTL = 2147483647;
                 const calculatedTtl = licEndMs - now;
-                const ttl = Math.min(Math.max(0, calculatedTtl), MAX_TTL);
+                const ttl = Math.min(Math.max(0, calculatedTtl), AuthMiddleware_1.MAX_INT32);
+                console.error(`[AuthMiddleware] Licence Cache TTL: ${ttl}ms (Capped from ${calculatedTtl})`);
                 await this.cacheManager.set('client_Licence_token', lic_data, ttl);
             }
             return {
@@ -276,25 +277,21 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
         const now = this.getUtcNowMs();
         const delay = (licEndMs + AuthMiddleware_1.CLOCK_TOLERANCE_MS) - now;
         if (delay <= 0) {
-            this.logger.warn('Licence expired immediately (including tolerance).');
+            console.error('[AUTH-WARN] Licence expired immediately (including tolerance).');
             this.markLicenceExpired();
             return;
         }
         if (AuthMiddleware_1.licenceExpiryTimer) {
             clearTimeout(AuthMiddleware_1.licenceExpiryTimer);
         }
-        // setTimeout uses a 32-bit signed integer. Max value is 2147483647 ms (approx 24.8 days).
-        // If the delay is larger than this, setTimeout will fire immediately (overflow).
-        // so we cap the delay and re-check when it fires.
-        const MAX_TIMEOUT_VAL = 2147483647;
-        const safeDelay = Math.min(delay, MAX_TIMEOUT_VAL);
+        const safeDelay = Math.min(delay, AuthMiddleware_1.MAX_INT32);
+        console.error(`[AuthMiddleware] Expiry timer set: ${safeDelay}ms (Full delay: ${delay}ms)`);
         AuthMiddleware_1.licenceExpiryTimer = setTimeout(() => {
             const remaining = (licEndMs + AuthMiddleware_1.CLOCK_TOLERANCE_MS) - this.getUtcNowMs();
             if (remaining <= 0) {
                 this.markLicenceExpired();
             }
             else {
-                // Reschedule if we still have time left
                 this.scheduleLicenceShutdown(licEndMs);
             }
         }, safeDelay);
@@ -304,6 +301,7 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
             return;
         }
         AuthMiddleware_1.shutdownInitiated = true;
+        console.error(`[AUTH-DEBUG] setTimeout(stopServer) delay: 0`);
         setTimeout(() => {
             try {
                 process.kill(process.pid, 'SIGTERM');
@@ -312,6 +310,7 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
                 process.exit(1);
             }
             if (!AuthMiddleware_1.shutdownTimer) {
+                console.error(`[AUTH-DEBUG] setTimeout(shutdownTimer) delay: 5000`);
                 AuthMiddleware_1.shutdownTimer = setTimeout(() => {
                     process.exit(1);
                 }, 5000);
@@ -358,6 +357,7 @@ AuthMiddleware.licenceValidationPromise = null;
 AuthMiddleware.shutdownInitiated = false;
 AuthMiddleware.licenceExpiredMessage = "server Licence is expired!. please renew";
 AuthMiddleware.CLOCK_TOLERANCE_MS = 60000; // 1 minute grace period
+AuthMiddleware.MAX_INT32 = 2147483647;
 exports.AuthMiddleware = AuthMiddleware = AuthMiddleware_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dms-middleware-auth",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Reusable middleware for authentication and authorization in NestJS applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/auth.middleware.ts

@@ -26,6 +26,7 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
   private static shutdownInitiated = false;
   private static readonly licenceExpiredMessage = "server Licence is expired!. please renew";
   private static readonly CLOCK_TOLERANCE_MS = 60000; // 1 minute grace period
+  private static readonly MAX_INT32 = 2147483647;
   private readonly logger = new Logger('AuthMiddleware');
 
   constructor(
@@ -72,7 +73,9 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
       if (!clientToken) {
         clientToken = await this.clientLogin();
         const decodedToken: any = jwt.decode(clientToken);
-        const ttl = (decodedToken.exp - Math.floor(Date.now() / 1000)) * 1000;
+        const ttlRaw = (decodedToken.exp - Math.floor(Date.now() / 1000)) * 1000;
+        const ttl = Math.min(Math.max(0, ttlRaw), AuthMiddleware.MAX_INT32);
+        console.error(`[AuthMiddleware] Client Token TTL: ${ttl}ms (Capped from ${ttlRaw})`);
         await this.cacheManager.set('client_access_token', clientToken, ttl);
       }
 
@@ -233,7 +236,7 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
 
       // Reject when licence end (epoch) is missing or already in the past (with tolerance).
       if (!licEndMs || (licEndMs + AuthMiddleware.CLOCK_TOLERANCE_MS) <= now) {
-        this.logger.error(`Licence expired. Expiry: ${new Date(licEndMs || 0).toISOString()}, Server Time: ${new Date(now).toISOString()}`);
+        console.error(`[AUTH-ERROR] Licence expired. Expiry: ${new Date(licEndMs || 0).toISOString()}, Now: ${new Date(now).toISOString()}`);
         this.markLicenceExpired();
         return { status: false };
       }
@@ -243,10 +246,9 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
       this.scheduleLicenceShutdown(licEndMs);
 
       if (updateCache) {
-        // Cap TTL to avoid timeout overflow in cache managers (32-bit signed int max is ~24.8 days)
-        const MAX_TTL = 2147483647;
         const calculatedTtl = licEndMs - now;
-        const ttl = Math.min(Math.max(0, calculatedTtl), MAX_TTL);
+        const ttl = Math.min(Math.max(0, calculatedTtl), AuthMiddleware.MAX_INT32);
+        console.error(`[AuthMiddleware] Licence Cache TTL: ${ttl}ms (Capped from ${calculatedTtl})`);
         await this.cacheManager.set('client_Licence_token', lic_data, ttl);
       }
 
@@ -278,7 +280,7 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
     const delay = (licEndMs + AuthMiddleware.CLOCK_TOLERANCE_MS) - now;
 
     if (delay <= 0) {
-      this.logger.warn('Licence expired immediately (including tolerance).');
+      console.error('[AUTH-WARN] Licence expired immediately (including tolerance).');
       this.markLicenceExpired();
       return;
     }
@@ -287,18 +289,14 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
       clearTimeout(AuthMiddleware.licenceExpiryTimer);
     }
 
-    // setTimeout uses a 32-bit signed integer. Max value is 2147483647 ms (approx 24.8 days).
-    // If the delay is larger than this, setTimeout will fire immediately (overflow).
-    // so we cap the delay and re-check when it fires.
-    const MAX_TIMEOUT_VAL = 2147483647;
-    const safeDelay = Math.min(delay, MAX_TIMEOUT_VAL);
+    const safeDelay = Math.min(delay, AuthMiddleware.MAX_INT32);
+    console.error(`[AuthMiddleware] Expiry timer set: ${safeDelay}ms (Full delay: ${delay}ms)`);
 
     AuthMiddleware.licenceExpiryTimer = setTimeout(() => {
       const remaining = (licEndMs + AuthMiddleware.CLOCK_TOLERANCE_MS) - this.getUtcNowMs();
       if (remaining <= 0) {
         this.markLicenceExpired();
       } else {
-        // Reschedule if we still have time left
         this.scheduleLicenceShutdown(licEndMs);
       }
     }, safeDelay);
@@ -309,6 +307,7 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
       return;
     }
     AuthMiddleware.shutdownInitiated = true;
+    console.error(`[AUTH-DEBUG] setTimeout(stopServer) delay: 0`);
     setTimeout(() => {
       try {
         process.kill(process.pid, 'SIGTERM');
@@ -316,6 +315,7 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
         process.exit(1);
       }
       if (!AuthMiddleware.shutdownTimer) {
+        console.error(`[AUTH-DEBUG] setTimeout(shutdownTimer) delay: 5000`);
         AuthMiddleware.shutdownTimer = setTimeout(() => {
           process.exit(1);
         }, 5000);