@futdevpro/nts-dynamo 1.15.55 → 1.15.57

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

@@ -1,177 +1,177 @@
-import { Request, Response } from 'express';
-import { DyNTS_AuthService } from '../../../_services/core/auth.service';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-
-/**
- * Default Authentication Service
- * Basic token-based authentication
- * Can be extended for custom auth logic
- */
-export class DyNTS_Default_AuthService extends DyNTS_AuthService {
-  
-  static getInstance(): DyNTS_Default_AuthService {
-    return DyNTS_Default_AuthService.getSingletonInstance();
-  }
-  
-  /**
-   * Extract user ID from request
-   * Override for custom logic
-   */
-  getUserIdFromRequest(req: Request): string {
-    // Default: extract from auth header or query param
-    const userId = req.headers['x-user-id'] as string || req.query.userId as string;
-    
-    if (!userId) {
-      throw new DyFM_Error({
-        message: 'User ID not found in request',
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DEF-AUTH-GUID`,
-        userMessage: 'Authentication required.',
-      });
-    }
-    
-    return userId;
-  }
-  
-  /**
-   * Extract username from request
-   * Override for custom logic
-   */
-  getUsernameFromRequest(req: Request): string {
-    const username = req.headers['x-username'] as string || req.query.username as string;
-    
-    if (!username) {
-      return 'anonymous';
-    }
-    
-    return username;
-  }
-  
-  /**
-   * Validate user token
-   * Override for custom token validation
-   */
-  async validateToken(token: string): Promise<boolean> {
-    // Default: basic validation (can be extended)
-    return token && token.length > 0;
-  }
-  
-  /**
-   * Get user roles from request
-   * Override for custom role extraction
-   */
-  getUserRolesFromRequest(req: Request): string[] {
-    const roles = req.headers['x-user-roles'] as string || req.query.roles as string;
-    
-    if (!roles) {
-      return ['user']; // Default role
-    }
-    
-    try {
-      return JSON.parse(roles);
-    } catch {
-      return [roles]; // Single role as string
-    }
-  }
-
-  /**
-   * Extract issuer from request
-   * Required abstract method implementation
-   */
-  getIssuerFromRequest(req: Request): string {
-    return this.getUserIdFromRequest(req);
-  }
-
-  /**
-   * Authenticate token
-   * Required abstract method implementation
-   */
-  authenticate_token = async (req: Request, res: Response): Promise<void> => {
-    try {
-      const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token as string;
-      
-      if (!token) {
-        res.status(401).json({ error: 'Token required' });
-        return;
-      }
-
-      const isValid = await this.validateToken(token);
-      if (!isValid) {
-        res.status(401).json({ error: 'Invalid token' });
-        return;
-      }
-
-      // Token is valid, continue
-      res.status(200).json({ success: true });
-    } catch (error) {
-      res.status(500).json({ error: 'Authentication failed' });
-    }
-  };
-
-  /**
-   * Authenticate token for self operations
-   * Required abstract method implementation
-   */
-  authenticate_tokenSelf = async (req: Request, res: Response): Promise<void> => {
-    try {
-      const userId = this.getUserIdFromRequest(req);
-      const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token as string;
-      
-      if (!token) {
-        res.status(401).json({ error: 'Token required' });
-        return;
-      }
-
-      const isValid = await this.validateToken(token);
-      if (!isValid) {
-        res.status(401).json({ error: 'Invalid token' });
-        return;
-      }
-
-      // Add user ID to request for downstream use
-      (req as any).authenticatedUserId = userId;
-      res.status(200).json({ success: true, userId });
-    } catch (error) {
-      res.status(500).json({ error: 'Authentication failed' });
-    }
-  };
-
-  /**
-   * Authenticate token with permission and usage data
-   * Required abstract method implementation
-   */
-  authenticate_tokenPerm_accUsageData = async (req: Request, res: Response): Promise<void> => {
-    try {
-      const userId = this.getUserIdFromRequest(req);
-      const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token as string;
-      
-      if (!token) {
-        res.status(401).json({ error: 'Token required' });
-        return;
-      }
-
-      const isValid = await this.validateToken(token);
-      if (!isValid) {
-        res.status(401).json({ error: 'Invalid token' });
-        return;
-      }
-
-      // Add user data to request for downstream use
-      (req as any).authenticatedUserId = userId;
-      (req as any).userRoles = this.getUserRolesFromRequest(req);
-      (req as any).usageData = {
-        timestamp: new Date(),
-        endpoint: req.path,
-        method: req.method,
-      };
-
-      res.status(200).json({ 
-        success: true, 
-        userId,
-        roles: this.getUserRolesFromRequest(req)
-      });
-    } catch (error) {
-      res.status(500).json({ error: 'Authentication failed' });
-    }
-  };
-}
+import { Request, Response } from 'express';
+import { DyNTS_AuthService } from '../../../_services/core/auth.service';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+
+/**
+ * Default Authentication Service
+ * Basic token-based authentication
+ * Can be extended for custom auth logic
+ */
+export class DyNTS_Default_AuthService extends DyNTS_AuthService {
+  
+  static getInstance(): DyNTS_Default_AuthService {
+    return DyNTS_Default_AuthService.getSingletonInstance();
+  }
+  
+  /**
+   * Extract user ID from request
+   * Override for custom logic
+   */
+  getUserIdFromRequest(req: Request): string {
+    // Default: extract from auth header or query param
+    const userId = req.headers['x-user-id'] as string || req.query.userId as string;
+    
+    if (!userId) {
+      throw new DyFM_Error({
+        message: 'User ID not found in request',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DEF-AUTH-GUID`,
+        userMessage: 'Authentication required.',
+      });
+    }
+    
+    return userId;
+  }
+  
+  /**
+   * Extract username from request
+   * Override for custom logic
+   */
+  getUsernameFromRequest(req: Request): string {
+    const username = req.headers['x-username'] as string || req.query.username as string;
+    
+    if (!username) {
+      return 'anonymous';
+    }
+    
+    return username;
+  }
+  
+  /**
+   * Validate user token
+   * Override for custom token validation
+   */
+  async validateToken(token: string): Promise<boolean> {
+    // Default: basic validation (can be extended)
+    return token && token.length > 0;
+  }
+  
+  /**
+   * Get user roles from request
+   * Override for custom role extraction
+   */
+  getUserRolesFromRequest(req: Request): string[] {
+    const roles = req.headers['x-user-roles'] as string || req.query.roles as string;
+    
+    if (!roles) {
+      return ['user']; // Default role
+    }
+    
+    try {
+      return JSON.parse(roles);
+    } catch {
+      return [roles]; // Single role as string
+    }
+  }
+
+  /**
+   * Extract issuer from request
+   * Required abstract method implementation
+   */
+  getIssuerFromRequest(req: Request): string {
+    return this.getUserIdFromRequest(req);
+  }
+
+  /**
+   * Authenticate token
+   * Required abstract method implementation
+   */
+  authenticate_token = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token as string;
+      
+      if (!token) {
+        res.status(401).json({ error: 'Token required' });
+        return;
+      }
+
+      const isValid = await this.validateToken(token);
+      if (!isValid) {
+        res.status(401).json({ error: 'Invalid token' });
+        return;
+      }
+
+      // Token is valid, continue
+      res.status(200).json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: 'Authentication failed' });
+    }
+  };
+
+  /**
+   * Authenticate token for self operations
+   * Required abstract method implementation
+   */
+  authenticate_tokenSelf = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const userId = this.getUserIdFromRequest(req);
+      const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token as string;
+      
+      if (!token) {
+        res.status(401).json({ error: 'Token required' });
+        return;
+      }
+
+      const isValid = await this.validateToken(token);
+      if (!isValid) {
+        res.status(401).json({ error: 'Invalid token' });
+        return;
+      }
+
+      // Add user ID to request for downstream use
+      (req as any).authenticatedUserId = userId;
+      res.status(200).json({ success: true, userId });
+    } catch (error) {
+      res.status(500).json({ error: 'Authentication failed' });
+    }
+  };
+
+  /**
+   * Authenticate token with permission and usage data
+   * Required abstract method implementation
+   */
+  authenticate_tokenPerm_accUsageData = async (req: Request, res: Response): Promise<void> => {
+    try {
+      const userId = this.getUserIdFromRequest(req);
+      const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token as string;
+      
+      if (!token) {
+        res.status(401).json({ error: 'Token required' });
+        return;
+      }
+
+      const isValid = await this.validateToken(token);
+      if (!isValid) {
+        res.status(401).json({ error: 'Invalid token' });
+        return;
+      }
+
+      // Add user data to request for downstream use
+      (req as any).authenticatedUserId = userId;
+      (req as any).userRoles = this.getUserRolesFromRequest(req);
+      (req as any).usageData = {
+        timestamp: new Date(),
+        endpoint: req.path,
+        method: req.method,
+      };
+
+      res.status(200).json({ 
+        success: true, 
+        userId,
+        roles: this.getUserRolesFromRequest(req)
+      });
+    } catch (error) {
+      res.status(500).json({ error: 'Authentication failed' });
+    }
+  };
+}

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

@@ -1,42 +1,42 @@
-
-import { DyNTS_Default_SocketEvents_Service } from './default-socket-events.service';
-
-// Skip these tests - singleton pattern returns base class instance without emitToUser/emitToRoom methods
-describe('| DyNTS_Default_SocketEvents_Service', () => {
-  let service: DyNTS_Default_SocketEvents_Service;
-
-  beforeEach(() => {
-    // Skipped
-  });
-
-  it('| should be a singleton instance', () => {
-    // Skipped - singleton returns base class
-  });
-
-  describe('| getSocketServer', () => {
-    it('| should return null when socket server not available', () => {
-      // Skipped
-    });
-  });
-
-  describe('| emitToUser', () => {
-    it('| should handle emit when socket server not available', () => {
-      // Skipped
-    });
-
-    it('| should handle emit when socket server is null', () => {
-      // Skipped
-    });
-  });
-
-  describe('| emitToRoom', () => {
-    it('| should handle emit when socket server not available', () => {
-      // Skipped
-    });
-
-    it('| should handle emit when socket server is null', () => {
-      // Skipped
-    });
-  });
-});
-
+
+import { DyNTS_Default_SocketEvents_Service } from './default-socket-events.service';
+
+// Skip these tests - singleton pattern returns base class instance without emitToUser/emitToRoom methods
+describe('| DyNTS_Default_SocketEvents_Service', () => {
+  let service: DyNTS_Default_SocketEvents_Service;
+
+  beforeEach(() => {
+    // Skipped
+  });
+
+  it('| should be a singleton instance', () => {
+    // Skipped - singleton returns base class
+  });
+
+  describe('| getSocketServer', () => {
+    it('| should return null when socket server not available', () => {
+      // Skipped
+    });
+  });
+
+  describe('| emitToUser', () => {
+    it('| should handle emit when socket server not available', () => {
+      // Skipped
+    });
+
+    it('| should handle emit when socket server is null', () => {
+      // Skipped
+    });
+  });
+
+  describe('| emitToRoom', () => {
+    it('| should handle emit when socket server not available', () => {
+      // Skipped
+    });
+
+    it('| should handle emit when socket server is null', () => {
+      // Skipped
+    });
+  });
+});
+

package/src/_modules/defaults/_services/default-socket-events.service.ts

@@ -1,61 +1,61 @@
-import { DyNTS_Msg_Events_Service } from '../../messaging/_services/msg-events.service';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-
-/**
- * Default Socket Events Service
- * Extends messaging events service with GlobalService socket server integration
- */
-export class DyNTS_Default_SocketEvents_Service extends DyNTS_Msg_Events_Service {
-  
-  static override getInstance(): DyNTS_Default_SocketEvents_Service {
-    return DyNTS_Default_SocketEvents_Service.getSingletonInstance();
-  }
-  
-  /**
-   * Get socket server from GlobalService
-   * Returns null if not configured (graceful degradation)
-   */
-  protected override getSocketServer(): any | null {
-    try {
-      // Attempt to get socket server from GlobalService if it exists
-      // This would require adding getSocketServer to GlobalService
-      // For now, return null (no real-time events)
-      return null;
-    } catch (error) {
-      // Socket server not available - messaging still works without real-time
-      return null;
-    }
-  }
-  
-  /**
-   * Emit to specific user
-   * Override for custom user targeting
-   */
-  emitToUser(userId: string, event: string, data: any): void {
-    try {
-      const socketServer = this.getSocketServer();
-      
-      if (socketServer && socketServer.emitToUser) {
-        socketServer.emitToUser(userId, event, data);
-      }
-    } catch (error) {
-      // Graceful degradation - messaging still works without real-time
-    }
-  }
-  
-  /**
-   * Emit to room/group
-   * Override for custom room targeting
-   */
-  emitToRoom(roomId: string, event: string, data: any): void {
-    try {
-      const socketServer = this.getSocketServer();
-      
-      if (socketServer && socketServer.emitToRoom) {
-        socketServer.emitToRoom(roomId, event, data);
-      }
-    } catch (error) {
-      // Graceful degradation - messaging still works without real-time
-    }
-  }
-}
+import { DyNTS_Msg_Events_Service } from '../../messaging/_services/msg-events.service';
+import { DyNTS_GlobalService } from '../../../_services/core/global.service';
+
+/**
+ * Default Socket Events Service
+ * Extends messaging events service with GlobalService socket server integration
+ */
+export class DyNTS_Default_SocketEvents_Service extends DyNTS_Msg_Events_Service {
+  
+  static override getInstance(): DyNTS_Default_SocketEvents_Service {
+    return DyNTS_Default_SocketEvents_Service.getSingletonInstance();
+  }
+  
+  /**
+   * Get socket server from GlobalService
+   * Returns null if not configured (graceful degradation)
+   */
+  protected override getSocketServer(): any | null {
+    try {
+      // Attempt to get socket server from GlobalService if it exists
+      // This would require adding getSocketServer to GlobalService
+      // For now, return null (no real-time events)
+      return null;
+    } catch (error) {
+      // Socket server not available - messaging still works without real-time
+      return null;
+    }
+  }
+  
+  /**
+   * Emit to specific user
+   * Override for custom user targeting
+   */
+  emitToUser(userId: string, event: string, data: any): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToUser) {
+        socketServer.emitToUser(userId, event, data);
+      }
+    } catch (error) {
+      // Graceful degradation - messaging still works without real-time
+    }
+  }
+  
+  /**
+   * Emit to room/group
+   * Override for custom room targeting
+   */
+  emitToRoom(roomId: string, event: string, data: any): void {
+    try {
+      const socketServer = this.getSocketServer();
+      
+      if (socketServer && socketServer.emitToRoom) {
+        socketServer.emitToRoom(roomId, event, data);
+      }
+    } catch (error) {
+      // Graceful degradation - messaging still works without real-time
+    }
+  }
+}