@futdevpro/nts-dynamo 1.15.68 → 1.15.71

package/src/_services/core/auth.service.spec.ts

@@ -1,159 +1,159 @@
-
-import { DyNTS_AuthService } from './auth.service';
-import { Request } from 'express';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-class TestAuthService extends DyNTS_AuthService {
-  static getInstance(): TestAuthService {
-    return TestAuthService.getSingletonInstance();
-  }
-
-  authenticate_token = async (req: Request, res: any): Promise<void> => {
-    // Mock implementation
-  };
-
-  authenticate_tokenSelf = async (req: Request, res: any): Promise<void> => {
-    // Mock implementation
-  };
-
-  authenticate_tokenPerm_accUsageData = async (req: Request, res: any): Promise<void> => {
-    // Mock implementation
-  };
-
-  getIssuerFromRequest(req: Request): string {
-    return 'test-issuer';
-  }
-
-  getUsernameFromRequest(req: Request): string {
-    return 'test-user';
-  }
-}
-
-describe('| DyNTS_AuthService', () => {
-  let service: TestAuthService;
-
-  beforeEach(() => {
-    service = TestAuthService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestAuthService.getInstance();
-    const instance2 = TestAuthService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestAuthService);
-  });
-
-  it('| should have default service name', () => {
-    expect(service.serviceName).toBe('AuthService');
-  });
-
-  it('| should have default error user message', () => {
-    expect(service.defaultErrorUserMsg).toBeDefined();
-    expect(service.defaultErrorUserMsg).toContain('Auth Error');
-  });
-
-  describe('| getTokenFromRequest', () => {
-    it('| should extract token from authorization header', () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer test-token-123',
-        },
-      } as any as Request;
-
-      const result = service.getTokenFromRequest(req);
-
-      expect(result).toBe('test-token-123');
-    });
-
-    it('| should throw error when authorization header is missing', () => {
-      const req = {
-        headers: {},
-      } as any as Request;
-
-      expect(() => {
-        service.getTokenFromRequest(req);
-      }).toThrow();
-    });
-
-    it('| should throw error when authorization header is null', () => {
-      const req = {
-        headers: {
-          authorization: null,
-        },
-      } as any as Request;
-
-      expect(() => {
-        service.getTokenFromRequest(req);
-      }).toThrow();
-    });
-
-    it('| should throw error when token is missing from header', () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer ',
-        },
-      } as any as Request;
-
-      expect(() => {
-        service.getTokenFromRequest(req);
-      }).toThrow();
-    });
-
-    it('| should throw error when authorization header does not contain Bearer', () => {
-      const req = {
-        headers: {
-          authorization: 'InvalidFormat token',
-        },
-      } as any as Request;
-
-      const result = service.getTokenFromRequest(req);
-
-      expect(result).toBe('token');
-    });
-
-    it('| should handle token with spaces correctly', () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer token-with-spaces',
-        },
-      } as any as Request;
-
-      const result = service.getTokenFromRequest(req);
-
-      expect(result).toBe('token-with-spaces');
-    });
-
-    it('| should include error code in thrown error', () => {
-      const req = {
-        headers: {},
-      } as any as Request;
-
-      try {
-        service.getTokenFromRequest(req);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-AS0-GT0');
-      }
-    });
-
-    it('| should include confidential content in error when header missing', () => {
-      const req = {
-        headers: {
-          'x-custom-header': 'value',
-        },
-      } as any as Request;
-
-      try {
-        service.getTokenFromRequest(req);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).confidentialContent).toBeDefined();
-      }
-    });
-  });
-});
-
+
+import { DyNTS_AuthService } from './auth.service';
+import { Request } from 'express';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+class TestAuthService extends DyNTS_AuthService {
+  static getInstance(): TestAuthService {
+    return TestAuthService.getSingletonInstance();
+  }
+
+  authenticate_token = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  authenticate_tokenSelf = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  authenticate_tokenPerm_accUsageData = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  getIssuerFromRequest(req: Request): string {
+    return 'test-issuer';
+  }
+
+  getUsernameFromRequest(req: Request): string {
+    return 'test-user';
+  }
+}
+
+describe('| DyNTS_AuthService', () => {
+  let service: TestAuthService;
+
+  beforeEach(() => {
+    service = TestAuthService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestAuthService.getInstance();
+    const instance2 = TestAuthService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestAuthService);
+  });
+
+  it('| should have default service name', () => {
+    expect(service.serviceName).toBe('AuthService');
+  });
+
+  it('| should have default error user message', () => {
+    expect(service.defaultErrorUserMsg).toBeDefined();
+    expect(service.defaultErrorUserMsg).toContain('Auth Error');
+  });
+
+  describe('| getTokenFromRequest', () => {
+    it('| should extract token from authorization header', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer test-token-123',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('test-token-123');
+    });
+
+    it('| should throw error when authorization header is missing', () => {
+      const req = {
+        headers: {},
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when authorization header is null', () => {
+      const req = {
+        headers: {
+          authorization: null,
+        },
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when token is missing from header', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer ',
+        },
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when authorization header does not contain Bearer', () => {
+      const req = {
+        headers: {
+          authorization: 'InvalidFormat token',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('token');
+    });
+
+    it('| should handle token with spaces correctly', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer token-with-spaces',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('token-with-spaces');
+    });
+
+    it('| should include error code in thrown error', () => {
+      const req = {
+        headers: {},
+      } as any as Request;
+
+      try {
+        service.getTokenFromRequest(req);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-AS0-GT0');
+      }
+    });
+
+    it('| should include confidential content in error when header missing', () => {
+      const req = {
+        headers: {
+          'x-custom-header': 'value',
+        },
+      } as any as Request;
+
+      try {
+        service.getTokenFromRequest(req);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).confidentialContent).toBeDefined();
+      }
+    });
+  });
+});
+

package/src/_services/core/auth.service.ts

@@ -1,174 +1,174 @@
-
-import { Request, Response } from 'express';
-
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_SingletonService } from '../base/singleton.service';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-/**
- * Extend this class as an Auth Service implementation
- * 
- * You should use singleton instance getting function by implementing a
- * static getInstance() function
- * @example
- * export class AuthService extends DyNTS_AuthService {
- *
- *   static getInstance(): AuthService {
- *     return AuthService.getSingletonInstance();
- *   }
- *   ...
- */
-export abstract class DyNTS_AuthService extends DyNTS_SingletonService {
-
-  readonly serviceName: string = 'AuthService';
-
-  override readonly defaultErrorUserMsg = 
-    `We encountered an unhandled Auth Error, ` +
-    `\nplease contact the responsible development team.`;
-
-  /**
-   * this function returns the 'authorization' header from the Request,
-   * or throws error, if its missing
-   * 
-   * @param req
-   * @returns 
-   */
-  getTokenFromRequest(req: Request): string {
-    const authHeader = req?.headers?.['authorization'];
-
-    if (!authHeader) {
-      throw new DyFM_Error({ 
-        status: 401,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT0`,
-        addECToUserMsg: true,
-        message: 'AuthHeader missing!',
-        userMessage: this.defaultErrorUserMsg, 
-        issuerService: this.serviceName,
-        confidentialContent: { headers: req?.headers },
-      });
-    }
-
-    const token = authHeader.split(' ')[1];
-    
-    if (!token) {
-      throw new DyFM_Error({ 
-        status: 401,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
-        addECToUserMsg: true,
-        message: 'Token missing!', 
-        userMessage: this.defaultErrorUserMsg, 
-        issuerService: this.serviceName,
-        confidentialContent: { headers: req?.headers },
-      });
-    }
-
-    return token;
-  }
-  
-  /**
-   * You need to implement a token validation logic, 
-   * when if the token is invalid, or the authentication fails, it sends or throws an error
-   * 
-   * @example
-   * 
-   * async authenticateToken(req: Request, res: Response, next: NextFunction) {
-   *   try {
-   *     let token = AuthService.getTokenFromRequest(req);
-   *     token = await AuthService.verifyToken(token);
-   * 
-   *     DyFM_Log.success('token authenticated');
-   *     res.setHeader('authorization', `Bearer ${token}`);
-   *     next();
-   *   } catch (error) {
-   *     error = new DyFM_Error({ 
-   *       status: 401, 
-   *       message: `authenticateToken (WB-ERROR)`,
-   *       addECToUserMsg: true,
-   *       userMessage: `Authorization failed.`, 
-   *       error 
-   *     });
-   *     DyFM_Log.error(error?.message, error);
-   * 
-   *     res.status(error.status);
-   *     res.send(error);
-   *   }
-   * }
-   * */
-  abstract authenticate_token: (req: Request, res: Response) => Promise<void>;
-
-  /**
-   * You need to implement a token validation logic, 
-   * when if the token is invalid, or the authentication fails, it sends or throws an error
-   * 
-   * @param req 
-   * @param res 
-   * @param next 
-   * 
-   * @example 
-   * 
-   * async authenticate_tokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
-   *   try {
-   *     let token = AuthService.getTokenFromRequest(req);
-   *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
-   *     DyFM_Log.success('selftoken authenticated');
-   * 
-   *     res.setHeader('authorization', `Bearer ${token}`);
-   *     next();
-   *   } catch (error) {
-   *     error = new DyFM_Error({ 
-   *       status: 401, 
-   *       message: `authenticate_tokenSelf (WB-ERROR)`,
-   *       addECToUserMsg: true,
-   *       userMessage: `Authorization failed.`, 
-   *       error 
-   *     });
-   *     DyFM_Log.error(error?.message, error);
-   * 
-   *     res.status(error.status);
-   *     res.send(error);
-   *   }
-   * }
-   * 
-   */
-  abstract authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
-  
-  /**
-   * Authenticate Token for Permission to Access UsageData
-   * @param req 
-   * @param res 
-   * @param next 
-   * 
-   * @example
-   * You need to implement a token validation logic, 
-   * when if the token is invalid, or the authentication fails, it sends or throws an error
-   * 
-   * async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
-   *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
-   * }
-   */
-  abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
-
-  /**
-   * The DynamoNTS System is using this to get issuer, that will be set on DBServices
-   * Don't throw error in this function, since it will be used in every request
-   * @param req 
-   * 
-   * @example
-   * getAccountIdFromRequest(req: Request): string {
-   *   try {
-   *     const authHeader = req.headers['authorization'];
-   *     const token = authHeader.split(' ')[1];
-   *     return this.getAccountIdFromToken(token);
-   *   } catch {
-   *     return undefined;
-   *   }
-   * }
-   */
-  abstract getIssuerFromRequest(req: Request): string;
-  /**
-   * Basic Module: UsageModule uses this function
-   * @param req 
-   */
-  abstract getUsernameFromRequest(req: Request): string;
-}
+
+import { Request, Response } from 'express';
+
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SingletonService } from '../base/singleton.service';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+/**
+ * Extend this class as an Auth Service implementation
+ * 
+ * You should use singleton instance getting function by implementing a
+ * static getInstance() function
+ * @example
+ * export class AuthService extends DyNTS_AuthService {
+ *
+ *   static getInstance(): AuthService {
+ *     return AuthService.getSingletonInstance();
+ *   }
+ *   ...
+ */
+export abstract class DyNTS_AuthService extends DyNTS_SingletonService {
+
+  readonly serviceName: string = 'AuthService';
+
+  override readonly defaultErrorUserMsg = 
+    `We encountered an unhandled Auth Error, ` +
+    `\nplease contact the responsible development team.`;
+
+  /**
+   * this function returns the 'authorization' header from the Request,
+   * or throws error, if its missing
+   * 
+   * @param req
+   * @returns 
+   */
+  getTokenFromRequest(req: Request): string {
+    const authHeader = req?.headers?.['authorization'];
+
+    if (!authHeader) {
+      throw new DyFM_Error({ 
+        status: 401,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT0`,
+        addECToUserMsg: true,
+        message: 'AuthHeader missing!',
+        userMessage: this.defaultErrorUserMsg, 
+        issuerService: this.serviceName,
+        confidentialContent: { headers: req?.headers },
+      });
+    }
+
+    const token = authHeader.split(' ')[1];
+    
+    if (!token) {
+      throw new DyFM_Error({ 
+        status: 401,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
+        addECToUserMsg: true,
+        message: 'Token missing!', 
+        userMessage: this.defaultErrorUserMsg, 
+        issuerService: this.serviceName,
+        confidentialContent: { headers: req?.headers },
+      });
+    }
+
+    return token;
+  }
+  
+  /**
+   * You need to implement a token validation logic, 
+   * when if the token is invalid, or the authentication fails, it sends or throws an error
+   * 
+   * @example
+   * 
+   * async authenticateToken(req: Request, res: Response, next: NextFunction) {
+   *   try {
+   *     let token = AuthService.getTokenFromRequest(req);
+   *     token = await AuthService.verifyToken(token);
+   * 
+   *     DyFM_Log.success('token authenticated');
+   *     res.setHeader('authorization', `Bearer ${token}`);
+   *     next();
+   *   } catch (error) {
+   *     error = new DyFM_Error({ 
+   *       status: 401, 
+   *       message: `authenticateToken (WB-ERROR)`,
+   *       addECToUserMsg: true,
+   *       userMessage: `Authorization failed.`, 
+   *       error 
+   *     });
+   *     DyFM_Log.error(error?.message, error);
+   * 
+   *     res.status(error.status);
+   *     res.send(error);
+   *   }
+   * }
+   * */
+  abstract authenticate_token: (req: Request, res: Response) => Promise<void>;
+
+  /**
+   * You need to implement a token validation logic, 
+   * when if the token is invalid, or the authentication fails, it sends or throws an error
+   * 
+   * @param req 
+   * @param res 
+   * @param next 
+   * 
+   * @example 
+   * 
+   * async authenticate_tokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
+   *   try {
+   *     let token = AuthService.getTokenFromRequest(req);
+   *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
+   *     DyFM_Log.success('selftoken authenticated');
+   * 
+   *     res.setHeader('authorization', `Bearer ${token}`);
+   *     next();
+   *   } catch (error) {
+   *     error = new DyFM_Error({ 
+   *       status: 401, 
+   *       message: `authenticate_tokenSelf (WB-ERROR)`,
+   *       addECToUserMsg: true,
+   *       userMessage: `Authorization failed.`, 
+   *       error 
+   *     });
+   *     DyFM_Log.error(error?.message, error);
+   * 
+   *     res.status(error.status);
+   *     res.send(error);
+   *   }
+   * }
+   * 
+   */
+  abstract authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
+  
+  /**
+   * Authenticate Token for Permission to Access UsageData
+   * @param req 
+   * @param res 
+   * @param next 
+   * 
+   * @example
+   * You need to implement a token validation logic, 
+   * when if the token is invalid, or the authentication fails, it sends or throws an error
+   * 
+   * async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
+   *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
+   * }
+   */
+  abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
+
+  /**
+   * The DynamoNTS System is using this to get issuer, that will be set on DBServices
+   * Don't throw error in this function, since it will be used in every request
+   * @param req 
+   * 
+   * @example
+   * getAccountIdFromRequest(req: Request): string {
+   *   try {
+   *     const authHeader = req.headers['authorization'];
+   *     const token = authHeader.split(' ')[1];
+   *     return this.getAccountIdFromToken(token);
+   *   } catch {
+   *     return undefined;
+   *   }
+   * }
+   */
+  abstract getIssuerFromRequest(req: Request): string;
+  /**
+   * Basic Module: UsageModule uses this function
+   * @param req 
+   */
+  abstract getUsernameFromRequest(req: Request): string;
+}