dms-middleware-auth 1.0.9 → 1.0.10

package/dist/auth.middleware.d.ts

@@ -1,4 +1,4 @@
-import { NestMiddleware } from '@nestjs/common';
+import { NestMiddleware, OnModuleInit } from '@nestjs/common';
 import { Response, NextFunction } from 'express';
 import { Cache } from 'cache-manager';
 interface AuthMiddlewareOptions {
@@ -10,13 +10,18 @@ interface AuthMiddlewareOptions {
     clientUuid: string;
     bypassURL: string;
 }
-export declare class AuthMiddleware implements NestMiddleware {
+export declare class AuthMiddleware implements NestMiddleware, OnModuleInit {
     private cacheManager;
     private readonly options;
     private static licenceExpired;
     private static shutdownTimer;
+    private static licenceExpiryTimer;
+    private static licenceValidatedUntilMs;
+    private static licenceValidationPromise;
+    private static shutdownInitiated;
     private static readonly licenceExpiredMessage;
     constructor(cacheManager: Cache, options: AuthMiddlewareOptions);
+    onModuleInit(): Promise<void>;
     use(req: any, res: Response, next: NextFunction): Promise<void | Response<any, Record<string, any>>>;
     private clientLogin;
     private getUserDetails;
@@ -25,6 +30,8 @@ export declare class AuthMiddleware implements NestMiddleware {
     private getLicencingDetails;
     private validateLicence;
     private markLicenceExpired;
+    private scheduleLicenceShutdown;
+    private stopServer;
     private normalizeEpochMs;
     private verifyJwt;
     private decodeAccessToken;

package/dist/auth.middleware.js

@@ -57,18 +57,23 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
         this.cacheManager = cacheManager;
         this.options = options;
     }
+    async onModuleInit() {
+        const { publicKey, realm } = this.options;
+        const isValid = await this.checkLicenceAndValidate(realm, publicKey);
+        if (!isValid) {
+            this.stopServer();
+        }
+    }
     async use(req, res, next) {
         const { publicKey, clientId, realm, bypassURL } = this.options;
         try {
             if (AuthMiddleware_1.licenceExpired) {
                 return res.status(axios_1.HttpStatusCode.Forbidden).json({ message: AuthMiddleware_1.licenceExpiredMessage });
             }
-            // fetching the licence and validating. 
-            const validate_lic = await this.checkLicenceAndValidate(realm, publicKey);
-            if (!validate_lic) {
+            if (!AuthMiddleware_1.licenceValidatedUntilMs) {
                 return res.status(axios_1.HttpStatusCode.Forbidden).json({ message: AuthMiddleware_1.licenceExpiredMessage });
             }
-            else if (req.originalUrl == bypassURL && validate_lic) {
+            if (req.originalUrl == bypassURL) {
                 return next();
             }
             const authHeader = req.headers['authorization'];
@@ -170,26 +175,30 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
     }
     async checkLicenceAndValidate(realm, publicKey) {
         try {
-            // Reuse cached licence when possible; short-circuit if already marked expired.
             if (AuthMiddleware_1.licenceExpired) {
                 return false;
             }
-            const lic_token = await this.cacheManager.get('client_Licence_token');
-            if (!lic_token) {
+            if (AuthMiddleware_1.licenceValidatedUntilMs && AuthMiddleware_1.licenceValidatedUntilMs > Date.now()) {
+                return true;
+            }
+            if (AuthMiddleware_1.licenceValidationPromise) {
+                return await AuthMiddleware_1.licenceValidationPromise;
+            }
+            AuthMiddleware_1.licenceValidationPromise = (async () => {
                 const response = await this.getLicencingDetails(realm);
                 if (response.code === axios_1.HttpStatusCode.InternalServerError) {
                     return false;
                 }
                 else {
                     const validate = await this.validateLicence(response.data, publicKey);
-                    if (validate.status && validate.ttl) {
-                        await this.cacheManager.set('client_Licence_token', response.data, validate.ttl);
-                    }
                     return validate.status;
                 }
+            })();
+            try {
+                return await AuthMiddleware_1.licenceValidationPromise;
             }
-            else {
-                return await this.validateLicence(lic_token, publicKey);
+            finally {
+                AuthMiddleware_1.licenceValidationPromise = null;
             }
         }
         catch (error) {
@@ -227,6 +236,7 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
             const licEndMs = this.normalizeEpochMs(token?.lic_end);
             // Reject when licence end (epoch) is missing or already in the past.
             if (!licEndMs) {
+                this.markLicenceExpired();
                 return {
                     status: false
                 };
@@ -238,6 +248,8 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
                 };
             }
             else {
+                AuthMiddleware_1.licenceValidatedUntilMs = licEndMs;
+                this.scheduleLicenceShutdown(licEndMs);
                 return {
                     status: true,
                     ttl: (licEndMs - Date.now()) > 0 ? (licEndMs - Date.now()) : null
@@ -246,18 +258,51 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
         }
         catch (error) {
             this.markLicenceExpired();
-            return false;
+            return {
+                status: false
+            };
         }
     }
     markLicenceExpired() {
         if (!AuthMiddleware_1.licenceExpired) {
             AuthMiddleware_1.licenceExpired = true;
         }
-        if (!AuthMiddleware_1.shutdownTimer) {
-            AuthMiddleware_1.shutdownTimer = setTimeout(() => {
-                process.exit(1);
-            }, 2 * 60 * 1000); // waiting two minutes after shutdowning server.
+        this.stopServer();
+    }
+    scheduleLicenceShutdown(licEndMs) {
+        if (!licEndMs) {
+            return;
+        }
+        const delay = licEndMs - Date.now();
+        if (delay <= 0) {
+            this.markLicenceExpired();
+            return;
         }
+        if (AuthMiddleware_1.licenceExpiryTimer) {
+            return;
+        }
+        AuthMiddleware_1.licenceExpiryTimer = setTimeout(() => {
+            this.markLicenceExpired();
+        }, delay);
+    }
+    stopServer() {
+        if (AuthMiddleware_1.shutdownInitiated) {
+            return;
+        }
+        AuthMiddleware_1.shutdownInitiated = true;
+        setTimeout(() => {
+            try {
+                process.kill(process.pid, 'SIGTERM');
+            }
+            catch {
+                process.exit(1);
+            }
+            if (!AuthMiddleware_1.shutdownTimer) {
+                AuthMiddleware_1.shutdownTimer = setTimeout(() => {
+                    process.exit(1);
+                }, 5000);
+            }
+        }, 0);
     }
     normalizeEpochMs(epoch) {
         if (!epoch || Number.isNaN(epoch)) {
@@ -284,6 +329,10 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
 exports.AuthMiddleware = AuthMiddleware;
 AuthMiddleware.licenceExpired = false;
 AuthMiddleware.shutdownTimer = null;
+AuthMiddleware.licenceExpiryTimer = null;
+AuthMiddleware.licenceValidatedUntilMs = null;
+AuthMiddleware.licenceValidationPromise = null;
+AuthMiddleware.shutdownInitiated = false;
 AuthMiddleware.licenceExpiredMessage = "server Licence is expired!. please renew";
 exports.AuthMiddleware = AuthMiddleware = AuthMiddleware_1 = __decorate([
     (0, common_1.Injectable)(),

package/package.json

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

package/src/auth.middleware.ts

@@ -1,4 +1,4 @@
-import { Inject, Injectable, NestMiddleware } from '@nestjs/common';
+import { Inject, Injectable, NestMiddleware, OnModuleInit } from '@nestjs/common';
 import { Response, NextFunction } from 'express';
 import * as jwt from 'jsonwebtoken';
 import axios, { HttpStatusCode } from 'axios';
@@ -16,17 +16,29 @@ interface AuthMiddlewareOptions {
 }
 
 @Injectable()
-export class AuthMiddleware implements NestMiddleware {
-  private static licenceExpired = false;
-  private static shutdownTimer: NodeJS.Timeout | null = null;
-  private static readonly licenceExpiredMessage = "server Licence is expired!. please renew";
-
-  constructor(
-    @Inject(CACHE_MANAGER) private cacheManager: Cache,
-    @Inject('AUTH_MIDDLEWARE_OPTIONS') private readonly options: AuthMiddlewareOptions
-  ) {}
-
-  async use(req: any, res: Response, next: NextFunction) {
+export class AuthMiddleware implements NestMiddleware, OnModuleInit {
+  private static licenceExpired = false;
+  private static shutdownTimer: NodeJS.Timeout | null = null;
+  private static licenceExpiryTimer: NodeJS.Timeout | null = null;
+  private static licenceValidatedUntilMs: number | null = null;
+  private static licenceValidationPromise: Promise<boolean> | null = null;
+  private static shutdownInitiated = false;
+  private static readonly licenceExpiredMessage = "server Licence is expired!. please renew";
+
+  constructor(
+    @Inject(CACHE_MANAGER) private cacheManager: Cache,
+    @Inject('AUTH_MIDDLEWARE_OPTIONS') private readonly options: AuthMiddlewareOptions
+  ) {}
+
+  async onModuleInit() {
+    const { publicKey, realm } = this.options;
+    const isValid = await this.checkLicenceAndValidate(realm, publicKey);
+    if (!isValid) {
+      this.stopServer();
+    }
+  }
+
+  async use(req: any, res: Response, next: NextFunction) {
 
 
     const { publicKey, clientId, realm, bypassURL } = this.options;
@@ -36,14 +48,12 @@ export class AuthMiddleware implements NestMiddleware {
         return res.status(HttpStatusCode.Forbidden).json({ message: AuthMiddleware.licenceExpiredMessage });
       }
 
-      // fetching the licence and validating. 
-      const validate_lic = await this.checkLicenceAndValidate(realm, publicKey);
-      if (!validate_lic) {
-        return res.status(HttpStatusCode.Forbidden).json({message: AuthMiddleware.licenceExpiredMessage});
-      }
-      else if (req.originalUrl == bypassURL && validate_lic ) {
-       return  next();
-      }
+      if (!AuthMiddleware.licenceValidatedUntilMs) {
+        return res.status(HttpStatusCode.Forbidden).json({ message: AuthMiddleware.licenceExpiredMessage });
+      }
+      if (req.originalUrl == bypassURL) {
+        return next();
+      }
       const authHeader = req.headers['authorization'];
 
       if (!authHeader || !authHeader.startsWith('Bearer ')) {
@@ -163,34 +173,36 @@ export class AuthMiddleware implements NestMiddleware {
     }
   }
 
-  private async checkLicenceAndValidate(realm: string, publicKey:string) {
-    try {
-      // Reuse cached licence when possible; short-circuit if already marked expired.
-      if (AuthMiddleware.licenceExpired) {
-        return false;
-      }
-      const lic_token = await this.cacheManager.get( 'client_Licence_token' );
-      if (!lic_token) {
-        const response:any = await  this.getLicencingDetails(realm);
-        if (response.code === HttpStatusCode.InternalServerError) {
-          return false
-        }
-        else{
-          const validate:any = await this.validateLicence(response.data, publicKey);
-          if (validate.status && validate.ttl) {
-            await this.cacheManager.set('client_Licence_token', response.data, validate.ttl);
-          }
-        
-          return validate.status;
-        }
-      }
-      else {
-        return await this.validateLicence(lic_token, publicKey);
-      }
-    }
-    catch(error:any){
-      return false;
-
+  private async checkLicenceAndValidate(realm: string, publicKey:string) {
+    try {
+      if (AuthMiddleware.licenceExpired) {
+        return false;
+      }
+      if (AuthMiddleware.licenceValidatedUntilMs && AuthMiddleware.licenceValidatedUntilMs > Date.now()) {
+        return true;
+      }
+      if (AuthMiddleware.licenceValidationPromise) {
+        return await AuthMiddleware.licenceValidationPromise;
+      }
+      AuthMiddleware.licenceValidationPromise = (async () => {
+        const response:any = await  this.getLicencingDetails(realm);
+        if (response.code === HttpStatusCode.InternalServerError) {
+          return false
+        }
+        else{
+          const validate = await this.validateLicence(response.data, publicKey);
+          return validate.status;
+        }
+      })();
+      try {
+        return await AuthMiddleware.licenceValidationPromise;
+      } finally {
+        AuthMiddleware.licenceValidationPromise = null;
+      }
+    }
+    catch(error:any){
+      return false;
+
     }
   }
   private async getLicencingDetails(realm: string) {
@@ -222,45 +234,81 @@ export class AuthMiddleware implements NestMiddleware {
       };
     }
   }
-  private async validateLicence(lic_data:any, publicKey:any){
-    try{
-      const token:any  = await this.verifyJwt(lic_data, publicKey);
-      const licEndMs = this.normalizeEpochMs(token?.lic_end);
-      // Reject when licence end (epoch) is missing or already in the past.
-      if (!licEndMs) {
-        return{
-          status: false
-        } 
-      }
-      if (licEndMs <= Date.now()) {
-        this.markLicenceExpired();
-        return {
-          status: false
-        } 
-      } else {
-
-        return {
-          status: true,
-          ttl: (licEndMs - Date.now()) > 0 ?  (licEndMs - Date.now()) : null
-        } 
-      }
-    }
-    catch(error:any){
-      this.markLicenceExpired();
-      return false;
-    }
-  }
-
-  private markLicenceExpired() {
-    if (!AuthMiddleware.licenceExpired) {
-      AuthMiddleware.licenceExpired = true;
-    }
-    if (!AuthMiddleware.shutdownTimer) {
-      AuthMiddleware.shutdownTimer = setTimeout(() => {
-        process.exit(1);
-      }, 2 * 60 * 1000); // waiting two minutes after shutdowning server.
-    }
-  }
+  private async validateLicence(lic_data:any, publicKey:any){
+    try{
+      const token:any  = await this.verifyJwt(lic_data, publicKey);
+      const licEndMs = this.normalizeEpochMs(token?.lic_end);
+      // Reject when licence end (epoch) is missing or already in the past.
+      if (!licEndMs) {
+        this.markLicenceExpired();
+        return{
+          status: false
+        } 
+      }
+      if (licEndMs <= Date.now()) {
+        this.markLicenceExpired();
+        return {
+          status: false
+        } 
+      } else {
+        AuthMiddleware.licenceValidatedUntilMs = licEndMs;
+        this.scheduleLicenceShutdown(licEndMs);
+        return {
+          status: true,
+          ttl: (licEndMs - Date.now()) > 0 ?  (licEndMs - Date.now()) : null
+        } 
+      }
+    }
+    catch(error:any){
+      this.markLicenceExpired();
+      return {
+        status: false
+      };
+    }
+  }
+
+  private markLicenceExpired() {
+    if (!AuthMiddleware.licenceExpired) {
+      AuthMiddleware.licenceExpired = true;
+    }
+    this.stopServer();
+  }
+
+  private scheduleLicenceShutdown(licEndMs: number) {
+    if (!licEndMs) {
+      return;
+    }
+    const delay = licEndMs - Date.now();
+    if (delay <= 0) {
+      this.markLicenceExpired();
+      return;
+    }
+    if (AuthMiddleware.licenceExpiryTimer) {
+      return;
+    }
+    AuthMiddleware.licenceExpiryTimer = setTimeout(() => {
+      this.markLicenceExpired();
+    }, delay);
+  }
+
+  private stopServer() {
+    if (AuthMiddleware.shutdownInitiated) {
+      return;
+    }
+    AuthMiddleware.shutdownInitiated = true;
+    setTimeout(() => {
+      try {
+        process.kill(process.pid, 'SIGTERM');
+      } catch {
+        process.exit(1);
+      }
+      if (!AuthMiddleware.shutdownTimer) {
+        AuthMiddleware.shutdownTimer = setTimeout(() => {
+          process.exit(1);
+        }, 5000);
+      }
+    }, 0);
+  }
 
   private normalizeEpochMs(epoch: number): number | null {
     if (!epoch || Number.isNaN(epoch)) {