@common-stack/server-core 7.2.1-alpha.47 → 7.2.1-alpha.49

package/lib/moleculer-generation/typedMoleculerService.js

@@ -0,0 +1,685 @@
+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;
+        }
+        // Skip utility methods that should never be exposed as actions
+        if (['dispose', 'broker', 'logger', 'topic', 'callAction'].includes(key)) {
+            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
+        // Build the action object
+        const action = {
+            ...(paramSchema ? { params: paramSchema } : {}),
+            handler: (ctx) => {
+                const method = service[methodName];
+                const paramsObj = ctx.params || {};
+                // Extract parameters in the correct order based on method signature
+                // Use paramsWithTypes to maintain parameter order
+                const args = paramsWithTypes.length > 0
+                    ? paramsWithTypes.map((param) => {
+                        let value = paramsObj[param.name];
+                        // If parameter not found by name and this is a single parameter method,
+                        // treat the entire paramsObj as the parameter value
+                        if (value === undefined && paramsWithTypes.length === 1) {
+                            value = paramsObj;
+                            // TODO: SECURITY - Add parameter validation and sanitization
+                            // - Validate against Zod schema before passing to method
+                            // - Sanitize MongoDB operators (strip $ prefixed fields)
+                            // - Prevent prototype pollution (__proto__, constructor, prototype)
+                            // - Whitelist allowed parameter fields
+                            // See: Parameter injection, NoSQL injection, type confusion risks
+                            console.warn('[MoleculerService] SECURITY WARNING: Passing entire params object as single parameter for method:', methodName, '- Implement validation before production use');
+                        }
+                        // For optional parameters, provide empty object if still undefined
+                        if (param.optional && value === undefined) {
+                            return {};
+                        }
+                        return value;
+                    })
+                    : [paramsObj]; // Fallback: pass entire params object if no signature info
+                if (methodName === 'getAll') {
+                    console.log('[MoleculerService] getAll args to be passed:', JSON.stringify(args, null, 2));
+                }
+                return method.apply(service, args);
+            },
+        };
+        // 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;
+                    await method.call(service, eventData);
+                    // Explicitly return void for Moleculer event handler signature
+                },
+                ...(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