@futdevpro/nts-dynamo 1.15.64 → 1.15.68

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

@@ -1,20 +1,20 @@
-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 declare 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);
-}
-export declare const DyNTS_defaultUser_dataParams: DyFM_DataModel_Params<DyNTS_Default_User>;
+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 declare 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);
+}
+export declare const DyNTS_defaultUser_dataParams: DyFM_DataModel_Params<DyNTS_Default_User>;
 //# sourceMappingURL=default-user.data-model.d.ts.map

package/build/_modules/defaults/_models/default-user.data-model.js

@@ -1,73 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_defaultUser_dataParams = exports.DyNTS_Default_User = void 0;
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const fsm_dynamo_2 = require("@futdevpro/fsm-dynamo");
-/**
- * Default User Model
- * Basic user model for authentication and user management
- * Can be extended or replaced with custom user models
- */
-class DyNTS_Default_User extends fsm_dynamo_1.DyFM_Metadata {
-    username;
-    email;
-    passwordHash;
-    displayName;
-    avatarUrl;
-    roles;
-    isActive;
-    lastLoginAt;
-    constructor(set) {
-        super(set);
-        if (set) {
-            Object.assign(this, set);
-        }
-    }
-}
-exports.DyNTS_Default_User = DyNTS_Default_User;
-exports.DyNTS_defaultUser_dataParams = new fsm_dynamo_2.DyFM_DataModel_Params({
-    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',
-        },
-    },
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_defaultUser_dataParams = exports.DyNTS_Default_User = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fsm_dynamo_2 = require("@futdevpro/fsm-dynamo");
+/**
+ * Default User Model
+ * Basic user model for authentication and user management
+ * Can be extended or replaced with custom user models
+ */
+class DyNTS_Default_User extends fsm_dynamo_1.DyFM_Metadata {
+    username;
+    email;
+    passwordHash;
+    displayName;
+    avatarUrl;
+    roles;
+    isActive;
+    lastLoginAt;
+    constructor(set) {
+        super(set);
+        if (set) {
+            Object.assign(this, set);
+        }
+    }
+}
+exports.DyNTS_Default_User = DyNTS_Default_User;
+exports.DyNTS_defaultUser_dataParams = new fsm_dynamo_2.DyFM_DataModel_Params({
+    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',
+        },
+    },
+});
 //# sourceMappingURL=default-user.data-model.js.map

package/build/_modules/defaults/_services/default-auth.service.d.ts

@@ -1,51 +1,51 @@
-import { Request, Response } from 'express';
-import { DyNTS_AuthService } from '../../../_services/core/auth.service';
-/**
- * Default Authentication Service
- * Basic token-based authentication
- * Can be extended for custom auth logic
- */
-export declare class DyNTS_Default_AuthService extends DyNTS_AuthService {
-    static getInstance(): DyNTS_Default_AuthService;
-    /**
-     * Extract user ID from request
-     * Override for custom logic
-     */
-    getUserIdFromRequest(req: Request): string;
-    /**
-     * Extract username from request
-     * Override for custom logic
-     */
-    getUsernameFromRequest(req: Request): string;
-    /**
-     * Validate user token
-     * Override for custom token validation
-     */
-    validateToken(token: string): Promise<boolean>;
-    /**
-     * Get user roles from request
-     * Override for custom role extraction
-     */
-    getUserRolesFromRequest(req: Request): string[];
-    /**
-     * Extract issuer from request
-     * Required abstract method implementation
-     */
-    getIssuerFromRequest(req: Request): string;
-    /**
-     * Authenticate token
-     * Required abstract method implementation
-     */
-    authenticate_token: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Authenticate token for self operations
-     * Required abstract method implementation
-     */
-    authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Authenticate token with permission and usage data
-     * Required abstract method implementation
-     */
-    authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
-}
+import { Request, Response } from 'express';
+import { DyNTS_AuthService } from '../../../_services/core/auth.service';
+/**
+ * Default Authentication Service
+ * Basic token-based authentication
+ * Can be extended for custom auth logic
+ */
+export declare class DyNTS_Default_AuthService extends DyNTS_AuthService {
+    static getInstance(): DyNTS_Default_AuthService;
+    /**
+     * Extract user ID from request
+     * Override for custom logic
+     */
+    getUserIdFromRequest(req: Request): string;
+    /**
+     * Extract username from request
+     * Override for custom logic
+     */
+    getUsernameFromRequest(req: Request): string;
+    /**
+     * Validate user token
+     * Override for custom token validation
+     */
+    validateToken(token: string): Promise<boolean>;
+    /**
+     * Get user roles from request
+     * Override for custom role extraction
+     */
+    getUserRolesFromRequest(req: Request): string[];
+    /**
+     * Extract issuer from request
+     * Required abstract method implementation
+     */
+    getIssuerFromRequest(req: Request): string;
+    /**
+     * Authenticate token
+     * Required abstract method implementation
+     */
+    authenticate_token: (req: Request, res: Response) => Promise<void>;
+    /**
+     * Authenticate token for self operations
+     * Required abstract method implementation
+     */
+    authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
+    /**
+     * Authenticate token with permission and usage data
+     * Required abstract method implementation
+     */
+    authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
+}
 //# sourceMappingURL=default-auth.service.d.ts.map

package/build/_modules/defaults/_services/default-auth.service.js

@@ -1,159 +1,159 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_Default_AuthService = void 0;
-const auth_service_1 = require("../../../_services/core/auth.service");
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const global_settings_const_1 = require("../../../_collections/global-settings.const");
-/**
- * Default Authentication Service
- * Basic token-based authentication
- * Can be extended for custom auth logic
- */
-class DyNTS_Default_AuthService extends auth_service_1.DyNTS_AuthService {
-    static getInstance() {
-        return DyNTS_Default_AuthService.getSingletonInstance();
-    }
-    /**
-     * Extract user ID from request
-     * Override for custom logic
-     */
-    getUserIdFromRequest(req) {
-        // Default: extract from auth header or query param
-        const userId = req.headers['x-user-id'] || req.query.userId;
-        if (!userId) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                message: 'User ID not found in request',
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DEF-AUTH-GUID`,
-                userMessage: 'Authentication required.',
-            });
-        }
-        return userId;
-    }
-    /**
-     * Extract username from request
-     * Override for custom logic
-     */
-    getUsernameFromRequest(req) {
-        const username = req.headers['x-username'] || req.query.username;
-        if (!username) {
-            return 'anonymous';
-        }
-        return username;
-    }
-    /**
-     * Validate user token
-     * Override for custom token validation
-     */
-    async validateToken(token) {
-        // Default: basic validation (can be extended)
-        return token && token.length > 0;
-    }
-    /**
-     * Get user roles from request
-     * Override for custom role extraction
-     */
-    getUserRolesFromRequest(req) {
-        const roles = req.headers['x-user-roles'] || req.query.roles;
-        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) {
-        return this.getUserIdFromRequest(req);
-    }
-    /**
-     * Authenticate token
-     * Required abstract method implementation
-     */
-    authenticate_token = async (req, res) => {
-        try {
-            const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token;
-            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, res) => {
-        try {
-            const userId = this.getUserIdFromRequest(req);
-            const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token;
-            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.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, res) => {
-        try {
-            const userId = this.getUserIdFromRequest(req);
-            const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token;
-            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.authenticatedUserId = userId;
-            req.userRoles = this.getUserRolesFromRequest(req);
-            req.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' });
-        }
-    };
-}
-exports.DyNTS_Default_AuthService = DyNTS_Default_AuthService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_Default_AuthService = void 0;
+const auth_service_1 = require("../../../_services/core/auth.service");
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const global_settings_const_1 = require("../../../_collections/global-settings.const");
+/**
+ * Default Authentication Service
+ * Basic token-based authentication
+ * Can be extended for custom auth logic
+ */
+class DyNTS_Default_AuthService extends auth_service_1.DyNTS_AuthService {
+    static getInstance() {
+        return DyNTS_Default_AuthService.getSingletonInstance();
+    }
+    /**
+     * Extract user ID from request
+     * Override for custom logic
+     */
+    getUserIdFromRequest(req) {
+        // Default: extract from auth header or query param
+        const userId = req.headers['x-user-id'] || req.query.userId;
+        if (!userId) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                message: 'User ID not found in request',
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-DEF-AUTH-GUID`,
+                userMessage: 'Authentication required.',
+            });
+        }
+        return userId;
+    }
+    /**
+     * Extract username from request
+     * Override for custom logic
+     */
+    getUsernameFromRequest(req) {
+        const username = req.headers['x-username'] || req.query.username;
+        if (!username) {
+            return 'anonymous';
+        }
+        return username;
+    }
+    /**
+     * Validate user token
+     * Override for custom token validation
+     */
+    async validateToken(token) {
+        // Default: basic validation (can be extended)
+        return token && token.length > 0;
+    }
+    /**
+     * Get user roles from request
+     * Override for custom role extraction
+     */
+    getUserRolesFromRequest(req) {
+        const roles = req.headers['x-user-roles'] || req.query.roles;
+        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) {
+        return this.getUserIdFromRequest(req);
+    }
+    /**
+     * Authenticate token
+     * Required abstract method implementation
+     */
+    authenticate_token = async (req, res) => {
+        try {
+            const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token;
+            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, res) => {
+        try {
+            const userId = this.getUserIdFromRequest(req);
+            const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token;
+            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.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, res) => {
+        try {
+            const userId = this.getUserIdFromRequest(req);
+            const token = req.headers.authorization?.replace('Bearer ', '') || req.query.token;
+            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.authenticatedUserId = userId;
+            req.userRoles = this.getUserRolesFromRequest(req);
+            req.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' });
+        }
+    };
+}
+exports.DyNTS_Default_AuthService = DyNTS_Default_AuthService;
 //# sourceMappingURL=default-auth.service.js.map

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

@@ -1,24 +1,24 @@
-import { DyNTS_Msg_Events_Service } from '../../messaging/_services/msg-events.service';
-/**
- * Default Socket Events Service
- * Extends messaging events service with GlobalService socket server integration
- */
-export declare class DyNTS_Default_SocketEvents_Service extends DyNTS_Msg_Events_Service {
-    static getInstance(): DyNTS_Default_SocketEvents_Service;
-    /**
-     * Get socket server from GlobalService
-     * Returns null if not configured (graceful degradation)
-     */
-    protected getSocketServer(): any | null;
-    /**
-     * Emit to specific user
-     * Override for custom user targeting
-     */
-    emitToUser(userId: string, event: string, data: any): void;
-    /**
-     * Emit to room/group
-     * Override for custom room targeting
-     */
-    emitToRoom(roomId: string, event: string, data: any): void;
-}
+import { DyNTS_Msg_Events_Service } from '../../messaging/_services/msg-events.service';
+/**
+ * Default Socket Events Service
+ * Extends messaging events service with GlobalService socket server integration
+ */
+export declare class DyNTS_Default_SocketEvents_Service extends DyNTS_Msg_Events_Service {
+    static getInstance(): DyNTS_Default_SocketEvents_Service;
+    /**
+     * Get socket server from GlobalService
+     * Returns null if not configured (graceful degradation)
+     */
+    protected getSocketServer(): any | null;
+    /**
+     * Emit to specific user
+     * Override for custom user targeting
+     */
+    emitToUser(userId: string, event: string, data: any): void;
+    /**
+     * Emit to room/group
+     * Override for custom room targeting
+     */
+    emitToRoom(roomId: string, event: string, data: any): void;
+}
 //# sourceMappingURL=default-socket-events.service.d.ts.map