@common-stack/store-mongo 8.0.2-alpha.0 → 8.1.1-alpha.13

package/lib/templates/repositories/typedMoleculerService.ts.template.toberemoved

@@ -0,0 +1,1188 @@
+/**
+ * @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.
+ */
+
+/* eslint-disable @typescript-eslint/no-namespace */
+import type { ServiceSchema } from 'moleculer';
+import { Moleculer } from './moleculerEventHandler';
+
+/**
+ * Exclude base service CRUD methods and lifecycle methods
+ */
+type ExcludedMethods =
+    | 'dispose'
+    | 'get'
+    | 'getAll'
+    | 'bulkDelete'
+    | 'delete'
+    | 'count'
+    | 'getByName'
+    | 'getByIds'
+    | 'getAllWithCount'
+    | 'create'
+    | 'update'
+    | 'bulkCreate'
+    | 'insert';
+
+/**
+ * Extract all method names from a service interface (excluding base methods)
+ */
+export type ServiceMethods<T> = {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    [K in keyof T]: T[K] extends Function ? (K extends ExcludedMethods ? never : K) : never;
+}[keyof T];
+
+/**
+ * Required actions type - forces all service methods to have actions
+ */
+export type RequiredServiceActions<TService> = {
+    [K in ServiceMethods<TService>]: {
+        params?: Record<string, unknown>;
+        handler: (...args: unknown[]) => unknown;
+    };
+};
+
+/**
+ * Service schema with REQUIRED typed actions - TypeScript will error if any are missing
+ */
+export interface EnforcedServiceSchema<TService> extends Omit<ServiceSchema, 'actions'> {
+    name: string; // Required by Moleculer
+    actions: RequiredServiceActions<TService> & Record<string, unknown>;
+}
+
+/**
+ * Infer Moleculer param type from TypeScript function parameter types
+ * Maps TypeScript types to Moleculer validation strings
+ * 
+ * @internal Reserved for future advanced type inference
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type InferMoleculerParamType<T> = 
+    T extends string ? 'string' :
+    T extends number ? 'number' :
+    T extends boolean ? 'boolean' :
+    T extends unknown[] ? 'array' :
+    T extends object ? 'object' :
+    'any';
+
+/**
+ * Extract parameter types from a function signature
+ * 
+ * @internal Reserved for future advanced type inference
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type FunctionParams<T> = T extends (...args: infer P) => unknown ? P : never;
+
+/**
+ * Split parameters by comma, respecting nested structures
+ */
+function splitParams(paramsStr: string): string[] {
+    const params: string[] = [];
+    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: string): string {
+    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): string {
+    // 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: string): Array<{ name: string; type: string; optional: boolean }> {
+    // 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: Array<{ name: string; type: string; optional: boolean }> = [];
+    
+    // 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;
+}
+
+/**
+ * Extract parameter names from a function's string representation (legacy)
+ * @deprecated Use extractParamsWithTypes instead
+ */
+function extractParamNames(funcStr: string): string[] {
+    const params = extractParamsWithTypes(funcStr);
+    return params.map(p => p.name);
+}
+
+/**
+ * ADVANCED AUTO-GENERATED configuration with full control
+ * Params are inferred from TypeScript function signatures with optional fine-grained control
+ */
+export type AutoInferredActionConfig<TService> = {
+    /**
+     * Optional: Override param schemas for specific methods
+     * Use this when you need custom Moleculer validation beyond the default 'object' type
+     * 
+     * @example
+     * ```typescript
+     * paramOverrides: {
+     *   findAccountById: { id: 'string' },  // Override inferred 'object' with 'string'
+     *   getUsers: { where: { type: 'object', optional: true } }  // Add optional flag
+     * }
+     * ```
+     */
+    paramOverrides?: Partial<{
+        [K in ServiceMethods<TService>]: Record<string, unknown>;
+    }>;
+    
+    /**
+     * Optional: Only include specific methods (whitelist approach)
+     * If specified, ONLY these methods will be auto-generated
+     * Takes precedence over exclude
+     * 
+     * @example
+     * ```typescript
+     * include: ['findAccountById', 'createAccount', 'updateAccount']
+     * ```
+     */
+    include?: Array<ServiceMethods<TService>>;
+    
+    /**
+     * Optional: Exclude specific methods from auto-generation (blacklist approach)
+     * Ignored if 'include' is specified
+     * 
+     * @example
+     * ```typescript
+     * exclude: ['deleteAccount', 'internalMethod']
+     * ```
+     */
+    exclude?: Array<ServiceMethods<TService>>;
+    
+    /**
+     * Optional: Map action names to different method names
+     * Use this when your Moleculer action name differs from the service method name
+     * 
+     * @example
+     * ```typescript
+     * actionToMethodMap: {
+     *   'accounts.find': 'findAccountById',
+     *   'accounts.create': 'createAccount'
+     * }
+     * ```
+     */
+    actionToMethodMap?: Record<string, string>;
+    
+    /**
+     * Optional: Add custom Moleculer action properties for specific methods
+     * Allows setting visibility, caching, rate limiting, etc.
+     * 
+     * @example
+     * ```typescript
+     * actionConfig: {
+     *   findAccountById: {
+     *     cache: true,
+     *     visibility: 'public'
+     *   },
+     *   deleteAccount: {
+     *     visibility: 'protected'
+     *   }
+     * }
+     * ```
+     */
+    actionConfig?: Partial<{
+        [K in ServiceMethods<TService>]: {
+            cache?: boolean | object;
+            visibility?: 'public' | 'protected' | 'private';
+            [key: string]: unknown;
+        };
+    }>;
+};
+
+/**
+ * Helper function to get all method names from an object, including inherited methods
+ * from the entire prototype chain (excluding Object.prototype methods)
+ * 
+ * @param obj - The object to get methods from
+ * @returns Array of method names
+ */
+function getAllMethodNames(obj: unknown): string[] {
+    const methods = new Set<string>();
+    let current = obj;
+    
+    // Traverse up the prototype chain
+    while (current && current !== Object.prototype) {
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype && prototype !== Object.prototype) {
+            Object.getOwnPropertyNames(prototype).forEach(name => {
+                // Only add functions, not constructors or private methods
+                if (name !== 'constructor' && !name.startsWith('_')) {
+                    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+                    if (descriptor && typeof descriptor.value === 'function') {
+                        methods.add(name);
+                    }
+                }
+            });
+        }
+        current = prototype;
+    }
+    
+    return Array.from(methods);
+}
+
+/**
+ * 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 }
+ *   }
+ * });
+ * ```
+ */
+export function generateAutoInferredServiceActions<TService>(
+    service: TService,
+    config: AutoInferredActionConfig<TService> = {},
+): Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }> {
+    const { 
+        paramOverrides = {}, 
+        include, 
+        exclude = [], 
+        actionToMethodMap = {},
+        actionConfig = {}
+    } = config;
+    const actions: Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }> = {};
+    
+    // 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 as ServiceMethods<TService>)) {
+                return;
+            }
+        }
+        // Apply exclude filter (blacklist) - only if include is not specified
+        else if (exclude.includes(key as ServiceMethods<TService>)) {
+            return;
+        }
+        
+        const method = (service as Record<string, unknown>)[key];
+        if (typeof method !== 'function') {
+            return;
+        }
+        
+        const methodName = actionToMethodMap[key] || key;
+        const serviceMethod = (service as Record<string, unknown>)[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: Record<string, unknown> | undefined;
+        
+        // Use override if provided
+        if (paramOverrides[key as keyof typeof paramOverrides]) {
+            paramSchema = paramOverrides[key as keyof typeof paramOverrides] as Record<string, unknown>;
+        } 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;
+            }, {} as Record<string, unknown>);
+        }
+        
+        // Get custom action configuration if provided
+        const customActionConfig = actionConfig[key as keyof typeof actionConfig];
+        
+        // Build the action object
+        const action: { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown; [key: string]: unknown } = {
+            ...(paramSchema ? { params: paramSchema } : {}),
+            handler: (ctx: { params: Record<string, unknown> }) => {
+                const method = (service as Record<string, (...args: unknown[]) => unknown>)[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);
+ * ```
+ */
+export function generateServiceActionsAndEvents<TService>(
+    service: TService,
+    config: AutoInferredActionConfig<TService> = {},
+): {
+    actions: Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown; [key: string]: unknown }>;
+    events: Record<string, { handler: (ctx: unknown) => unknown; group?: string }>;
+} {
+    // Get event handlers from decorator metadata
+    const eventHandlers = Moleculer.getEventHandlers(service as object);
+    const eventHandlerMethods = new Set(eventHandlers.map(h => h.methodName));
+    
+    // Generate actions (excluding event handler methods)
+    const actionsConfig: AutoInferredActionConfig<TService> = {
+        ...config,
+        exclude: [
+            ...(config.exclude || []),
+            ...Array.from(eventHandlerMethods) as Array<ServiceMethods<TService>>,
+        ],
+    };
+    
+    const actions = generateAutoInferredServiceActions<TService>(service, actionsConfig);
+    
+    // Generate events from decorated methods
+    const events: Record<string, { handler: (ctx: unknown) => unknown; group?: string }> = {};
+    
+    eventHandlers.forEach((metadata: Moleculer.EventHandlerMetadata) => {
+        const method = (service as Record<string, unknown>)[metadata.methodName];
+        
+        if (typeof method === 'function') {
+            events[metadata.eventName] = {
+                handler: async (ctx: { params: { event?: unknown } }) => {
+                    // Event payload is typically wrapped in ctx.params.event
+                    const eventData = ctx.params.event || ctx.params;
+                    return (method as (...args: unknown[]) => unknown).call(service, eventData);
+                },
+                ...(metadata.group ? { group: metadata.group } : {}),
+            };
+        }
+    });
+    
+    return { actions, events };
+}
+
+export interface AutoActionConfig {
+    /**
+     * Custom parameter validation schema for specific actions
+     * Key is the action/method name, value is Moleculer params schema
+     */
+    params?: Record<string, Record<string, unknown>>;
+    
+    /**
+     * Actions to exclude from auto-generation (use manual handlers instead)
+     */
+    exclude?: string[];
+    
+    /**
+     * Action name mappings (if action name differs from method name)
+     * Key is the action name, value is the method name
+     */
+    actionToMethodMap?: Record<string, string>;
+}
+
+/**
+ * Type-safe configuration that REQUIRES params for ALL service methods
+ * TypeScript will show compile error if any method is missing from params
+ */
+export type TypeSafeActionConfig<TService> = {
+    /**
+     * REQUIRED: Parameter validation schema for ALL service methods
+     * TypeScript will error if any method is missing
+     */
+    params: {
+        [K in ServiceMethods<TService>]: Record<string, unknown>;
+    };
+    
+    /**
+     * Optional: Actions to exclude from auto-generation
+     */
+    exclude?: string[];
+    
+    /**
+     * Optional: Action name mappings
+     */
+    actionToMethodMap?: Record<string, string>;
+};
+
+/**
+ * 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
+ * });
+ * ```
+ */
+export function generateServiceActions<TService extends Record<string, unknown>>(
+    service: TService,
+    config: AutoActionConfig = {},
+): Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }> {
+    const { params = {}, exclude = [], actionToMethodMap = {} } = config;
+    const actions: Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }> = {};
+    
+    // Get all methods from the service
+    const allKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(service));
+    const generatedMethods: string[] = [];
+    
+    allKeys.forEach((key) => {
+        // Skip excluded methods, constructors, and private methods
+        if (exclude.includes(key) || key === 'constructor' || key.startsWith('_')) {
+            return;
+        }
+        
+        const method = (service as Record<string, unknown>)[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 as Record<string, unknown>)[methodName];
+        
+        if (typeof serviceMethod !== 'function') {
+            return;
+        }
+        
+        generatedMethods.push(key);
+        
+        // Create the action handler
+        actions[key] = {
+            ...(params[key] ? { params: params[key] } : {}),
+            handler: (ctx: { params: Record<string, unknown> }) => {
+                // Call the service method with ctx.params spread as arguments
+                const method = (service as Record<string, (...args: unknown[]) => unknown>)[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
+ *   }
+ * });
+ * ```
+ */
+export function generateTypeSafeServiceActions<TService>(
+    service: TService,
+    config: TypeSafeActionConfig<TService>,
+): Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }> {
+    // Delegate to the regular function - type checking happens at compile time
+    return generateServiceActions(service as unknown as Record<string, unknown>, config as AutoActionConfig);
+}
+
+/**
+ * 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);
+ * ```
+ */
+export function verifyAllParamsDefined<TService extends Record<string, unknown>>(
+    service: TService,
+    config: AutoActionConfig = {},
+): void {
+    const { params = {}, exclude = [] } = config;
+    const allKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(service));
+    const missingParams: string[] = [];
+    
+    allKeys.forEach((key) => {
+        // Skip excluded methods, constructors, and private methods
+        if (exclude.includes(key) || key === 'constructor' || key.startsWith('_')) {
+            return;
+        }
+        
+        const method = (service as Record<string, unknown>)[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);
+    }
+}
+
+/**
+ * Type-safe Moleculer Service base class with ENFORCED action verification.
+ *
+ * @deprecated Use generateServiceActionsAndEvents() or generateAutoInferredServiceActions() instead
+ * This class requires importing Moleculer Service which causes build issues.
+ * 
+ * Usage with auto-generated actions:
+ * ```typescript
+ * export class AccountMoleculerService extends Service {
+ *     constructor(broker: ServiceBroker, { container }: { container: Container }) {
+ *         super(broker);
+ *         const accountService = container.get<IAccountService>(SERVER_TYPES.IAccountService);
+ *
+ *         // Automatically generate ALL actions from the service!
+ *         const autoActions = generateAutoInferredServiceActions(accountService);
+ *
+ *         this.parseServiceSchema({
+ *             name: MoleculerServiceName.AccountUser,
+ *             actions: autoActions,
+ *         });
+ *     }
+ * }
+ * ```
+ */
+// export class TypedMoleculerService<TService> extends Service {
+//     constructor(broker: ServiceBroker) {
+//         super(broker);
+//     }
+
+//     protected generateActions<T extends Record<string, unknown>>(
+//         service: T,
+//         config?: AutoActionConfig,
+//     ): Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }> {
+//         return generateServiceActions(service, config);
+//     }
+
+//     protected parseTypedServiceSchema<T = TService>(schema: EnforcedServiceSchema<T>): void {
+//         this.parseServiceSchema(schema as ServiceSchema);
+//     }
+
+//     protected parsePartialServiceSchema(schema: ServiceSchema): void {
+//         this.parseServiceSchema(schema);
+//     }
+// }
+
+/**
+ * Placeholder for TypedMoleculerService for backward compatibility
+ * @deprecated Use generateServiceActionsAndEvents() instead
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type TypedMoleculerService<TService> = unknown;
+
+/**
+ * Helper type for explicit verification - use in const to get better error messages
+ */
+export type VerifyAllActionsImplemented<TService> = {
+    [K in ServiceMethods<TService>]: true;
+};
+
+/**
+ * Typed action handler with parameter and return type safety
+ */
+export interface TypedActionHandler<TParams = unknown, TReturn = unknown> {
+    params?: Record<string, unknown>;
+    handler: (ctx: { params: TParams }) => TReturn | Promise<TReturn>;
+}
+
+/**
+ * Helper to create a typed action handler
+ */
+export function createTypedAction<TParams, TReturn>(
+    action: TypedActionHandler<TParams, TReturn>,
+): TypedActionHandler<TParams, TReturn> {
+    return action;
+}
+
+/**
+ * Service schema type with better action type hints
+ */
+export interface TypedServiceSchema extends ServiceSchema {
+    actions?: Record<string, TypedActionHandler>;
+}
+
+/**
+ * Extend Moleculer namespace with action generation utilities
+ */
+declare module './moleculerEventHandler' {
+    export namespace Moleculer {
+        /**
+         * ADVANCED AUTO-GENERATED configuration with full control
+         */
+        export type AutoInferredActionConfig<TService> = {
+            paramOverrides?: Partial<{
+                [K in ServiceMethods<TService>]: Record<string, unknown>;
+            }>;
+            include?: Array<ServiceMethods<TService>>;
+            exclude?: Array<ServiceMethods<TService>>;
+            actionToMethodMap?: Record<string, string>;
+            actionConfig?: Partial<{
+                [K in ServiceMethods<TService>]: {
+                    cache?: boolean | object;
+                    visibility?: 'public' | 'protected' | 'private';
+                    [key: string]: unknown;
+                };
+            }>;
+        };
+
+        /**
+         * Generate actions with full control over inclusion, exclusion, and overrides.
+         * Params are inferred from TypeScript function signatures.
+         */
+        export function generateAutoInferredActions<TService>(
+            service: TService,
+            config?: AutoInferredActionConfig<TService>,
+        ): Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown }>;
+
+        /**
+         * Generate both actions AND events from a service instance
+         */
+        export function generateActionsAndEvents<TService>(
+            service: TService,
+            config?: AutoInferredActionConfig<TService>,
+        ): {
+            actions: Record<string, { params?: Record<string, unknown>; handler: (ctx: unknown) => unknown; [key: string]: unknown }>;
+            events: Record<string, { handler: (ctx: unknown) => unknown; group?: string }>;
+        };
+
+        /**
+         * DEBUG UTILITY: Extract parameter information for all service methods
+         * Returns detailed information about parameters, schemas, and configurations
+         */
+        export function debugServiceParams<TService>(
+            service: TService,
+            config?: AutoInferredActionConfig<TService>,
+        ): Record<string, {
+            methodName: string;
+            paramNames: string[];
+            functionSignature: string;
+            inferredSchema: Record<string, unknown> | undefined;
+            overrideSchema: Record<string, unknown> | undefined;
+            isExcluded: boolean;
+            isEventHandler: boolean;
+        }>;
+
+        /**
+         * DEBUG UTILITY: Pretty print service parameter information to console
+         * Useful for understanding auto-generation and identifying methods needing overrides
+         */
+        export function printServiceParams<TService>(
+            service: TService,
+            config?: AutoInferredActionConfig<TService>,
+            options?: {
+                onlyMissingOverrides?: boolean;
+                onlyIncluded?: boolean;
+                showExcluded?: boolean;
+            },
+        ): void;
+    }
+}
+
+/**
+ * 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']
+ * });
+ * ```
+ */
+export function debugServiceParams<TService>(
+    service: TService,
+    config: AutoInferredActionConfig<TService> = {},
+): Record<string, {
+    methodName: string;
+    paramNames: string[];
+    functionSignature: string;
+    inferredSchema: Record<string, unknown> | undefined;
+    overrideSchema: Record<string, unknown> | undefined;
+    isExcluded: boolean;
+    isEventHandler: boolean;
+}> {
+    const { 
+        paramOverrides = {}, 
+        include, 
+        exclude = [], 
+    } = config;
+    
+    const result: Record<string, {
+        methodName: string;
+        paramNames: string[];
+        functionSignature: string;
+        inferredSchema: Record<string, unknown> | undefined;
+        overrideSchema: Record<string, unknown> | undefined;
+        isExcluded: boolean;
+        isEventHandler: boolean;
+    }> = {};
+    
+    // Get all methods from the service, including inherited methods
+    const allKeys = getAllMethodNames(service);
+    
+    // Get event handler methods
+    const eventHandlers = Moleculer.getEventHandlers(service as object);
+    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 as Record<string, unknown>)[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 as ServiceMethods<TService>);
+        } else {
+            isExcluded = exclude.includes(key as ServiceMethods<TService>) || 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: Record<string, unknown> | undefined;
+        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;
+            }, {} as Record<string, unknown>);
+        }
+        
+        // Get override schema if provided
+        const overrideSchema = paramOverrides[key as keyof typeof paramOverrides] as Record<string, unknown> | undefined;
+        
+        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 });
+ * ```
+ */
+export function printServiceParams<TService>(
+    service: TService,
+    config: AutoInferredActionConfig<TService> = {},
+    options: {
+        onlyMissingOverrides?: boolean;
+        onlyIncluded?: boolean;
+        showExcluded?: boolean;
+    } = {},
+): void {
+    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: string;
+        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: string[] = [];
+        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;
+
+
+
+