@futdevpro/nts-dynamo 1.15.53 → 1.15.55

package/src/_modules/defaults/_models/default-user.data-model.ts

@@ -1,72 +1,72 @@
-import { DyFM_Metadata } from '@futdevpro/fsm-dynamo';
-import { DyFM_DataModel_Params } from '@futdevpro/fsm-dynamo';
-
-/**
- * Default User Model
- * Basic user model for authentication and user management
- * Can be extended or replaced with custom user models
- */
-export class DyNTS_Default_User extends DyFM_Metadata {
-  username: string;
-  email: string;
-  passwordHash?: string;
-  displayName?: string;
-  avatarUrl?: string;
-  roles: string[];
-  isActive: boolean;
-  lastLoginAt?: Date;
-
-  constructor(set?: DyNTS_Default_User) {
-    super(set);
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
-}
-
-export const DyNTS_defaultUser_dataParams: DyFM_DataModel_Params<DyNTS_Default_User> =
-  new DyFM_DataModel_Params<DyNTS_Default_User>({
-    dataName: 'default-user RENAME OR EXTEND THIS DONT USE AS IS',
-    properties: {
-      username: { 
-        key: 'username', 
-        type: 'string', 
-        required: true, 
-        unique: true, 
-        index: true,
-      },
-      email: { 
-        key: 'email', 
-        type: 'string', 
-        required: true, 
-        unique: true, 
-        index: true,
-      },
-      passwordHash: { 
-        key: 'passwordHash', 
-        type: 'string',
-      },
-      displayName: { 
-        key: 'displayName', 
-        type: 'string',
-      },
-      avatarUrl: { 
-        key: 'avatarUrl', 
-        type: 'string',
-      },
-      roles: { 
-        key: 'roles', 
-        type: 'string[]', 
-        required: true,
-      },
-      isActive: { 
-        key: 'isActive', 
-        type: 'boolean', 
-        required: true,
-      },
-      lastLoginAt: { 
-        key: 'lastLoginAt', 
-        type: 'date',
-      },
-    },
-  });
+import { DyFM_Metadata } from '@futdevpro/fsm-dynamo';
+import { DyFM_DataModel_Params } from '@futdevpro/fsm-dynamo';
+
+/**
+ * Default User Model
+ * Basic user model for authentication and user management
+ * Can be extended or replaced with custom user models
+ */
+export class DyNTS_Default_User extends DyFM_Metadata {
+  username: string;
+  email: string;
+  passwordHash?: string;
+  displayName?: string;
+  avatarUrl?: string;
+  roles: string[];
+  isActive: boolean;
+  lastLoginAt?: Date;
+
+  constructor(set?: DyNTS_Default_User) {
+    super(set);
+    if (set) {
+      Object.assign(this, set);
+    }
+  }
+}
+
+export const DyNTS_defaultUser_dataParams: DyFM_DataModel_Params<DyNTS_Default_User> =
+  new DyFM_DataModel_Params<DyNTS_Default_User>({
+    dataName: 'default-user RENAME OR EXTEND THIS DONT USE AS IS',
+    properties: {
+      username: { 
+        key: 'username', 
+        type: 'string', 
+        required: true, 
+        unique: true, 
+        index: true,
+      },
+      email: { 
+        key: 'email', 
+        type: 'string', 
+        required: true, 
+        unique: true, 
+        index: true,
+      },
+      passwordHash: { 
+        key: 'passwordHash', 
+        type: 'string',
+      },
+      displayName: { 
+        key: 'displayName', 
+        type: 'string',
+      },
+      avatarUrl: { 
+        key: 'avatarUrl', 
+        type: 'string',
+      },
+      roles: { 
+        key: 'roles', 
+        type: 'string[]', 
+        required: true,
+      },
+      isActive: { 
+        key: 'isActive', 
+        type: 'boolean', 
+        required: true,
+      },
+      lastLoginAt: { 
+        key: 'lastLoginAt', 
+        type: 'date',
+      },
+    },
+  });

package/src/_modules/defaults/_services/default-auth.service.spec.ts

@@ -1,269 +1,269 @@
-
-import { DyNTS_Default_AuthService } from './default-auth.service';
-import { Request, Response } from 'express';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-// Skipped: DyFM_Error vs Error expectation issues
-describe('| DyNTS_Default_AuthService', () => {
-  let service: DyNTS_Default_AuthService;
-
-  beforeEach(() => {
-    service = DyNTS_Default_AuthService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = DyNTS_Default_AuthService.getInstance();
-    const instance2 = DyNTS_Default_AuthService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(DyNTS_Default_AuthService);
-  });
-
-  describe('| getUserIdFromRequest', () => {
-    it('| should extract user ID from x-user-id header', () => {
-      const req = {
-        headers: {
-          'x-user-id': 'user-123',
-        },
-      } as any as Request;
-
-      const result = service.getUserIdFromRequest(req);
-
-      expect(result).toBe('user-123');
-    });
-
-    it('| should extract user ID from query parameter', () => {
-      const req = {
-        headers: {},
-        query: {
-          userId: 'user-456',
-        },
-      } as any as Request;
-
-      const result = service.getUserIdFromRequest(req);
-
-      expect(result).toBe('user-456');
-    });
-
-    it('| should prioritize header over query parameter', () => {
-      const req = {
-        headers: {
-          'x-user-id': 'user-123',
-        },
-        query: {
-          userId: 'user-456',
-        },
-      } as any as Request;
-
-      const result = service.getUserIdFromRequest(req);
-
-      expect(result).toBe('user-123');
-    });
-
-    it('| should throw error when user ID not found', () => {
-      const req = {
-        headers: {},
-        query: {},
-      } as any as Request;
-
-      expect(() => {
-        service.getUserIdFromRequest(req);
-      }).toThrow();
-    });
-  });
-
-  describe('| getUsernameFromRequest', () => {
-    it('| should extract username from x-username header', () => {
-      const req = {
-        headers: {
-          'x-username': 'testuser',
-        },
-      } as any as Request;
-
-      const result = service.getUsernameFromRequest(req);
-
-      expect(result).toBe('testuser');
-    });
-
-    it('| should extract username from query parameter', () => {
-      const req = {
-        headers: {},
-        query: {
-          username: 'testuser2',
-        },
-      } as any as Request;
-
-      const result = service.getUsernameFromRequest(req);
-
-      expect(result).toBe('testuser2');
-    });
-
-    it('| should return anonymous when username not found', () => {
-      const req = {
-        headers: {},
-        query: {},
-      } as any as Request;
-
-      const result = service.getUsernameFromRequest(req);
-
-      expect(result).toBe('anonymous');
-    });
-  });
-
-  describe('| validateToken', () => {
-    it('| should return true for non-empty token', async () => {
-      const result = await service.validateToken('valid-token');
-
-      expect(result).toBe(true);
-    });
-
-    it('| should return false for empty token', async () => {
-      const result = await service.validateToken('');
-
-      expect(result).toBeFalsy();
-    });
-
-    it('| should return false for null token', async () => {
-      const result = await service.validateToken(null as never);
-
-      expect(result).toBeFalsy();
-    });
-  });
-
-  describe('| getUserRolesFromRequest', () => {
-    it('| should extract roles from x-user-roles header as JSON', () => {
-      const req = {
-        headers: {
-          'x-user-roles': JSON.stringify(['admin', 'user']),
-        },
-      } as any as Request;
-
-      const result = service.getUserRolesFromRequest(req);
-
-      expect(result).toEqual(['admin', 'user']);
-    });
-
-    it('| should extract roles from query parameter as JSON', () => {
-      const req = {
-        headers: {},
-        query: {
-          roles: JSON.stringify(['admin']),
-        },
-      } as any as Request;
-
-      const result = service.getUserRolesFromRequest(req);
-
-      expect(result).toEqual(['admin']);
-    });
-
-    it('| should return single role as array when not JSON', () => {
-      const req = {
-        headers: {
-          'x-user-roles': 'admin',
-        },
-      } as any as Request;
-
-      const result = service.getUserRolesFromRequest(req);
-
-      expect(result).toEqual(['admin']);
-    });
-
-    it('| should return default role when roles not found', () => {
-      const req = {
-        headers: {},
-        query: {},
-      } as any as Request;
-
-      const result = service.getUserRolesFromRequest(req);
-
-      expect(result).toEqual(['user']);
-    });
-  });
-
-  describe('| getIssuerFromRequest', () => {
-    it('| should return user ID from request', () => {
-      const req = {
-        headers: {
-          'x-user-id': 'user-123',
-        },
-      } as any as Request;
-
-      const result = service.getIssuerFromRequest(req);
-
-      expect(result).toBe('user-123');
-    });
-  });
-
-  describe('| authenticate_token', () => {
-    it('| should authenticate valid token from authorization header', async () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer valid-token',
-        },
-      } as any as Request;
-      const res = {
-        status: jasmine.createSpy('status').and.returnValue({
-          json: jasmine.createSpy('json'),
-        }),
-      } as any as Response;
-
-      await service.authenticate_token(req, res);
-
-      expect(res.status).toHaveBeenCalledWith(200);
-    });
-
-    it('| should authenticate valid token from query parameter', async () => {
-      const req = {
-        headers: {},
-        query: {
-          token: 'valid-token',
-        },
-      } as any as Request;
-      const res = {
-        status: jasmine.createSpy('status').and.returnValue({
-          json: jasmine.createSpy('json'),
-        }),
-      } as any as Response;
-
-      await service.authenticate_token(req, res);
-
-      expect(res.status).toHaveBeenCalledWith(200);
-    });
-
-    it('| should return 401 when token is missing', async () => {
-      const req = {
-        headers: {},
-        query: {},
-      } as any as Request;
-      const res = {
-        status: jasmine.createSpy('status').and.returnValue({
-          json: jasmine.createSpy('json'),
-        }),
-      } as any as Response;
-
-      await service.authenticate_token(req, res);
-
-      expect(res.status).toHaveBeenCalledWith(401);
-    });
-
-    it('| should return 401 when token is invalid', async () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer invalid-token',
-        },
-      } as Request;
-      const res = {
-        status: jasmine.createSpy('status').and.returnValue({
-          json: jasmine.createSpy('json'),
-        }),
-      } as unknown as Response;
-
-      spyOn(service, 'validateToken').and.returnValue(Promise.resolve(false));
-
-      await service.authenticate_token(req, res);
-
-      expect(res.status).toHaveBeenCalledWith(401);
-    });
-  });
-});
-
+
+import { DyNTS_Default_AuthService } from './default-auth.service';
+import { Request, Response } from 'express';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+// Skipped: DyFM_Error vs Error expectation issues
+describe('| DyNTS_Default_AuthService', () => {
+  let service: DyNTS_Default_AuthService;
+
+  beforeEach(() => {
+    service = DyNTS_Default_AuthService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = DyNTS_Default_AuthService.getInstance();
+    const instance2 = DyNTS_Default_AuthService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(DyNTS_Default_AuthService);
+  });
+
+  describe('| getUserIdFromRequest', () => {
+    it('| should extract user ID from x-user-id header', () => {
+      const req = {
+        headers: {
+          'x-user-id': 'user-123',
+        },
+      } as any as Request;
+
+      const result = service.getUserIdFromRequest(req);
+
+      expect(result).toBe('user-123');
+    });
+
+    it('| should extract user ID from query parameter', () => {
+      const req = {
+        headers: {},
+        query: {
+          userId: 'user-456',
+        },
+      } as any as Request;
+
+      const result = service.getUserIdFromRequest(req);
+
+      expect(result).toBe('user-456');
+    });
+
+    it('| should prioritize header over query parameter', () => {
+      const req = {
+        headers: {
+          'x-user-id': 'user-123',
+        },
+        query: {
+          userId: 'user-456',
+        },
+      } as any as Request;
+
+      const result = service.getUserIdFromRequest(req);
+
+      expect(result).toBe('user-123');
+    });
+
+    it('| should throw error when user ID not found', () => {
+      const req = {
+        headers: {},
+        query: {},
+      } as any as Request;
+
+      expect(() => {
+        service.getUserIdFromRequest(req);
+      }).toThrow();
+    });
+  });
+
+  describe('| getUsernameFromRequest', () => {
+    it('| should extract username from x-username header', () => {
+      const req = {
+        headers: {
+          'x-username': 'testuser',
+        },
+      } as any as Request;
+
+      const result = service.getUsernameFromRequest(req);
+
+      expect(result).toBe('testuser');
+    });
+
+    it('| should extract username from query parameter', () => {
+      const req = {
+        headers: {},
+        query: {
+          username: 'testuser2',
+        },
+      } as any as Request;
+
+      const result = service.getUsernameFromRequest(req);
+
+      expect(result).toBe('testuser2');
+    });
+
+    it('| should return anonymous when username not found', () => {
+      const req = {
+        headers: {},
+        query: {},
+      } as any as Request;
+
+      const result = service.getUsernameFromRequest(req);
+
+      expect(result).toBe('anonymous');
+    });
+  });
+
+  describe('| validateToken', () => {
+    it('| should return true for non-empty token', async () => {
+      const result = await service.validateToken('valid-token');
+
+      expect(result).toBe(true);
+    });
+
+    it('| should return false for empty token', async () => {
+      const result = await service.validateToken('');
+
+      expect(result).toBeFalsy();
+    });
+
+    it('| should return false for null token', async () => {
+      const result = await service.validateToken(null as never);
+
+      expect(result).toBeFalsy();
+    });
+  });
+
+  describe('| getUserRolesFromRequest', () => {
+    it('| should extract roles from x-user-roles header as JSON', () => {
+      const req = {
+        headers: {
+          'x-user-roles': JSON.stringify(['admin', 'user']),
+        },
+      } as any as Request;
+
+      const result = service.getUserRolesFromRequest(req);
+
+      expect(result).toEqual(['admin', 'user']);
+    });
+
+    it('| should extract roles from query parameter as JSON', () => {
+      const req = {
+        headers: {},
+        query: {
+          roles: JSON.stringify(['admin']),
+        },
+      } as any as Request;
+
+      const result = service.getUserRolesFromRequest(req);
+
+      expect(result).toEqual(['admin']);
+    });
+
+    it('| should return single role as array when not JSON', () => {
+      const req = {
+        headers: {
+          'x-user-roles': 'admin',
+        },
+      } as any as Request;
+
+      const result = service.getUserRolesFromRequest(req);
+
+      expect(result).toEqual(['admin']);
+    });
+
+    it('| should return default role when roles not found', () => {
+      const req = {
+        headers: {},
+        query: {},
+      } as any as Request;
+
+      const result = service.getUserRolesFromRequest(req);
+
+      expect(result).toEqual(['user']);
+    });
+  });
+
+  describe('| getIssuerFromRequest', () => {
+    it('| should return user ID from request', () => {
+      const req = {
+        headers: {
+          'x-user-id': 'user-123',
+        },
+      } as any as Request;
+
+      const result = service.getIssuerFromRequest(req);
+
+      expect(result).toBe('user-123');
+    });
+  });
+
+  describe('| authenticate_token', () => {
+    it('| should authenticate valid token from authorization header', async () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer valid-token',
+        },
+      } as any as Request;
+      const res = {
+        status: jasmine.createSpy('status').and.returnValue({
+          json: jasmine.createSpy('json'),
+        }),
+      } as any as Response;
+
+      await service.authenticate_token(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+    });
+
+    it('| should authenticate valid token from query parameter', async () => {
+      const req = {
+        headers: {},
+        query: {
+          token: 'valid-token',
+        },
+      } as any as Request;
+      const res = {
+        status: jasmine.createSpy('status').and.returnValue({
+          json: jasmine.createSpy('json'),
+        }),
+      } as any as Response;
+
+      await service.authenticate_token(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+    });
+
+    it('| should return 401 when token is missing', async () => {
+      const req = {
+        headers: {},
+        query: {},
+      } as any as Request;
+      const res = {
+        status: jasmine.createSpy('status').and.returnValue({
+          json: jasmine.createSpy('json'),
+        }),
+      } as any as Response;
+
+      await service.authenticate_token(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(401);
+    });
+
+    it('| should return 401 when token is invalid', async () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer invalid-token',
+        },
+      } as Request;
+      const res = {
+        status: jasmine.createSpy('status').and.returnValue({
+          json: jasmine.createSpy('json'),
+        }),
+      } as unknown as Response;
+
+      spyOn(service, 'validateToken').and.returnValue(Promise.resolve(false));
+
+      await service.authenticate_token(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(401);
+    });
+  });
+});
+