@common-stack/store-mongo 7.2.1-alpha.31 → 7.2.1-alpha.32

package/lib/moleculer-generation/typedMoleculerService.js

@@ -1,656 +0,0 @@
-import {Moleculer}from'./moleculerEventHandler.js';import {getAllMethodNames}from'./serviceGenerationUtils.js';// from package: store-mongo
-/**
- * @file typed-moleculer-service.ts
- * @description Provides type-safe base class for Moleculer services with ENFORCED
- * compile-time verification AND automatic action generation from service methods.
- */
-/**
- * Split parameters by comma, respecting nested structures
- */
-function splitParams(paramsStr) {
-    const params = [];
-    let current = '';
-    let depth = 0;
-    for (let i = 0; i < paramsStr.length; i++) {
-        const char = paramsStr[i];
-        if (char === '<' || char === '{' || char === '[' || char === '(') {
-            depth++;
-            current += char;
-        }
-        else if (char === '>' || char === '}' || char === ']' || char === ')') {
-            depth--;
-            current += char;
-        }
-        else if (char === ',' && depth === 0) {
-            params.push(current);
-            current = '';
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        params.push(current);
-    }
-    return params;
-}
-/**
- * Infer Moleculer validator type from TypeScript type annotation
- */
-function inferMoleculerType(typeAnnotation) {
-    const type = typeAnnotation.trim();
-    // Check for array types
-    if (type.endsWith('[]') || type.startsWith('Array<') || type.startsWith('ReadonlyArray<')) {
-        return 'array';
-    }
-    // Check for primitive types
-    if (type === 'string' || type === 'String')
-        return 'string';
-    if (type === 'number' || type === 'Number')
-        return 'number';
-    if (type === 'boolean' || type === 'Boolean')
-        return 'boolean';
-    // Check for common built-in types
-    if (type === 'Date')
-        return 'date';
-    if (type === 'RegExp')
-        return 'object';
-    // Check for union types with primitive
-    if (type.includes('|')) {
-        const types = type.split('|').map(t => t.trim());
-        // If all types are same primitive, return that
-        const nonNullTypes = types.filter(t => t !== 'null' && t !== 'undefined');
-        if (nonNullTypes.length === 1) {
-            return inferMoleculerType(nonNullTypes[0]);
-        }
-        // If contains string, number, or boolean, try to infer
-        if (nonNullTypes.some(t => t === 'string'))
-            return 'string';
-        if (nonNullTypes.some(t => t === 'number'))
-            return 'number';
-        if (nonNullTypes.some(t => t === 'boolean'))
-            return 'boolean';
-    }
-    // Check for enum types (assume string enum)
-    if (type.includes('Enum') || type.includes('Type')) {
-        return 'string';
-    }
-    // Default to object for interfaces, types, classes, etc.
-    return 'object';
-}
-/**
- * Infer type from default value
- */
-function inferTypeFromDefault(defaultValue) {
-    // String defaults
-    if (defaultValue.startsWith("'") || defaultValue.startsWith('"') || defaultValue.startsWith('`')) {
-        return 'string';
-    }
-    // Number defaults
-    if (/^-?\d+(\.\d+)?$/.test(defaultValue)) {
-        return 'number';
-    }
-    // Boolean defaults
-    if (defaultValue === 'true' || defaultValue === 'false') {
-        return 'boolean';
-    }
-    // Array defaults
-    if (defaultValue.startsWith('[')) {
-        return 'array';
-    }
-    // Object defaults
-    if (defaultValue.startsWith('{')) {
-        return 'object';
-    }
-    return 'object';
-}
-/**
- * Extract parameter names and infer types from a function's string representation
- * Returns array of { name, type } where type is the inferred Moleculer validator
- */
-function extractParamsWithTypes(funcStr) {
-    // Match function parameters: function(a, b) or (a, b) => or async (a, b) =>
-    const match = funcStr.match(/(?:function\s*)?(?:\w+\s*)?\(([^)]*)\)/);
-    if (!match || !match[1])
-        return [];
-    const paramsStr = match[1].trim();
-    if (!paramsStr)
-        return [];
-    const params = [];
-    // Split by comma, but handle nested objects/arrays
-    const paramParts = splitParams(paramsStr);
-    paramParts.forEach(param => {
-        const trimmed = param.trim();
-        if (!trimmed)
-            return;
-        // Check if optional (has ?)
-        const optional = trimmed.includes('?');
-        // Extract parameter name and type annotation
-        // Patterns: "name", "name?", "name: Type", "name?: Type", "name = default"
-        const paramMatch = trimmed.match(/^(\w+)\??(?:\s*:\s*([^=]+))?(?:\s*=\s*(.+))?/);
-        if (!paramMatch)
-            return;
-        const name = paramMatch[1];
-        const typeAnnotation = paramMatch[2]?.trim();
-        const defaultValue = paramMatch[3]?.trim();
-        // Infer Moleculer type from TypeScript annotation or default value
-        let moleculerType = 'object'; // Safe default
-        if (typeAnnotation) {
-            moleculerType = inferMoleculerType(typeAnnotation);
-        }
-        else if (defaultValue) {
-            moleculerType = inferTypeFromDefault(defaultValue);
-        }
-        params.push({
-            name,
-            type: moleculerType,
-            optional: optional || !!defaultValue,
-        });
-    });
-    return params;
-}
-// getAllMethodNames is now imported from serviceGenerationUtils.ts for consistency
-/**
- * ADVANCED AUTO-GENERATED: Generate actions with full control over inclusion, exclusion, and overrides.
- * Params are inferred from TypeScript function signatures with optional fine-grained control.
- *
- * @param service - The service instance to wrap
- * @param config - Advanced configuration for fine-grained control
- * @returns Actions object with handlers for selected service methods
- *
- * @example
- * ```typescript
- * // Basic: Auto-generate all methods
- * const actions = generateAutoInferredServiceActions<IAccountService>(accountService);
- *
- * // Advanced: Include only specific methods
- * const actions = generateAutoInferredServiceActions<IAccountService>(accountService, {
- *   include: ['findAccountById', 'createAccount', 'updateAccount']
- * });
- *
- * // Advanced: Exclude specific methods
- * const actions = generateAutoInferredServiceActions<IAccountService>(accountService, {
- *   exclude: ['deleteAccount', 'internalMethod']
- * });
- *
- * // Advanced: Override param schemas for specific methods
- * const actions = generateAutoInferredServiceActions<IAccountService>(accountService, {
- *   paramOverrides: {
- *     findAccountById: { id: 'string' },
- *     getUsers: { where: { type: 'object', optional: true } }
- *   }
- * });
- *
- * // Advanced: Add custom action configuration
- * const actions = generateAutoInferredServiceActions<IAccountService>(accountService, {
- *   actionConfig: {
- *     findAccountById: { cache: true, visibility: 'public' },
- *     deleteAccount: { visibility: 'protected' }
- *   }
- * });
- *
- * // Advanced: Combine multiple options
- * const actions = generateAutoInferredServiceActions<IAccountService>(accountService, {
- *   include: ['findAccountById', 'createAccount'],
- *   paramOverrides: {
- *     findAccountById: { id: 'string' }
- *   },
- *   actionConfig: {
- *     findAccountById: { cache: true }
- *   }
- * });
- * ```
- */
-function generateAutoInferredServiceActions(service, config = {}) {
-    const { paramOverrides = {}, include, exclude = [], actionToMethodMap = {}, actionConfig = {} } = config;
-    const actions = {};
-    // Get all methods from the service, including inherited methods from parent classes
-    const allKeys = getAllMethodNames(service);
-    allKeys.forEach((key) => {
-        // Skip constructor and private methods
-        if (key === 'constructor' || key.startsWith('_')) {
-            return;
-        }
-        // Apply include filter (whitelist) - takes precedence
-        if (include && include.length > 0) {
-            if (!include.includes(key)) {
-                return;
-            }
-        }
-        // Apply exclude filter (blacklist) - only if include is not specified
-        else if (exclude.includes(key)) {
-            return;
-        }
-        const method = service[key];
-        if (typeof method !== 'function') {
-            return;
-        }
-        const methodName = actionToMethodMap[key] || key;
-        const serviceMethod = service[methodName];
-        if (typeof serviceMethod !== 'function') {
-            return;
-        }
-        // Use runtime reflection to infer params and types from function signature
-        const funcStr = serviceMethod.toString();
-        const paramsWithTypes = extractParamsWithTypes(funcStr);
-        // Build param schema
-        let paramSchema;
-        // Use override if provided
-        if (paramOverrides[key]) {
-            paramSchema = paramOverrides[key];
-        }
-        else if (paramsWithTypes.length > 0) {
-            // Auto-generate schema from inferred types
-            paramSchema = paramsWithTypes.reduce((acc, param) => {
-                if (param.optional) {
-                    acc[param.name] = { type: param.type, optional: true };
-                }
-                else {
-                    acc[param.name] = param.type;
-                }
-                return acc;
-            }, {});
-        }
-        // Get custom action configuration if provided
-        const customActionConfig = actionConfig[key];
-        // Build the action object
-        const action = {
-            ...(paramSchema ? { params: paramSchema } : {}),
-            handler: (ctx) => {
-                const method = service[methodName];
-                const paramsObj = ctx.params || {};
-                const values = Object.values(paramsObj);
-                return method.apply(service, values.length > 0 ? values : [paramsObj]);
-            },
-        };
-        // Merge custom action config if provided (cache, visibility, etc.)
-        if (customActionConfig) {
-            Object.assign(action, customActionConfig);
-        }
-        actions[key] = action;
-    });
-    return actions;
-}
-/**
- * Generate both actions AND events from a service instance
- * - Actions: Generated from regular service methods
- * - Events: Generated from methods marked with @MoleculerEventHandler decorator
- *
- * @param service - The service instance to wrap
- * @param config - Configuration for actions and events
- * @returns Object with both actions and events
- *
- * @example
- * ```typescript
- * // Service with decorator
- * class OrganizationService {
- *     // Regular method becomes action
- *     async createOrganization(org: Org): Promise<Org> { }
- *
- *     // Decorated method becomes event handler
- *     @MoleculerEventHandler(UserBroadcasterAction.OnUserCreated)
- *     async onUserCreated(event: UserEvent): Promise<void> { }
- * }
- *
- * // Generate both
- * const { actions, events } = generateServiceActionsAndEvents(service);
- * ```
- */
-function generateServiceActionsAndEvents(service, config = {}) {
-    // Get event handlers from decorator metadata
-    const eventHandlers = Moleculer.getEventHandlers(service);
-    const eventHandlerMethods = new Set(eventHandlers.map(h => h.methodName));
-    // Generate actions (excluding event handler methods)
-    const actionsConfig = {
-        ...config,
-        exclude: [
-            ...(config.exclude || []),
-            ...Array.from(eventHandlerMethods),
-        ],
-    };
-    const actions = generateAutoInferredServiceActions(service, actionsConfig);
-    // Generate events from decorated methods
-    const events = {};
-    eventHandlers.forEach((metadata) => {
-        const method = service[metadata.methodName];
-        if (typeof method === 'function') {
-            events[metadata.eventName] = {
-                handler: async (ctx) => {
-                    // Event payload is typically wrapped in ctx.params.event
-                    const eventData = ctx.params.event || ctx.params;
-                    return method.call(service, eventData);
-                },
-                ...(metadata.group ? { group: metadata.group } : {}),
-            };
-        }
-    });
-    return { actions, events };
-}
-/**
- * Automatically generate Moleculer actions from a service instance.
- *
- * This eliminates the need to write repetitive action handlers - just pass your service
- * and it will create handlers that forward all calls automatically.
- *
- * @param service - The service instance to wrap
- * @param config - Optional configuration for customizing actions
- * @returns Actions object with handlers for all service methods
- *
- * @example
- * ```typescript
- * const actions = generateServiceActions(accountService, {
- *   params: {
- *     findAccountById: { id: 'string' },
- *     createAccount: { account: 'object' }
- *   },
- *   exclude: ['get', 'getAll'] // Handle these manually
- * });
- * ```
- */
-function generateServiceActions(service, config = {}) {
-    const { params = {}, exclude = [], actionToMethodMap = {} } = config;
-    const actions = {};
-    // Get all methods from the service
-    const allKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(service));
-    const generatedMethods = [];
-    allKeys.forEach((key) => {
-        // Skip excluded methods, constructors, and private methods
-        if (exclude.includes(key) || key === 'constructor' || key.startsWith('_')) {
-            return;
-        }
-        const method = service[key];
-        // Only process functions
-        if (typeof method !== 'function') {
-            return;
-        }
-        // Determine the method name to call (in case of mapping)
-        const methodName = actionToMethodMap[key] || key;
-        const serviceMethod = service[methodName];
-        if (typeof serviceMethod !== 'function') {
-            return;
-        }
-        generatedMethods.push(key);
-        // Create the action handler
-        actions[key] = {
-            ...(params[key] ? { params: params[key] } : {}),
-            handler: (ctx) => {
-                // Call the service method with ctx.params spread as arguments
-                const method = service[methodName];
-                // If params is an object with known keys, extract them in order
-                // Otherwise, pass the whole params object
-                const paramsObj = ctx.params || {};
-                const values = Object.values(paramsObj);
-                return method.apply(service, values.length > 0 ? values : [paramsObj]);
-            },
-        };
-    });
-    // In development, log methods that don't have param validation
-    if (process.env.NODE_ENV !== 'production') {
-        const methodsWithoutParams = generatedMethods.filter(method => !params[method]);
-        if (methodsWithoutParams.length > 0) {
-            console.warn(`⚠️  [generateServiceActions] The following methods don't have param validation defined:`, methodsWithoutParams);
-        }
-    }
-    return actions;
-}
-/**
- * TYPE-SAFE version: Generate Moleculer actions with COMPILE-TIME verification.
- * TypeScript will error if any service method is missing from params.
- *
- * @param service - The service instance to wrap
- * @param config - Type-safe configuration requiring ALL methods to have params
- * @returns Actions object with handlers for all service methods
- *
- * @example
- * ```typescript
- * const actions = generateTypeSafeServiceActions<IAccountService>(accountService, {
- *   params: {
- *     // TypeScript enforces ALL IAccountService methods are here!
- *     findAccountById: { id: 'string' },
- *     createAccount: { account: 'object' },
- *     // ... if you forget any method, TypeScript will error
- *   }
- * });
- * ```
- */
-function generateTypeSafeServiceActions(service, config) {
-    // Delegate to the regular function - type checking happens at compile time
-    return generateServiceActions(service, config);
-}
-/**
- * Verify that all service methods have param validation defined.
- * Throws an error if any methods are missing params.
- *
- * Use this in development to ensure you haven't forgotten any param schemas.
- *
- * @param service - The service instance
- * @param config - The config used for generateServiceActions
- * @throws Error if any methods are missing param validation
- *
- * @example
- * ```typescript
- * const config = { params: { ... }, exclude: [...] };
- * verifyAllParamsDefined(accountService, config); // Throws if params missing
- * const actions = generateServiceActions(accountService, config);
- * ```
- */
-function verifyAllParamsDefined(service, config = {}) {
-    const { params = {}, exclude = [] } = config;
-    const allKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(service));
-    const missingParams = [];
-    allKeys.forEach((key) => {
-        // Skip excluded methods, constructors, and private methods
-        if (exclude.includes(key) || key === 'constructor' || key.startsWith('_')) {
-            return;
-        }
-        const method = service[key];
-        // Only check functions
-        if (typeof method !== 'function') {
-            return;
-        }
-        // Check if params defined
-        if (!params[key]) {
-            missingParams.push(key);
-        }
-    });
-    if (missingParams.length > 0) {
-        const errorMessage = [
-            `Missing param validation for methods: ${missingParams.join(', ')}`,
-            '',
-            'Add these to your params config:',
-            ...missingParams.map(method => `  ${method}: { /* your params */ },`),
-        ].join('\n');
-        throw new Error(errorMessage);
-    }
-}
-/**
- * Helper to create a typed action handler
- */
-function createTypedAction(action) {
-    return action;
-}
-/**
- * DEBUG UTILITY: Dumps parameter information for all service methods
- *
- * This function extracts and logs parameter names, types, and inferred schemas
- * for debugging auto-generation issues. Use during development to understand
- * what the auto-generation sees and optimize paramOverrides.
- *
- * @param service - The service instance to analyze
- * @param config - Optional configuration to see what would be generated
- * @returns Object with detailed parameter information for each method
- *
- * @example
- * ```typescript
- * // In development/debug mode
- * const paramInfo = Moleculer.debugServiceParams(accountService);
- * console.log(JSON.stringify(paramInfo, null, 2));
- *
- * // With config to see filtered results
- * const paramInfo = Moleculer.debugServiceParams(accountService, {
- *   exclude: ['dispose', 'createUserToken']
- * });
- * ```
- */
-function debugServiceParams(service, config = {}) {
-    const { paramOverrides = {}, include, exclude = [], } = config;
-    const result = {};
-    // Get all methods from the service, including inherited methods
-    const allKeys = getAllMethodNames(service);
-    // Get event handler methods
-    const eventHandlers = Moleculer.getEventHandlers(service);
-    const eventHandlerMethods = new Set(eventHandlers.map(h => h.methodName));
-    allKeys.forEach((key) => {
-        // Skip constructor and private methods
-        if (key === 'constructor' || key.startsWith('_')) {
-            return;
-        }
-        const method = service[key];
-        if (typeof method !== 'function') {
-            return;
-        }
-        // Determine if this method would be excluded
-        const isEventHandler = eventHandlerMethods.has(key);
-        let isExcluded = false;
-        if (include && include.length > 0) {
-            isExcluded = !include.includes(key);
-        }
-        else {
-            isExcluded = exclude.includes(key) || isEventHandler;
-        }
-        // Get function signature
-        const funcStr = method.toString();
-        const paramsWithTypes = extractParamsWithTypes(funcStr);
-        // Extract just the function signature (first line with params)
-        const signatureMatch = funcStr.match(/^(?:async\s+)?(?:function\s+)?(?:\w+\s*)?\(([^)]*)\)/);
-        const signature = signatureMatch ? signatureMatch[0] : funcStr.split('{')[0].trim();
-        // Build inferred schema using new type inference
-        let inferredSchema;
-        if (paramsWithTypes.length > 0) {
-            inferredSchema = paramsWithTypes.reduce((acc, param) => {
-                if (param.optional) {
-                    acc[param.name] = { type: param.type, optional: true };
-                }
-                else {
-                    acc[param.name] = param.type;
-                }
-                return acc;
-            }, {});
-        }
-        // Get override schema if provided
-        const overrideSchema = paramOverrides[key];
-        result[key] = {
-            methodName: key,
-            paramNames: paramsWithTypes.map(p => p.name),
-            functionSignature: signature,
-            inferredSchema,
-            overrideSchema,
-            isExcluded,
-            isEventHandler,
-        };
-    });
-    return result;
-}
-/**
- * DEBUG UTILITY: Pretty prints service parameter information to console
- *
- * Formats and logs the output of debugServiceParams() in a readable way.
- * Shows which methods need paramOverrides and what types are inferred.
- *
- * @param service - The service instance to analyze
- * @param config - Optional configuration
- * @param options - Display options
- *
- * @example
- * ```typescript
- * // Print all methods
- * Moleculer.printServiceParams(accountService);
- *
- * // Print only methods without overrides
- * Moleculer.printServiceParams(accountService, config, { onlyMissingOverrides: true });
- *
- * // Print only included methods
- * Moleculer.printServiceParams(accountService, config, { onlyIncluded: true });
- * ```
- */
-function printServiceParams(service, config = {}, options = {}) {
-    const paramInfo = debugServiceParams(service, config);
-    const methods = Object.values(paramInfo);
-    const separator = '='.repeat(80);
-    const dashedLine = '-'.repeat(80);
-    console.log(`\n${separator}`);
-    console.log('SERVICE PARAMETER DEBUG INFORMATION');
-    console.log(`${separator}\n`);
-    // Summary statistics
-    const totalMethods = methods.length;
-    const includedMethods = methods.filter(m => !m.isExcluded);
-    const eventHandlers = methods.filter(m => m.isEventHandler);
-    const withOverrides = methods.filter(m => m.overrideSchema);
-    const withoutOverrides = includedMethods.filter(m => !m.overrideSchema && !m.isExcluded);
-    console.log('📊 SUMMARY:');
-    console.log(`  Total methods found: ${totalMethods}`);
-    console.log(`  Included in actions: ${includedMethods.length}`);
-    console.log(`  Event handlers (excluded from actions): ${eventHandlers.length}`);
-    console.log(`  With param overrides: ${withOverrides.length}`);
-    console.log(`  Without param overrides: ${withoutOverrides.length}`);
-    console.log(`\n${dashedLine}\n`);
-    // Filter methods based on options
-    let displayMethods = methods;
-    if (options.onlyMissingOverrides) {
-        displayMethods = displayMethods.filter(m => !m.overrideSchema && !m.isExcluded);
-    }
-    if (options.onlyIncluded) {
-        displayMethods = displayMethods.filter(m => !m.isExcluded);
-    }
-    if (!options.showExcluded) {
-        displayMethods = displayMethods.filter(m => !m.isExcluded);
-    }
-    // Print each method
-    displayMethods.forEach((info, index) => {
-        let status;
-        if (info.isExcluded) {
-            status = '❌ EXCLUDED';
-        }
-        else if (info.isEventHandler) {
-            status = '📡 EVENT HANDLER';
-        }
-        else if (info.overrideSchema) {
-            status = '✅ HAS OVERRIDE';
-        }
-        else {
-            status = '⚠️  NEEDS OVERRIDE';
-        }
-        console.log(`${index + 1}. ${info.methodName} ${status}`);
-        console.log(`   Signature: ${info.functionSignature}`);
-        console.log(`   Parameters: [${info.paramNames.join(', ')}]`);
-        if (info.inferredSchema) {
-            console.log(`   Inferred: ${JSON.stringify(info.inferredSchema)}`);
-        }
-        if (info.overrideSchema) {
-            console.log(`   Override: ${JSON.stringify(info.overrideSchema)}`);
-        }
-        console.log('');
-    });
-    // Suggestions
-    if (withoutOverrides.length > 0 && !options.onlyMissingOverrides) {
-        console.log(`\n${separator}`);
-        console.log('💡 SUGGESTIONS:');
-        console.log(`${separator}\n`);
-        console.log('The following methods use default "object" validation:');
-        console.log('Consider adding paramOverrides for better type safety:\n');
-        const suggestions = [];
-        withoutOverrides.forEach(info => {
-            const params = info.paramNames.map(p => `${p}: 'string'`).join(', ');
-            suggestions.push(`  ${info.methodName}: { ${params} },`);
-        });
-        console.log('paramOverrides: {');
-        console.log(suggestions.join('\n'));
-        console.log('}');
-    }
-    console.log(`\n${separator}\n`);
-}
-// Implement the namespace extensions
-Moleculer.generateAutoInferredActions = generateAutoInferredServiceActions;
-Moleculer.generateActionsAndEvents = generateServiceActionsAndEvents;
-Moleculer.debugServiceParams = debugServiceParams;
-Moleculer.printServiceParams = printServiceParams;export{createTypedAction,debugServiceParams,generateAutoInferredServiceActions,generateServiceActions,generateServiceActionsAndEvents,generateTypeSafeServiceActions,printServiceParams,verifyAllParamsDefined};//# sourceMappingURL=typedMoleculerService.js.map