dms-middleware-auth 1.0.9 → 1.1.0

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,21 @@ 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);
+    }
     async use(req, res, next) {
         const { publicKey, clientId, realm, bypassURL } = this.options;
         try {
             if (AuthMiddleware_1.licenceExpired) {
+                this.stopServer();
                 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 +173,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 +234,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 +246,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 +256,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 +327,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.1.0",
   "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,9 +16,13 @@ interface AuthMiddlewareOptions {
 }
 
 @Injectable()
-export class AuthMiddleware implements NestMiddleware {
+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(
@@ -26,6 +30,12 @@ export class AuthMiddleware implements NestMiddleware {
     @Inject('AUTH_MIDDLEWARE_OPTIONS') private readonly options: AuthMiddlewareOptions
   ) {}
 
+  async onModuleInit() {
+    const { publicKey, realm } = this.options;
+    const isValid = await this.checkLicenceAndValidate(realm, publicKey);
+    
+  }
+
   async use(req: any, res: Response, next: NextFunction) {
 
 
@@ -33,16 +43,17 @@ export class AuthMiddleware implements NestMiddleware {
 
     try {
         if (AuthMiddleware.licenceExpired) {
+         
+        this.stopServer();
+    
         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});
+      if (!AuthMiddleware.licenceValidatedUntilMs) {
+        return res.status(HttpStatusCode.Forbidden).json({ message: AuthMiddleware.licenceExpiredMessage });
       }
-      else if (req.originalUrl == bypassURL && validate_lic ) {
-       return  next();
+      if (req.originalUrl == bypassURL) {
+        return next();
       }
       const authHeader = req.headers['authorization'];
 
@@ -165,27 +176,29 @@ 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) {
+      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:any = await this.validateLicence(response.data, publicKey);
-          if (validate.status && validate.ttl) {
-            await this.cacheManager.set('client_Licence_token', response.data, validate.ttl);
-          }
-        
+          const validate = await this.validateLicence(response.data, publicKey);
           return validate.status;
         }
-      }
-      else {
-        return await this.validateLicence(lic_token, publicKey);
+      })();
+      try {
+        return await AuthMiddleware.licenceValidationPromise;
+      } finally {
+        AuthMiddleware.licenceValidationPromise = null;
       }
     }
     catch(error:any){
@@ -228,6 +241,7 @@ export class AuthMiddleware implements NestMiddleware {
       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,7 +252,8 @@ export class AuthMiddleware implements NestMiddleware {
           status: false
         } 
       } else {
-
+        AuthMiddleware.licenceValidatedUntilMs = licEndMs;
+        this.scheduleLicenceShutdown(licEndMs);
         return {
           status: true,
           ttl: (licEndMs - Date.now()) > 0 ?  (licEndMs - Date.now()) : null
@@ -247,7 +262,9 @@ export class AuthMiddleware implements NestMiddleware {
     }
     catch(error:any){
       this.markLicenceExpired();
-      return false;
+      return {
+        status: false
+      };
     }
   }
 
@@ -255,11 +272,43 @@ export class AuthMiddleware implements NestMiddleware {
     if (!AuthMiddleware.licenceExpired) {
       AuthMiddleware.licenceExpired = true;
     }
-    if (!AuthMiddleware.shutdownTimer) {
-      AuthMiddleware.shutdownTimer = setTimeout(() => {
-        process.exit(1);
-      }, 2 * 60 * 1000); // waiting two minutes after shutdowning server.
+   // 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 {