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

package/lib/index.d.ts

@@ -5,4 +5,3 @@ export * from './dataloaders';
 export * from './mixins';
 export * from './interfaces';
 export * from './interfaces/index.old';
-export * from './moleculer-generation';

package/lib/index.js

@@ -1 +1 @@
-export{generateMongo}from'./helpers/mongoose-connection.js';export{BaseService2}from'./services/BaseService.js';export{BaseProxyService2}from'./services/BaseProxyService.js';export{BaseService}from'./services/base-service.js';export{BaseProxyService}from'./services/base-proxy-service.js';export{addIdVirtualFields2,commonModelSchemaOptions2}from'./store/models/common-options-v2.js';export{addIdVirtualFields,commonModeSchemaOptions}from'./store/models/common-options.js';export{BaseMongoRepository}from'./store/repositories/BaseMongoRepository.js';export{BaseRepository}from'./store/repositories/base-repository.js';export{BulkDataLoader2}from'./dataloaders/bulk-dataloader-v2.js';export{BulkDataLoader}from'./dataloaders/bulk-dataloader.js';export{BaseServiceMixin as BaseServiceMixin2}from'./mixins/BaseServiceMixin.js';export{BaseServiceMixin}from'./mixins/base-service-mixin.js';export{PAGINATION_OPTIONS}from'./interfaces/getAllArgs.js';export{buildActionPath,getActionName,getAllMethodNames,isExcludedMethod,toPascalCase}from'./moleculer-generation/serviceGenerationUtils.js';export{Moleculer}from'./moleculer-generation/moleculerEventHandler.js';export{createTypedAction,debugServiceParams,generateAutoInferredServiceActions,generateServiceActions,generateServiceActionsAndEvents,generateTypeSafeServiceActions,printServiceParams,verifyAllParamsDefined}from'./moleculer-generation/typedMoleculerService.js';export{ProxyService,generateProxyMethods}from'./moleculer-generation/typedProxyService.js';//# sourceMappingURL=index.js.map
+export{generateMongo}from'./helpers/mongoose-connection.js';export{BaseService2}from'./services/BaseService.js';export{BaseProxyService2}from'./services/BaseProxyService.js';export{BaseService}from'./services/base-service.js';export{BaseProxyService}from'./services/base-proxy-service.js';export{addIdVirtualFields2,commonModelSchemaOptions2}from'./store/models/common-options-v2.js';export{addIdVirtualFields,commonModeSchemaOptions}from'./store/models/common-options.js';export{BaseMongoRepository}from'./store/repositories/BaseMongoRepository.js';export{BaseRepository}from'./store/repositories/base-repository.js';export{BulkDataLoader2}from'./dataloaders/bulk-dataloader-v2.js';export{BulkDataLoader}from'./dataloaders/bulk-dataloader.js';export{BaseServiceMixin as BaseServiceMixin2}from'./mixins/BaseServiceMixin.js';export{BaseServiceMixin}from'./mixins/base-service-mixin.js';export{PAGINATION_OPTIONS}from'./interfaces/getAllArgs.js';//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@common-stack/store-mongo",
-    "version": "7.2.1-alpha.31",
+    "version": "7.2.1-alpha.32",
     "description": "Sample core for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -58,7 +58,7 @@
             ]
         }
     },
-    "gitHead": "5067fc1b656efe968ae646df72bfa3dbc9fff7f9",
+    "gitHead": "6585d3213eab8f5db2bb43f8c15768b070404f21",
     "typescript": {
         "definition": "lib/index.d.ts"
     }

package/lib/moleculer-generation/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * @file moleculer-generation/index.ts
- * @description Auto-generation utilities for Moleculer services and proxy services
- *
- * This module provides utilities for auto-generating:
- * - Server-side Moleculer service actions and events
- * - Client-side proxy service methods
- *
- * All utilities ensure consistent naming conventions (camelCase) across
- * the entire microservice architecture.
- */
-export * from './serviceGenerationUtils';
-export * from './moleculerEventHandler';
-export * from './typedMoleculerService';
-export * from './typedProxyService';

package/lib/moleculer-generation/moleculerEventHandler.d.ts

@@ -1,73 +0,0 @@
-/**
- * @file moleculer-event-handler.ts
- * @description Decorator for marking service methods as Moleculer event handlers
- *
- * This allows event handlers to be defined directly in the service class
- * and automatically registered as Moleculer events.
- */
-import 'reflect-metadata';
-/**
- * Moleculer namespace containing event handler utilities
- */
-export declare namespace Moleculer {
-    /**
-     * Metadata key for storing event handler information
-     */
-    const EVENT_HANDLER_METADATA_KEY = "moleculer:eventHandler";
-    /**
-     * Event handler metadata interface
-     */
-    interface EventHandlerMetadata {
-        eventName: string;
-        methodName: string;
-        group?: string;
-    }
-    /**
-     * Decorator for marking a service method as a Moleculer event handler
-     *
-     * @param eventName - The event name to listen for
-     * @param options - Optional event configuration
-     *
-     * @example
-     * ```typescript
-     * class OrganizationService implements IOrganizationService {
-     *     @Moleculer.EventHandler(UserBroadcasterAction.OnUserCreated)
-     *     async onUserCreated(event: IUserCreationEvent): Promise<void> {
-     *         await this.createDefaultOrganization(event.user);
-     *     }
-     *
-     *     @Moleculer.EventHandler(OrganizationServiceAction.OnOrganizationCreated, { group: 'org-setup' })
-     *     async onOrganizationCreated(event: IOrganizationCreatedEvent): Promise<void> {
-     *         // Handle organization creation
-     *     }
-     * }
-     * ```
-     */
-    function EventHandler(eventName: string, options?: {
-        group?: string;
-    }): MethodDecorator;
-    /**
-     * Get all Moleculer event handlers defined on a service class
-     *
-     * @param serviceClassOrInstance - The service class constructor or instance
-     * @returns Array of event handler metadata
-     *
-     * @example
-     * ```typescript
-     * const handlers = Moleculer.getEventHandlers(OrganizationService);
-     * // Returns: [
-     * //   { eventName: 'user.created', methodName: 'onUserCreated' },
-     * //   { eventName: 'org.created', methodName: 'onOrganizationCreated' }
-     * // ]
-     * ```
-     */
-    function getEventHandlers(serviceClassOrInstance: (new (...args: unknown[]) => unknown) | object): EventHandlerMetadata[];
-    /**
-     * Check if a method is marked as a Moleculer event handler
-     *
-     * @param serviceClassOrInstance - The service class constructor or instance
-     * @param methodName - The method name to check
-     * @returns Event handler metadata if found, undefined otherwise
-     */
-    function isEventHandler(serviceClassOrInstance: (new (...args: unknown[]) => unknown) | object, methodName: string): EventHandlerMetadata | undefined;
-}

package/lib/moleculer-generation/moleculerEventHandler.js

@@ -1,91 +0,0 @@
-import'reflect-metadata';// from package: store-mongo
-/* eslint-disable @typescript-eslint/no-namespace */
-/**
- * @file moleculer-event-handler.ts
- * @description Decorator for marking service methods as Moleculer event handlers
- *
- * This allows event handlers to be defined directly in the service class
- * and automatically registered as Moleculer events.
- */
-/**
- * Moleculer namespace containing event handler utilities
- */
-var Moleculer;
-(function (Moleculer) {
-    /**
-     * Metadata key for storing event handler information
-     */
-    Moleculer.EVENT_HANDLER_METADATA_KEY = 'moleculer:eventHandler';
-    /**
-     * Decorator for marking a service method as a Moleculer event handler
-     *
-     * @param eventName - The event name to listen for
-     * @param options - Optional event configuration
-     *
-     * @example
-     * ```typescript
-     * class OrganizationService implements IOrganizationService {
-     *     @Moleculer.EventHandler(UserBroadcasterAction.OnUserCreated)
-     *     async onUserCreated(event: IUserCreationEvent): Promise<void> {
-     *         await this.createDefaultOrganization(event.user);
-     *     }
-     *
-     *     @Moleculer.EventHandler(OrganizationServiceAction.OnOrganizationCreated, { group: 'org-setup' })
-     *     async onOrganizationCreated(event: IOrganizationCreatedEvent): Promise<void> {
-     *         // Handle organization creation
-     *     }
-     * }
-     * ```
-     */
-    function EventHandler(eventName, options) {
-        return function moleculerEventHandlerDecorator(target, propertyKey, descriptor) {
-            // Get existing event handlers for this class
-            const existingHandlers = Reflect.getMetadata(Moleculer.EVENT_HANDLER_METADATA_KEY, target.constructor) || [];
-            // Add this handler to the list
-            const metadata = {
-                eventName,
-                methodName: propertyKey.toString(),
-                group: options?.group,
-            };
-            existingHandlers.push(metadata);
-            // Store the updated list
-            Reflect.defineMetadata(Moleculer.EVENT_HANDLER_METADATA_KEY, existingHandlers, target.constructor);
-            return descriptor;
-        };
-    }
-    Moleculer.EventHandler = EventHandler;
-    /**
-     * Get all Moleculer event handlers defined on a service class
-     *
-     * @param serviceClassOrInstance - The service class constructor or instance
-     * @returns Array of event handler metadata
-     *
-     * @example
-     * ```typescript
-     * const handlers = Moleculer.getEventHandlers(OrganizationService);
-     * // Returns: [
-     * //   { eventName: 'user.created', methodName: 'onUserCreated' },
-     * //   { eventName: 'org.created', methodName: 'onOrganizationCreated' }
-     * // ]
-     * ```
-     */
-    function getEventHandlers(serviceClassOrInstance) {
-        const target = typeof serviceClassOrInstance === 'function'
-            ? serviceClassOrInstance
-            : serviceClassOrInstance.constructor;
-        return Reflect.getMetadata(Moleculer.EVENT_HANDLER_METADATA_KEY, target) || [];
-    }
-    Moleculer.getEventHandlers = getEventHandlers;
-    /**
-     * Check if a method is marked as a Moleculer event handler
-     *
-     * @param serviceClassOrInstance - The service class constructor or instance
-     * @param methodName - The method name to check
-     * @returns Event handler metadata if found, undefined otherwise
-     */
-    function isEventHandler(serviceClassOrInstance, methodName) {
-        const handlers = getEventHandlers(serviceClassOrInstance);
-        return handlers.find(h => h.methodName === methodName);
-    }
-    Moleculer.isEventHandler = isEventHandler;
-})(Moleculer || (Moleculer = {}));export{Moleculer};//# sourceMappingURL=moleculerEventHandler.js.map

package/lib/moleculer-generation/moleculerEventHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"moleculerEventHandler.js","sources":["../../src/moleculer-generation/moleculerEventHandler.ts"],"sourcesContent":["// from package: store-mongo\n/* eslint-disable @typescript-eslint/no-namespace */\n/**\n * @file moleculer-event-handler.ts\n * @description Decorator for marking service methods as Moleculer event handlers\n * \n * This allows event handlers to be defined directly in the service class\n * and automatically registered as Moleculer events.\n */\n\nimport 'reflect-metadata';\n\n/**\n * Moleculer namespace containing event handler utilities\n */\nexport namespace Moleculer {\n    /**\n     * Metadata key for storing event handler information\n     */\n    export const EVENT_HANDLER_METADATA_KEY = 'moleculer:eventHandler';\n\n    /**\n     * Event handler metadata interface\n     */\n    export interface EventHandlerMetadata {\n        eventName: string;\n        methodName: string;\n        group?: string;\n    }\n\n    /**\n     * Decorator for marking a service method as a Moleculer event handler\n     * \n     * @param eventName - The event name to listen for\n     * @param options - Optional event configuration\n     * \n     * @example\n     * ```typescript\n     * class OrganizationService implements IOrganizationService {\n     *     @Moleculer.EventHandler(UserBroadcasterAction.OnUserCreated)\n     *     async onUserCreated(event: IUserCreationEvent): Promise<void> {\n     *         await this.createDefaultOrganization(event.user);\n     *     }\n     * \n     *     @Moleculer.EventHandler(OrganizationServiceAction.OnOrganizationCreated, { group: 'org-setup' })\n     *     async onOrganizationCreated(event: IOrganizationCreatedEvent): Promise<void> {\n     *         // Handle organization creation\n     *     }\n     * }\n     * ```\n     */\n    export function EventHandler(\n        eventName: string,\n        options?: { group?: string }\n    ): MethodDecorator {\n        return function moleculerEventHandlerDecorator(\n            target: object,\n            propertyKey: string | symbol,\n            descriptor: PropertyDescriptor\n        ): PropertyDescriptor {\n            // Get existing event handlers for this class\n            const existingHandlers: EventHandlerMetadata[] = \n                Reflect.getMetadata(EVENT_HANDLER_METADATA_KEY, target.constructor) || [];\n            \n            // Add this handler to the list\n            const metadata: EventHandlerMetadata = {\n                eventName,\n                methodName: propertyKey.toString(),\n                group: options?.group,\n            };\n            \n            existingHandlers.push(metadata);\n            \n            // Store the updated list\n            Reflect.defineMetadata(EVENT_HANDLER_METADATA_KEY, existingHandlers, target.constructor);\n            \n            return descriptor;\n        };\n    }\n\n    /**\n     * Get all Moleculer event handlers defined on a service class\n     * \n     * @param serviceClassOrInstance - The service class constructor or instance\n     * @returns Array of event handler metadata\n     * \n     * @example\n     * ```typescript\n     * const handlers = Moleculer.getEventHandlers(OrganizationService);\n     * // Returns: [\n     * //   { eventName: 'user.created', methodName: 'onUserCreated' },\n     * //   { eventName: 'org.created', methodName: 'onOrganizationCreated' }\n     * // ]\n     * ```\n     */\n    export function getEventHandlers(\n        serviceClassOrInstance: (new (...args: unknown[]) => unknown) | object\n    ): EventHandlerMetadata[] {\n        const target = typeof serviceClassOrInstance === 'function' \n            ? serviceClassOrInstance \n            : (serviceClassOrInstance as { constructor: new (...args: unknown[]) => unknown }).constructor;\n        return Reflect.getMetadata(EVENT_HANDLER_METADATA_KEY, target) || [];\n    }\n\n    /**\n     * Check if a method is marked as a Moleculer event handler\n     * \n     * @param serviceClassOrInstance - The service class constructor or instance\n     * @param methodName - The method name to check\n     * @returns Event handler metadata if found, undefined otherwise\n     */\n    export function isEventHandler(\n        serviceClassOrInstance: (new (...args: unknown[]) => unknown) | object,\n        methodName: string\n    ): EventHandlerMetadata | undefined {\n        const handlers = getEventHandlers(serviceClassOrInstance);\n        return handlers.find(h => h.methodName === methodName);\n    }\n}\n"],"names":[],"mappings":"yBAAA;AACA;AACA;;;;;;AAMG;AAIH;;AAEG;AACG,IAAW,UAuGhB;AAvGD,CAAA,UAAiB,SAAS,EAAA;AACtB;;AAEG;IACU,SAA0B,CAAA,0BAAA,GAAG,wBAAwB,CAAC;AAWnE;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,SAAgB,YAAY,CACxB,SAAiB,EACjB,OAA4B,EAAA;AAE5B,QAAA,OAAO,SAAS,8BAA8B,CAC1C,MAAc,EACd,WAA4B,EAC5B,UAA8B,EAAA;;AAG9B,YAAA,MAAM,gBAAgB,GAClB,OAAO,CAAC,WAAW,CAAC,SAAA,CAAA,0BAA0B,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;;AAG9E,YAAA,MAAM,QAAQ,GAAyB;gBACnC,SAAS;AACT,gBAAA,UAAU,EAAE,WAAW,CAAC,QAAQ,EAAE;gBAClC,KAAK,EAAE,OAAO,EAAE,KAAK;aACxB,CAAC;AAEF,YAAA,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;;AAGhC,YAAA,OAAO,CAAC,cAAc,CAAC,SAAA,CAAA,0BAA0B,EAAE,gBAAgB,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;AAEzF,YAAA,OAAO,UAAU,CAAC;AACtB,SAAC,CAAC;KACL;AA3Be,IAAA,SAAA,CAAA,YAAY,eA2B3B,CAAA;AAED;;;;;;;;;;;;;;AAcG;IACH,SAAgB,gBAAgB,CAC5B,sBAAsE,EAAA;AAEtE,QAAA,MAAM,MAAM,GAAG,OAAO,sBAAsB,KAAK,UAAU;AACvD,cAAE,sBAAsB;AACxB,cAAG,sBAA+E,CAAC,WAAW,CAAC;QACnG,OAAO,OAAO,CAAC,WAAW,CAAC,SAAA,CAAA,0BAA0B,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;KACxE;AAPe,IAAA,SAAA,CAAA,gBAAgB,mBAO/B,CAAA;AAED;;;;;;AAMG;AACH,IAAA,SAAgB,cAAc,CAC1B,sBAAsE,EACtE,UAAkB,EAAA;AAElB,QAAA,MAAM,QAAQ,GAAG,gBAAgB,CAAC,sBAAsB,CAAC,CAAC;AAC1D,QAAA,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,KAAK,UAAU,CAAC,CAAC;KAC1D;AANe,IAAA,SAAA,CAAA,cAAc,iBAM7B,CAAA;AACL,CAAC,EAvGgB,SAAS,KAAT,SAAS,GAuGzB,EAAA,CAAA,CAAA"}

package/lib/moleculer-generation/serviceGenerationUtils.d.ts

@@ -1,99 +0,0 @@
-/**
- * @file serviceGenerationUtils.ts
- * @description Shared utilities for auto-generating Moleculer services and proxy services.
- *
- * This module provides common functionality used by both:
- * - typedMoleculerService.ts (server-side Moleculer service generation)
- * - typedProxyService.ts (client-side proxy service generation)
- *
- * Centralizing these utilities ensures consistency in action naming conventions
- * and method discovery across the entire microservice architecture.
- */
-/**
- * Excluded base service methods that should not be auto-generated as actions
- */
-export type ExcludedServiceMethods = 'dispose' | 'get' | 'getAll' | 'bulkDelete' | 'delete' | 'count' | 'getByName' | 'getByIds' | 'getAllWithCount' | 'create' | 'update' | 'bulkCreate' | 'insert' | 'broker' | 'logger' | 'topic' | 'callAction';
-/**
- * Check if a method should be excluded from auto-generation
- *
- * @param methodName - The method name to check
- * @returns true if the method should be excluded
- */
-export declare function isExcludedMethod(methodName: string): boolean;
-/**
- * Get all method names from a service instance, traversing the prototype chain.
- *
- * This function walks up the prototype chain to include inherited methods from
- * parent classes, which is essential for services that extend base classes.
- *
- * @param obj - The service instance to analyze
- * @returns Array of method names (includes inherited methods)
- *
- * @example
- * ```typescript
- * class BaseService {
- *   get() {}
- *   getAll() {}
- * }
- *
- * class UserService extends BaseService {
- *   createUser() {}
- * }
- *
- * const service = new UserService();
- * const methods = getAllMethodNames(service);
- * // Returns: ['createUser', 'get', 'getAll', 'constructor']
- * ```
- */
-export declare function getAllMethodNames(obj: unknown): string[];
-/**
- * Convert method name to action name using camelCase convention.
- *
- * **IMPORTANT**: We use camelCase (method name as-is) for action names to match
- * the Moleculer service action registration pattern. Both server-side Moleculer
- * services and client-side proxy services must use the same convention.
- *
- * @param methodName - The method name (e.g., 'getTags', 'createTag')
- * @returns The action name in camelCase (same as method name)
- *
- * @example
- * ```typescript
- * getActionName('getTags')          // Returns: 'getTags'
- * getActionName('createTag')        // Returns: 'createTag'
- * getActionName('removeTag')        // Returns: 'removeTag'
- * ```
- *
- * @deprecated PascalCase conversion (e.g., GetTags, CreateTag) is no longer used.
- * Previous behavior caused mismatches between proxy and Moleculer services.
- */
-export declare function getActionName(methodName: string): string;
-/**
- * Convert string to PascalCase (first letter uppercase).
- *
- * **DEPRECATED**: This function is kept for backward compatibility with command enums
- * but should NOT be used for action name generation. Use getActionName() instead.
- *
- * @param str - The string to convert
- * @returns String with first letter uppercase
- *
- * @example
- * ```typescript
- * toPascalCase('getTags')    // Returns: 'GetTags'
- * toPascalCase('createTag')  // Returns: 'CreateTag'
- * ```
- */
-export declare function toPascalCase(str: string): string;
-/**
- * Build the full Moleculer action path from topic and action name.
- *
- * @param topic - The Moleculer service topic (e.g., 'Tag', 'User')
- * @param actionName - The action name (e.g., 'getTags', 'createTag')
- * @returns Full action path (e.g., 'Tag.getTags', 'User.createUser')
- *
- * @example
- * ```typescript
- * buildActionPath('Tag', 'getTags')       // Returns: 'Tag.getTags'
- * buildActionPath('User', 'createUser')   // Returns: 'User.createUser'
- * ```
- */
-export declare function buildActionPath(topic: string, actionName: string): string;

package/lib/moleculer-generation/serviceGenerationUtils.js

@@ -1,146 +0,0 @@
-/**
- * @file serviceGenerationUtils.ts
- * @description Shared utilities for auto-generating Moleculer services and proxy services.
- *
- * This module provides common functionality used by both:
- * - typedMoleculerService.ts (server-side Moleculer service generation)
- * - typedProxyService.ts (client-side proxy service generation)
- *
- * Centralizing these utilities ensures consistency in action naming conventions
- * and method discovery across the entire microservice architecture.
- */
-/**
- * Check if a method should be excluded from auto-generation
- *
- * @param methodName - The method name to check
- * @returns true if the method should be excluded
- */
-function isExcludedMethod(methodName) {
-    const excludedMethods = [
-        'dispose',
-        'get',
-        'getAll',
-        'bulkDelete',
-        'delete',
-        'count',
-        'getByName',
-        'getByIds',
-        'getAllWithCount',
-        'create',
-        'update',
-        'bulkCreate',
-        'insert',
-        'broker',
-        'logger',
-        'topic',
-        'callAction',
-    ];
-    return excludedMethods.includes(methodName);
-}
-/**
- * Get all method names from a service instance, traversing the prototype chain.
- *
- * This function walks up the prototype chain to include inherited methods from
- * parent classes, which is essential for services that extend base classes.
- *
- * @param obj - The service instance to analyze
- * @returns Array of method names (includes inherited methods)
- *
- * @example
- * ```typescript
- * class BaseService {
- *   get() {}
- *   getAll() {}
- * }
- *
- * class UserService extends BaseService {
- *   createUser() {}
- * }
- *
- * const service = new UserService();
- * const methods = getAllMethodNames(service);
- * // Returns: ['createUser', 'get', 'getAll', 'constructor']
- * ```
- */
-function getAllMethodNames(obj) {
-    const methods = new Set();
-    let current = obj;
-    // Traverse prototype chain
-    while (current && current !== Object.prototype) {
-        const props = Object.getOwnPropertyNames(current);
-        for (const prop of props) {
-            if (prop !== 'constructor') {
-                try {
-                    const descriptor = Object.getOwnPropertyDescriptor(current, prop);
-                    if (descriptor && typeof descriptor.value === 'function') {
-                        methods.add(prop);
-                    }
-                }
-                catch (error) {
-                    // Skip properties that can't be accessed
-                }
-            }
-        }
-        current = Object.getPrototypeOf(current);
-    }
-    return Array.from(methods);
-}
-/**
- * Convert method name to action name using camelCase convention.
- *
- * **IMPORTANT**: We use camelCase (method name as-is) for action names to match
- * the Moleculer service action registration pattern. Both server-side Moleculer
- * services and client-side proxy services must use the same convention.
- *
- * @param methodName - The method name (e.g., 'getTags', 'createTag')
- * @returns The action name in camelCase (same as method name)
- *
- * @example
- * ```typescript
- * getActionName('getTags')          // Returns: 'getTags'
- * getActionName('createTag')        // Returns: 'createTag'
- * getActionName('removeTag')        // Returns: 'removeTag'
- * ```
- *
- * @deprecated PascalCase conversion (e.g., GetTags, CreateTag) is no longer used.
- * Previous behavior caused mismatches between proxy and Moleculer services.
- */
-function getActionName(methodName) {
-    // Use method name as-is (camelCase) for action names
-    // This ensures proxy services and Moleculer services use the same action keys
-    return methodName;
-}
-/**
- * Convert string to PascalCase (first letter uppercase).
- *
- * **DEPRECATED**: This function is kept for backward compatibility with command enums
- * but should NOT be used for action name generation. Use getActionName() instead.
- *
- * @param str - The string to convert
- * @returns String with first letter uppercase
- *
- * @example
- * ```typescript
- * toPascalCase('getTags')    // Returns: 'GetTags'
- * toPascalCase('createTag')  // Returns: 'CreateTag'
- * ```
- */
-function toPascalCase(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
- * Build the full Moleculer action path from topic and action name.
- *
- * @param topic - The Moleculer service topic (e.g., 'Tag', 'User')
- * @param actionName - The action name (e.g., 'getTags', 'createTag')
- * @returns Full action path (e.g., 'Tag.getTags', 'User.createUser')
- *
- * @example
- * ```typescript
- * buildActionPath('Tag', 'getTags')       // Returns: 'Tag.getTags'
- * buildActionPath('User', 'createUser')   // Returns: 'User.createUser'
- * ```
- */
-function buildActionPath(topic, actionName) {
-    return `${topic}.${actionName}`;
-}export{buildActionPath,getActionName,getAllMethodNames,isExcludedMethod,toPascalCase};//# sourceMappingURL=serviceGenerationUtils.js.map

package/lib/moleculer-generation/serviceGenerationUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serviceGenerationUtils.js","sources":["../../src/moleculer-generation/serviceGenerationUtils.ts"],"sourcesContent":["/**\n * @file serviceGenerationUtils.ts\n * @description Shared utilities for auto-generating Moleculer services and proxy services.\n * \n * This module provides common functionality used by both:\n * - typedMoleculerService.ts (server-side Moleculer service generation)\n * - typedProxyService.ts (client-side proxy service generation)\n * \n * Centralizing these utilities ensures consistency in action naming conventions\n * and method discovery across the entire microservice architecture.\n */\n\n/**\n * Excluded base service methods that should not be auto-generated as actions\n */\nexport type ExcludedServiceMethods =\n    | 'dispose'\n    | 'get'\n    | 'getAll'\n    | 'bulkDelete'\n    | 'delete'\n    | 'count'\n    | 'getByName'\n    | 'getByIds'\n    | 'getAllWithCount'\n    | 'create'\n    | 'update'\n    | 'bulkCreate'\n    | 'insert'\n    | 'broker'\n    | 'logger'\n    | 'topic'\n    | 'callAction';\n\n/**\n * Check if a method should be excluded from auto-generation\n * \n * @param methodName - The method name to check\n * @returns true if the method should be excluded\n */\nexport function isExcludedMethod(methodName: string): boolean {\n    const excludedMethods: ExcludedServiceMethods[] = [\n        'dispose',\n        'get',\n        'getAll',\n        'bulkDelete',\n        'delete',\n        'count',\n        'getByName',\n        'getByIds',\n        'getAllWithCount',\n        'create',\n        'update',\n        'bulkCreate',\n        'insert',\n        'broker',\n        'logger',\n        'topic',\n        'callAction',\n    ];\n\n    return excludedMethods.includes(methodName as ExcludedServiceMethods);\n}\n\n/**\n * Get all method names from a service instance, traversing the prototype chain.\n * \n * This function walks up the prototype chain to include inherited methods from\n * parent classes, which is essential for services that extend base classes.\n * \n * @param obj - The service instance to analyze\n * @returns Array of method names (includes inherited methods)\n * \n * @example\n * ```typescript\n * class BaseService {\n *   get() {}\n *   getAll() {}\n * }\n * \n * class UserService extends BaseService {\n *   createUser() {}\n * }\n * \n * const service = new UserService();\n * const methods = getAllMethodNames(service);\n * // Returns: ['createUser', 'get', 'getAll', 'constructor']\n * ```\n */\nexport function getAllMethodNames(obj: unknown): string[] {\n    const methods = new Set<string>();\n    let current = obj;\n\n    // Traverse prototype chain\n    while (current && current !== Object.prototype) {\n        const props = Object.getOwnPropertyNames(current);\n        for (const prop of props) {\n            if (prop !== 'constructor') {\n                try {\n                    const descriptor = Object.getOwnPropertyDescriptor(current, prop);\n                    if (descriptor && typeof descriptor.value === 'function') {\n                        methods.add(prop);\n                    }\n                } catch (error) {\n                    // Skip properties that can't be accessed\n                }\n            }\n        }\n        current = Object.getPrototypeOf(current);\n    }\n\n    return Array.from(methods);\n}\n\n/**\n * Convert method name to action name using camelCase convention.\n * \n * **IMPORTANT**: We use camelCase (method name as-is) for action names to match\n * the Moleculer service action registration pattern. Both server-side Moleculer\n * services and client-side proxy services must use the same convention.\n * \n * @param methodName - The method name (e.g., 'getTags', 'createTag')\n * @returns The action name in camelCase (same as method name)\n * \n * @example\n * ```typescript\n * getActionName('getTags')          // Returns: 'getTags'\n * getActionName('createTag')        // Returns: 'createTag'\n * getActionName('removeTag')        // Returns: 'removeTag'\n * ```\n * \n * @deprecated PascalCase conversion (e.g., GetTags, CreateTag) is no longer used.\n * Previous behavior caused mismatches between proxy and Moleculer services.\n */\nexport function getActionName(methodName: string): string {\n    // Use method name as-is (camelCase) for action names\n    // This ensures proxy services and Moleculer services use the same action keys\n    return methodName;\n}\n\n/**\n * Convert string to PascalCase (first letter uppercase).\n * \n * **DEPRECATED**: This function is kept for backward compatibility with command enums\n * but should NOT be used for action name generation. Use getActionName() instead.\n * \n * @param str - The string to convert\n * @returns String with first letter uppercase\n * \n * @example\n * ```typescript\n * toPascalCase('getTags')    // Returns: 'GetTags'\n * toPascalCase('createTag')  // Returns: 'CreateTag'\n * ```\n */\nexport function toPascalCase(str: string): string {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\n/**\n * Build the full Moleculer action path from topic and action name.\n * \n * @param topic - The Moleculer service topic (e.g., 'Tag', 'User')\n * @param actionName - The action name (e.g., 'getTags', 'createTag')\n * @returns Full action path (e.g., 'Tag.getTags', 'User.createUser')\n * \n * @example\n * ```typescript\n * buildActionPath('Tag', 'getTags')       // Returns: 'Tag.getTags'\n * buildActionPath('User', 'createUser')   // Returns: 'User.createUser'\n * ```\n */\nexport function buildActionPath(topic: string, actionName: string): string {\n    return `${topic}.${actionName}`;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;AAUG;AAwBH;;;;;AAKG;AACG,SAAU,gBAAgB,CAAC,UAAkB,EAAA;AAC/C,IAAA,MAAM,eAAe,GAA6B;QAC9C,SAAS;QACT,KAAK;QACL,QAAQ;QACR,YAAY;QACZ,QAAQ;QACR,OAAO;QACP,WAAW;QACX,UAAU;QACV,iBAAiB;QACjB,QAAQ;QACR,QAAQ;QACR,YAAY;QACZ,QAAQ;QACR,QAAQ;QACR,QAAQ;QACR,OAAO;QACP,YAAY;KACf,CAAC;AAEF,IAAA,OAAO,eAAe,CAAC,QAAQ,CAAC,UAAoC,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACG,SAAU,iBAAiB,CAAC,GAAY,EAAA;AAC1C,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAClC,IAAI,OAAO,GAAG,GAAG,CAAC;;IAGlB,OAAO,OAAO,IAAI,OAAO,KAAK,MAAM,CAAC,SAAS,EAAE;QAC5C,MAAM,KAAK,GAAG,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;AAClD,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;AACtB,YAAA,IAAI,IAAI,KAAK,aAAa,EAAE;AACxB,gBAAA,IAAI;oBACA,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;oBAClE,IAAI,UAAU,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU,EAAE;AACtD,wBAAA,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;qBACrB;iBACJ;gBAAC,OAAO,KAAK,EAAE;;iBAEf;aACJ;SACJ;AACD,QAAA,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;KAC5C;AAED,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;AAmBG;AACG,SAAU,aAAa,CAAC,UAAkB,EAAA;;;AAG5C,IAAA,OAAO,UAAU,CAAC;AACtB,CAAC;AAED;;;;;;;;;;;;;;AAcG;AACG,SAAU,YAAY,CAAC,GAAW,EAAA;AACpC,IAAA,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;AAYG;AACa,SAAA,eAAe,CAAC,KAAa,EAAE,UAAkB,EAAA;AAC7D,IAAA,OAAO,CAAG,EAAA,KAAK,CAAI,CAAA,EAAA,UAAU,EAAE,CAAC;AACpC"}