dms-middleware-auth 1.0.10 → 1.1.0

package/dist/auth.middleware.js

@@ -60,14 +60,12 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
     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) {
+                this.stopServer();
                 return res.status(axios_1.HttpStatusCode.Forbidden).json({ message: AuthMiddleware_1.licenceExpiredMessage });
             }
             if (!AuthMiddleware_1.licenceValidatedUntilMs) {
@@ -267,7 +265,7 @@ let AuthMiddleware = AuthMiddleware_1 = class AuthMiddleware {
         if (!AuthMiddleware_1.licenceExpired) {
             AuthMiddleware_1.licenceExpired = true;
         }
-        this.stopServer();
+        // this.stopServer();
     }
     scheduleLicenceShutdown(licEndMs) {
         if (!licEndMs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dms-middleware-auth",
-  "version": "1.0.10",
+  "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, OnModuleInit } 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,44 +16,45 @@ interface AuthMiddlewareOptions {
 }
 
 @Injectable()
-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) {
+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);
+    
+  }
+
+  async use(req: any, res: Response, next: NextFunction) {
 
 
     const { publicKey, clientId, realm, bypassURL } = this.options;
 
     try {
         if (AuthMiddleware.licenceExpired) {
+         
+        this.stopServer();
+    
         return res.status(HttpStatusCode.Forbidden).json({ message: AuthMiddleware.licenceExpiredMessage });
       }
 
-      if (!AuthMiddleware.licenceValidatedUntilMs) {
-        return res.status(HttpStatusCode.Forbidden).json({ message: AuthMiddleware.licenceExpiredMessage });
-      }
-      if (req.originalUrl == bypassURL) {
-        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 ')) {
@@ -173,36 +174,36 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
     }
   }
 
-  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 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) {
@@ -234,81 +235,81 @@ export class AuthMiddleware implements NestMiddleware, OnModuleInit {
       };
     }
   }
-  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 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)) {