@common-stack/server-core 8.0.2-alpha.0 → 8.2.1-alpha.0

package/lib/interfaces/connector.d.ts

@@ -4,14 +4,10 @@ export interface IResolverOptions {
     logger?: CdmLogger.ILogger;
     [key: string]: any;
 }
-export declare enum ConfigurationScope {
-    WINDOW = 1,
-    RESOURCE = 2
-}
 export interface IWebsocketConfig {
     [key: string]: any;
 }
-export interface IPreferencesData<T = ConfigurationScope> {
+export interface IPreferencesData<T = any> {
     type?: string | string[];
     default?: string | boolean | number | any;
     description?: string;
@@ -25,13 +21,13 @@ export interface IPreferencesData<T = ConfigurationScope> {
     };
     [key: string]: any;
 }
-export interface IPreferences<T = ConfigurationScope> {
+export interface IPreferences<T = any> {
     [key: string]: IPreferencesData<T>;
 }
 /**
  * Formatted preferences data
  */
-export interface IPreferncesTransformed<T = ConfigurationScope> {
+export interface IPreferncesTransformed<T = any> {
     type: string;
     data: IPreferencesData<T>;
 }

package/lib/interfaces/roles.d.ts

@@ -1,5 +1,5 @@
-import { ConfigurationScope, IPreferencesData } from "./connector";
-export interface IRoles<T = ConfigurationScope> {
+import { IPreferencesData } from './connector';
+export interface IRoles<T = any> {
     [key: string]: IPreferencesData<T>;
 }
 export interface IRoleUpdate<T> {

package/lib/moleculer-generation/__tests__/integration-proxy-moleculer.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file integration-proxy-moleculer.test.ts
+ * @description Integration tests for full proxy → Moleculer → service cycle
+ * Tests parameter wrapping/unwrapping between proxy and Moleculer handler
+ */
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * @file moleculerEventHandler.test.ts
+ * @description Test suite for Moleculer event handler decorator
+ */
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * @file serviceGenerationUtils.test.ts
+ * @description Test suite for service generation utilities
+ */
+export {};

package/lib/moleculer-generation/__tests__/typedMoleculerService.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file typedMoleculerService.test.ts
+ * @description Test suite for Moleculer service generation
+ */
+export {};

package/lib/moleculer-generation/__tests__/typedProxyService.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file typedProxyService.test.ts
+ * @description Test suite for proxy service generation
+ */
+export {};

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

@@ -0,0 +1,16 @@
+/**
+ * @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';
+export * from './zodToMoleculer';

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

@@ -0,0 +1,73 @@
+/**
+ * @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/serviceGenerationUtils.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @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
+ * @param context - Generation context: 'moleculer' for server-side, 'proxy' for client-side
+ * @returns true if the method should be excluded
+ */
+export declare function isExcludedMethod(methodName: string, context?: 'moleculer' | 'proxy'): 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;