atomic-queues 1.4.1 → 1.6.0

package/dist/services/processor-discovery/processor-discovery.service.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -16,30 +49,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessorDiscoveryService = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
-const decorators_1 = require("../../decorators");
-const worker_manager_1 = require("../worker-manager");
-const queue_manager_1 = require("../queue-manager");
-const cron_manager_1 = require("../cron-manager");
 const command_discovery_1 = require("../command-discovery");
-const service_queue_1 = require("../service-queue");
 const queue_bus_1 = require("../queue-bus");
-const queue_events_manager_1 = require("../queue-events-manager");
 const constants_1 = require("../constants");
+const processor_registry_1 = require("./processor-registry");
+const decorator_discovery_service_1 = require("./decorator-discovery.service");
+const worker_factory_service_1 = require("./worker-factory.service");
+const scaling_registration_service_1 = require("./scaling-registration.service");
 /**
  * ProcessorDiscoveryService
  *
- * Automatically discovers and registers classes decorated with:
- * - @WorkerProcessor - For job processing
- * - @EntityScaler - For entity scaling logic
+ * Orchestrator that coordinates discovery, registration, worker creation,
+ * and scaling setup. Delegates to focused services:
  *
- * This service bridges the decorator-based API with the core services:
- * - WorkerManagerService - For worker lifecycle
- * - QueueManagerService - For queue management
- * - CronManagerService - For automatic scaling
+ * - ProcessorRegistry: state management for processors/scalers/workers
+ * - DecoratorDiscoveryService: NestJS provider scanning and registration
+ * - WorkerFactoryService: worker creation and job processing
+ * - ScalingRegistrationService: scaling/spawn registration logic
  *
  * @example
  * ```typescript
- * // Classes are auto-discovered from module providers
  * @WorkerProcessor({ entityType: 'table' })
  * @Injectable()
  * export class TableProcessor {
@@ -56,218 +85,82 @@ const constants_1 = require("../constants");
  * ```
  */
 let ProcessorDiscoveryService = ProcessorDiscoveryService_1 = class ProcessorDiscoveryService {
-    constructor(discoveryService, metadataScanner, moduleRef, workerManager, queueManager, cronManager, commandDiscovery, serviceQueueManager, queueEventsManager, config) {
+    constructor(discoveryService, moduleRef, registry, decoratorDiscovery, workerFactory, scalingRegistration, commandDiscovery, config) {
         this.discoveryService = discoveryService;
-        this.metadataScanner = metadataScanner;
         this.moduleRef = moduleRef;
-        this.workerManager = workerManager;
-        this.queueManager = queueManager;
-        this.cronManager = cronManager;
+        this.registry = registry;
+        this.decoratorDiscovery = decoratorDiscovery;
+        this.workerFactory = workerFactory;
+        this.scalingRegistration = scalingRegistration;
         this.commandDiscovery = commandDiscovery;
-        this.serviceQueueManager = serviceQueueManager;
-        this.queueEventsManager = queueEventsManager;
         this.config = config;
         this.logger = new common_1.Logger(ProcessorDiscoveryService_1.name);
-        this.processors = new Map();
-        this.scalers = new Map();
-        this.activeWorkers = new Map(); // entityType -> Set of entityIds with workers
-        this.commandBus = null;
-        this.queryBus = null;
-    }
-    /**
-     * Set the CommandBus for executing commands from QueueBus registry
-     */
-    setCommandBus(commandBus) {
-        this.commandBus = commandBus;
-        // Also set on CommandDiscoveryService if available
-        if (this.commandDiscovery) {
-            this.commandDiscovery.setCommandBus(commandBus);
-        }
-    }
-    /**
-     * Set the QueryBus for executing queries from QueueBus registry
-     */
-    setQueryBus(queryBus) {
-        this.queryBus = queryBus;
-        // Also set on CommandDiscoveryService if available
-        if (this.commandDiscovery) {
-            this.commandDiscovery.setQueryBus(queryBus);
-        }
     }
     async onModuleInit() {
         if (!this.discoveryService) {
             this.logger.warn('DiscoveryService not available. Manual registration required.');
             return;
         }
-        await this.discoverProcessors();
-        await this.discoverScalers();
-        await this.registerEntitiesFromConfig();
-        await this.registerScalersWithCronManager();
-        await this.registerScalerlessProcessors();
-        await this.registerSpawnWorkerHandler();
-        await this.setupQueueEventsListening();
-        // Auto-register commands from CQRS handlers (default: true)
+        // Phase 1: Discovery and registration
+        this.decoratorDiscovery.discoverProcessors(this.registry);
+        this.decoratorDiscovery.discoverScalers(this.registry);
+        this.decoratorDiscovery.registerEntitiesFromConfig(this.registry);
+        // Phase 2: Wire up worker factory
+        this.workerFactory.setRegistry(this.registry);
+        // Phase 3: Register all scaling handlers
+        await this.scalingRegistration.registerAll(this.registry, this.workerFactory);
+        // Phase 4: CQRS auto-wiring
         if (this.config.autoRegisterCommands !== false) {
             this.autoRegisterCommandsFromCqrs();
         }
+        this.autoWireCqrsBuses();
     }
+    // ==========================================================================
+    // CQRS WIRING
+    // ==========================================================================
     /**
-     * Register entity types from module config `entities` option.
-     * This creates virtual processors for entities that don't have explicit @WorkerProcessor classes.
-     *
-     * Benefits:
-     * - No boilerplate @WorkerProcessor class needed
-     * - Just configure in module and decorate commands with @QueueEntity
-     * - Workers auto-spawn on job arrival and terminate when idle
+     * Set the CommandBus for executing commands from QueueBus registry
      */
-    async registerEntitiesFromConfig() {
-        const entities = this.config.entities;
-        if (!entities) {
-            return;
-        }
-        const keyPrefix = this.config.keyPrefix || 'aq';
-        for (const [entityType, entityConfig] of Object.entries(entities)) {
-            // Skip if a processor is already registered for this entity type
-            if (this.processors.has(entityType)) {
-                this.logger.debug(`Entity '${entityType}' already has a @WorkerProcessor, skipping config-based registration`);
-                continue;
-            }
-            this.logger.log(`Registering entity '${entityType}' from module config (no @WorkerProcessor needed)`);
-            // Build queue and worker name functions
-            const queueNameFn = entityConfig.queueName
-                ?? ((entityId) => `${keyPrefix}:${entityType}:${entityId}:queue`);
-            const workerNameFn = entityConfig.workerName
-                ?? ((entityId) => `${keyPrefix}:${entityType}:${entityId}:worker`);
-            // Create a virtual processor entry
-            const processor = {
-                entityType,
-                processorInstance: null, // No instance - we use generic processing
-                options: {
-                    entityType,
-                    defaultEntityId: entityConfig.defaultEntityId,
-                    queueName: queueNameFn,
-                    workerName: workerNameFn,
-                    workerConfig: entityConfig.workerConfig,
-                    maxWorkersPerEntity: entityConfig.maxWorkersPerEntity ?? 1,
-                    idleTimeoutSeconds: entityConfig.idleTimeoutSeconds ?? 15,
-                    autoSpawn: entityConfig.autoSpawn !== false, // Default true
-                },
-                jobHandlers: new Map(), // No explicit handlers - use generic routing
-                wildcardHandler: undefined,
-                queueNameFn,
-                workerNameFn,
-            };
-            this.processors.set(entityType, processor);
-            this.activeWorkers.set(entityType, new Set());
-            this.logger.debug(`Registered config-based processor for '${entityType}' ` +
-                `(maxWorkers: ${processor.options.maxWorkersPerEntity}, idle: ${processor.options.idleTimeoutSeconds}s)`);
+    setCommandBus(commandBus) {
+        this.workerFactory.setCommandBus(commandBus);
+        if (this.commandDiscovery) {
+            this.commandDiscovery.setCommandBus(commandBus);
         }
     }
     /**
-     * Register processors that don't have an EntityScaler (scalerless mode).
-     * These processors will auto-spawn workers when jobs arrive and
-     * auto-terminate when idle.
+     * Set the QueryBus for executing queries from QueueBus registry
      */
-    async registerScalerlessProcessors() {
-        if (!this.cronManager) {
-            this.logger.debug('CronManager not available, skipping scalerless processor registration');
-            return;
-        }
-        for (const [entityType, processor] of this.processors) {
-            // Skip if a scaler is already registered for this entity type
-            if (this.scalers.has(entityType)) {
-                continue;
-            }
-            // Check if autoSpawn is explicitly disabled
-            if (processor.options.autoSpawn === false) {
-                this.logger.debug(`Auto-spawn disabled for ${entityType}, skipping scalerless registration`);
-                continue;
-            }
-            this.logger.log(`Registering scalerless config for '${entityType}' (autoSpawn mode)`);
-            const scalingConfig = {
-                entityType,
-                maxWorkersPerEntity: processor.options.maxWorkersPerEntity ?? 1,
-                idleTimeoutSeconds: processor.options.idleTimeoutSeconds ?? 15,
-                // In scalerless mode, we don't rely on getActiveEntityIds
-                // Workers are spawned reactively when jobs arrive
-                getActiveEntityIds: async () => {
-                    // Return empty - workers are spawned by QueueEventsManager when jobs arrive
-                    return [];
-                },
-                getDesiredWorkerCount: async (_entityId) => {
-                    return 1; // Default to 1 worker per entity
-                },
-                onSpawnWorker: async (entityId) => {
-                    await this.createWorkerForEntity(entityType, entityId);
-                },
-                onTerminateWorker: async (entityId, _workerId) => {
-                    const workerName = processor.workerNameFn(entityId);
-                    await this.workerManager.signalWorkerClose(workerName);
-                },
-            };
-            this.cronManager.registerEntityType(scalingConfig);
-            this.logger.log(`Registered scalerless config for '${entityType}' (idleTimeout: ${scalingConfig.idleTimeoutSeconds}s)`);
+    setQueryBus(queryBus) {
+        this.workerFactory.setQueryBus(queryBus);
+        if (this.commandDiscovery) {
+            this.commandDiscovery.setQueryBus(queryBus);
         }
     }
     /**
-     * Setup QueueEvents listening for job arrivals.
-     * This enables automatic worker spawning when jobs are added.
+     * Attempt to resolve CommandBus and QueryBus from the DI container.
      */
-    async setupQueueEventsListening() {
-        if (!this.queueEventsManager) {
-            this.logger.debug('QueueEventsManager not available, skipping event listening setup');
+    autoWireCqrsBuses() {
+        if (!this.discoveryService)
             return;
+        const providers = this.discoveryService.getProviders();
+        const commandBusWrapper = providers.find((w) => w.metatype?.name === 'CommandBus' && w.instance);
+        if (commandBusWrapper?.instance) {
+            this.setCommandBus(commandBusWrapper.instance);
+            this.logger.log('Auto-wired CommandBus from @nestjs/cqrs');
+        }
+        else {
+            this.logger.debug('CommandBus not found in DI container. ' +
+                'Import CqrsModule in your app or call setCommandBus() manually.');
         }
-        // Wire up QueueManager with QueueEventsManager for auto-listening
-        this.queueManager.setQueueEventsManager(this.queueEventsManager);
-        // Set up the callback for job arrivals
-        this.queueEventsManager.setOnJobArrivedCallback(async (entityType, entityId, _queueName) => {
-            const processor = this.processors.get(entityType);
-            const scaler = this.scalers.get(entityType);
-            // If there's a scaler with @OnSpawnWorker, use it
-            if (scaler?.methods.onSpawnWorker) {
-                await scaler.scalerInstance[scaler.methods.onSpawnWorker](entityId);
-            }
-            // Also auto-create worker if processor is registered
-            if (processor) {
-                await this.createWorkerForEntity(entityType, entityId);
-            }
-        });
-        // Register entity patterns for all processors
-        for (const [entityType, processor] of this.processors) {
-            this.queueEventsManager.registerEntityPattern(entityType, processor.queueNameFn, processor.workerNameFn);
+        const queryBusWrapper = providers.find((w) => w.metatype?.name === 'QueryBus' && w.instance);
+        if (queryBusWrapper?.instance) {
+            this.setQueryBus(queryBusWrapper.instance);
+            this.logger.log('Auto-wired QueryBus from @nestjs/cqrs');
         }
-        this.logger.log('Queue events listening setup complete');
-    }
-    /**
-     * Register spawn worker handler with ServiceQueueManager
-     * This allows workers to be spawned on-demand via the service queue.
-     * Uses the same logic as scaling cycle - calls scaler's @OnSpawnWorker first,
-     * then auto-creates via processor if registered.
-     */
-    async registerSpawnWorkerHandler() {
-        if (!this.serviceQueueManager) {
-            this.logger.debug('ServiceQueueManager not available, skipping spawn handler registration');
-            return;
+        else {
+            this.logger.debug('QueryBus not found in DI container. ' +
+                'Import CqrsModule in your app or call setQueryBus() manually.');
         }
-        this.serviceQueueManager.registerSpawnWorkerHandler(async (entityType, entityId) => {
-            const scaler = this.scalers.get(entityType);
-            const processor = this.processors.get(entityType);
-            // First call custom spawn handler if scaler has @OnSpawnWorker defined
-            if (scaler?.methods.onSpawnWorker) {
-                await scaler.scalerInstance[scaler.methods.onSpawnWorker](entityId);
-            }
-            // Also auto-create worker if processor is registered (and scaler didn't create one)
-            if (processor) {
-                await this.createWorkerForEntity(entityType, entityId);
-            }
-            // If neither scaler nor processor can handle this, log a warning
-            if (!scaler?.methods.onSpawnWorker && !processor) {
-                this.logger.warn(`No spawn handler for entity type '${entityType}'. ` +
-                    `Either add @OnSpawnWorker() to your scaler or register a @WorkerProcessor.`);
-            }
-        });
-        this.logger.debug('Spawn worker handler registered with ServiceQueueManager');
     }
     /**
      * Auto-discover and register commands/queries from @nestjs/cqrs handlers
@@ -278,358 +171,88 @@ let ProcessorDiscoveryService = ProcessorDiscoveryService_1 = class ProcessorDis
             this.logger.log(`Auto-registered ${commands} commands and ${queries} queries from CQRS handlers`);
         }
     }
+    // ==========================================================================
+    // PUBLIC API — Delegated to Registry
+    // ==========================================================================
     /**
-     * Discover all @WorkerProcessor decorated classes
+     * Get registered processor for an entity type
      */
-    async discoverProcessors() {
-        const providers = this.discoveryService.getProviders();
-        for (const wrapper of providers) {
-            const { instance, metatype } = wrapper;
-            if (!instance || !metatype)
-                continue;
-            // Cast to Type<any> for metadata functions
-            const targetClass = metatype;
-            const options = (0, decorators_1.getWorkerProcessorMetadata)(targetClass);
-            if (!options)
-                continue;
-            this.registerProcessor(targetClass, instance, options);
-        }
-        this.logger.log(`Discovered ${this.processors.size} worker processor(s): ${Array.from(this.processors.keys()).join(', ')}`);
+    getProcessor(entityType) {
+        return this.registry.getProcessor(entityType);
     }
     /**
-     * Discover all @EntityScaler decorated classes
+     * Get registered scaler for an entity type
      */
-    async discoverScalers() {
-        const providers = this.discoveryService.getProviders();
-        for (const wrapper of providers) {
-            const { instance, metatype } = wrapper;
-            if (!instance || !metatype)
-                continue;
-            // Cast to Type<any> for metadata functions
-            const targetClass = metatype;
-            const options = (0, decorators_1.getEntityScalerMetadata)(targetClass);
-            if (!options)
-                continue;
-            this.registerScaler(targetClass, instance, options);
-        }
-        this.logger.log(`Discovered ${this.scalers.size} entity scaler(s): ${Array.from(this.scalers.keys()).join(', ')}`);
+    getScaler(entityType) {
+        return this.registry.getScaler(entityType);
     }
     /**
-     * Register a processor from discovered metadata
+     * Get all registered entity types
      */
-    registerProcessor(metatype, instance, options) {
-        const { entityType } = options;
-        // Build job handlers map
-        const handlers = (0, decorators_1.getJobHandlerMetadata)(metatype);
-        const jobHandlers = new Map();
-        let wildcardHandler;
-        for (const handler of handlers) {
-            if (handler.isWildcard) {
-                wildcardHandler = { method: handler.methodName };
-            }
-            else {
-                jobHandlers.set(handler.jobName, {
-                    method: handler.methodName,
-                    isWildcard: false,
-                });
-            }
-        }
-        // Build queue and worker name functions
-        const keyPrefix = this.config.keyPrefix || 'aq';
-        const queueNameFn = typeof options.queueName === 'function'
-            ? options.queueName
-            : options.queueName
-                ? () => options.queueName
-                : (entityId) => `${keyPrefix}:${entityType}:${entityId}:queue`;
-        const workerNameFn = typeof options.workerName === 'function'
-            ? options.workerName
-            : options.workerName
-                ? () => options.workerName
-                : (entityId) => `${keyPrefix}:${entityType}:${entityId}:worker`;
-        const processor = {
-            entityType,
-            processorInstance: instance,
-            options,
-            jobHandlers,
-            wildcardHandler,
-            queueNameFn,
-            workerNameFn,
-        };
-        this.processors.set(entityType, processor);
-        this.activeWorkers.set(entityType, new Set());
-        this.logger.debug(`Registered processor for entity type '${entityType}' with ${jobHandlers.size} job handlers` +
-            (wildcardHandler ? ' and wildcard handler' : ''));
+    getRegisteredEntityTypes() {
+        return this.registry.getRegisteredEntityTypes();
     }
     /**
-     * Register a scaler from discovered metadata
+     * Check if a worker exists for an entity
      */
-    registerScaler(metatype, instance, options) {
-        const { entityType } = options;
-        // Find decorated methods
-        const methods = {
-            getActiveEntities: Reflect.getMetadata(decorators_1.GET_ACTIVE_ENTITIES_METADATA + ':method', metatype),
-            getDesiredWorkerCount: Reflect.getMetadata(decorators_1.GET_DESIRED_WORKER_COUNT_METADATA + ':method', metatype),
-            onSpawnWorker: Reflect.getMetadata(decorators_1.ON_SPAWN_WORKER_METADATA + ':method', metatype),
-            onTerminateWorker: Reflect.getMetadata(decorators_1.ON_TERMINATE_WORKER_METADATA + ':method', metatype),
-        };
-        const scaler = {
-            entityType,
-            scalerInstance: instance,
-            options,
-            methods,
-        };
-        this.scalers.set(entityType, scaler);
-        this.logger.debug(`Registered scaler for entity type '${entityType}' with methods: ` +
-            Object.entries(methods)
-                .filter(([_, v]) => v)
-                .map(([k, _]) => k)
-                .join(', '));
+    hasActiveWorker(entityType, entityId) {
+        return this.registry.hasActiveWorker(entityType, entityId);
     }
     /**
-     * Register scalers with CronManager for automatic scaling
+     * Get all active workers for an entity type
      */
-    async registerScalersWithCronManager() {
-        if (!this.cronManager) {
-            this.logger.warn('CronManager not available. Automatic scaling disabled.');
-            return;
-        }
-        for (const [entityType, scaler] of this.scalers) {
-            const processor = this.processors.get(entityType);
-            const scalingConfig = {
-                entityType,
-                maxWorkersPerEntity: scaler.options.maxWorkersPerEntity ?? 1,
-                idleTimeoutSeconds: scaler.options.idleTimeoutSeconds ?? 15,
-                getActiveEntityIds: async () => {
-                    if (scaler.methods.getActiveEntities) {
-                        return scaler.scalerInstance[scaler.methods.getActiveEntities]();
-                    }
-                    return [];
-                },
-                getDesiredWorkerCount: async (entityId) => {
-                    if (scaler.methods.getDesiredWorkerCount) {
-                        return scaler.scalerInstance[scaler.methods.getDesiredWorkerCount](entityId);
-                    }
-                    return 1; // Default to 1 worker
-                },
-                onSpawnWorker: async (entityId) => {
-                    // First call custom spawn handler if defined
-                    if (scaler.methods.onSpawnWorker) {
-                        await scaler.scalerInstance[scaler.methods.onSpawnWorker](entityId);
-                    }
-                    // Auto-create worker if processor is registered
-                    if (processor) {
-                        await this.createWorkerForEntity(entityType, entityId);
-                    }
-                },
-                onTerminateWorker: async (entityId, workerId) => {
-                    // First call custom terminate handler if defined
-                    if (scaler.methods.onTerminateWorker) {
-                        await scaler.scalerInstance[scaler.methods.onTerminateWorker](entityId, workerId);
-                    }
-                    // Auto-terminate worker if processor is registered
-                    if (processor) {
-                        const workerName = processor.workerNameFn(entityId);
-                        await this.workerManager.signalWorkerClose(workerName);
-                    }
-                },
-            };
-            this.cronManager.registerEntityType(scalingConfig);
-            this.logger.log(`Registered scaling config for entity type '${entityType}' (idleTimeout: ${scalingConfig.idleTimeoutSeconds}s)`);
-        }
+    getActiveWorkers(entityType) {
+        return this.registry.getActiveWorkers(entityType);
     }
+    // ==========================================================================
+    // PUBLIC API — Delegated to WorkerFactory
+    // ==========================================================================
     /**
      * Create a worker for an entity using the registered processor
      */
     async createWorkerForEntity(entityType, entityId) {
-        const processor = this.processors.get(entityType);
-        if (!processor) {
-            throw new Error(`No processor registered for entity type: ${entityType}`);
-        }
-        const workerName = processor.workerNameFn(entityId);
-        const queueName = processor.queueNameFn(entityId);
-        // Check if worker already exists
-        if (await this.workerManager.workerExists(workerName)) {
-            this.logger.debug(`Worker ${workerName} already exists, skipping`);
-            return;
-        }
-        this.logger.log(`Creating worker ${workerName} for ${entityType}:${entityId}`);
-        // Ensure queue exists
-        this.queueManager.getOrCreateQueue(queueName);
-        // Create the worker with the processor
-        const workerConfig = {
-            concurrency: 1,
-            stalledInterval: 1000,
-            lockDuration: 30000,
-            heartbeatTTL: 3,
-            heartbeatInterval: 1000,
-            ...this.config.workerDefaults,
-            ...processor.options.workerConfig,
-        };
-        await this.workerManager.createWorker({
-            workerName,
-            queueName,
-            config: workerConfig,
-            processor: async (job) => {
-                return this.processJob(processor, job, entityId);
-            },
-            events: {
-                onReady: async () => {
-                    this.logger.log(`Worker ${workerName} ready`);
-                    this.activeWorkers.get(entityType)?.add(entityId);
-                },
-                onCompleted: async (job) => {
-                    this.logger.debug(`Worker ${workerName}: Job ${job.id} completed`);
-                },
-                onFailed: async (job, error) => {
-                    this.logger.error(`Worker ${workerName}: Job ${job?.id} failed: ${error.message}`);
-                },
-                onClosed: async () => {
-                    this.logger.log(`Worker ${workerName} closed`);
-                    this.activeWorkers.get(entityType)?.delete(entityId);
-                },
-            },
-        });
-    }
-    /**
-     * Process a job using the registered handlers
-     *
-     * Priority order:
-     * 1. Explicit @JobHandler on the processor class (if instance exists)
-     * 2. Auto-routing via @JobCommand/@JobQuery decorated classes
-     * 3. QueueBus registry lookup (class name as job name)
-     * 4. Wildcard @JobHandler('*') on the processor class (if instance exists)
-     */
-    async processJob(processor, job, entityId) {
-        const { processorInstance, jobHandlers, wildcardHandler, entityType } = processor;
-        const jobName = job.name;
-        // 1. Try to find specific @JobHandler (only if processor has an instance)
-        if (processorInstance) {
-            const handler = jobHandlers.get(jobName);
-            if (handler) {
-                return processorInstance[handler.method](job, entityId);
-            }
-        }
-        // 2. Try auto-routing via @JobCommand/@JobQuery
-        if (this.commandDiscovery) {
-            const result = await this.commandDiscovery.executeJob(job, entityId, entityType);
-            if (result !== undefined) {
-                return result;
-            }
-            // Check if a handler exists (even if it returned undefined)
-            if (this.commandDiscovery.hasHandler(jobName, entityType)) {
-                return result;
-            }
-        }
-        // 3. Try QueueBus registry lookup (job.name = class name like 'MakeBetCommand')
-        const registryEntry = queue_bus_1.QueueBus.getRegistered(jobName);
-        if (registryEntry) {
-            return this.executeFromRegistry(registryEntry, job, entityId);
-        }
-        // 4. Fall back to wildcard handler (only if processor has an instance)
-        if (processorInstance && wildcardHandler) {
-            return processorInstance[wildcardHandler.method](job, entityId);
-        }
-        // No handler found
-        this.logger.warn(`No handler found for job '${jobName}' on entity type '${entityType}'`);
-        return null;
-    }
-    /**
-     * Execute a command/query from QueueBus registry
-     */
-    async executeFromRegistry(entry, job, entityId) {
-        const { targetClass, isQuery, className } = entry;
-        // Instantiate the command/query with job data
-        const instance = Object.assign(new targetClass(), job.data);
-        if (isQuery) {
-            if (!this.queryBus) {
-                this.logger.error(`QueryBus not set. Cannot execute query ${className}. Call setQueryBus() first.`);
-                return null;
-            }
-            return this.queryBus.execute(instance);
-        }
-        else {
-            if (!this.commandBus) {
-                this.logger.error(`CommandBus not set. Cannot execute command ${className}. Call setCommandBus() first.`);
-                return null;
-            }
-            return this.commandBus.execute(instance);
-        }
+        return this.workerFactory.createWorkerForEntity(entityType, entityId);
     }
     // ==========================================================================
-    // PUBLIC API - Manual Registration
+    // PUBLIC API — Manual Registration (Delegated to DecoratorDiscovery)
     // ==========================================================================
     /**
      * Manually register a processor class
-     * Use this when auto-discovery is not available or for dynamic registration
      */
     async registerProcessorClass(processorClass, instance) {
-        const options = (0, decorators_1.getWorkerProcessorMetadata)(processorClass);
+        const { getWorkerProcessorMetadata } = await Promise.resolve().then(() => __importStar(require('../../decorators')));
+        const options = getWorkerProcessorMetadata(processorClass);
         if (!options) {
             throw new Error(`Class ${processorClass.name} is not decorated with @WorkerProcessor`);
         }
         const resolvedInstance = instance || this.moduleRef.get(processorClass, { strict: false });
-        this.registerProcessor(processorClass, resolvedInstance, options);
+        this.decoratorDiscovery.registerProcessor(this.registry, processorClass, resolvedInstance, options);
     }
     /**
      * Manually register a scaler class
      */
     async registerScalerClass(scalerClass, instance) {
-        const options = (0, decorators_1.getEntityScalerMetadata)(scalerClass);
+        const { getEntityScalerMetadata } = await Promise.resolve().then(() => __importStar(require('../../decorators')));
+        const options = getEntityScalerMetadata(scalerClass);
         if (!options) {
             throw new Error(`Class ${scalerClass.name} is not decorated with @EntityScaler`);
         }
         const resolvedInstance = instance || this.moduleRef.get(scalerClass, { strict: false });
-        this.registerScaler(scalerClass, resolvedInstance, options);
-    }
-    /**
-     * Get registered processor for an entity type
-     */
-    getProcessor(entityType) {
-        return this.processors.get(entityType);
-    }
-    /**
-     * Get registered scaler for an entity type
-     */
-    getScaler(entityType) {
-        return this.scalers.get(entityType);
-    }
-    /**
-     * Get all registered entity types
-     */
-    getRegisteredEntityTypes() {
-        return Array.from(new Set([...this.processors.keys(), ...this.scalers.keys()]));
-    }
-    /**
-     * Check if a worker exists for an entity
-     */
-    hasActiveWorker(entityType, entityId) {
-        return this.activeWorkers.get(entityType)?.has(entityId) ?? false;
-    }
-    /**
-     * Get all active workers for an entity type
-     */
-    getActiveWorkers(entityType) {
-        return Array.from(this.activeWorkers.get(entityType) || []);
+        this.decoratorDiscovery.registerScaler(this.registry, scalerClass, resolvedInstance, options);
     }
 };
 exports.ProcessorDiscoveryService = ProcessorDiscoveryService;
 exports.ProcessorDiscoveryService = ProcessorDiscoveryService = ProcessorDiscoveryService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Optional)()),
-    __param(1, (0, common_1.Optional)()),
-    __param(5, (0, common_1.Optional)()),
     __param(6, (0, common_1.Optional)()),
-    __param(7, (0, common_1.Optional)()),
-    __param(8, (0, common_1.Optional)()),
-    __param(9, (0, common_1.Inject)(constants_1.ATOMIC_QUEUES_CONFIG)),
+    __param(7, (0, common_1.Inject)(constants_1.ATOMIC_QUEUES_CONFIG)),
     __metadata("design:paramtypes", [core_1.DiscoveryService,
-        core_1.MetadataScanner,
         core_1.ModuleRef,
-        worker_manager_1.WorkerManagerService,
-        queue_manager_1.QueueManagerService,
-        cron_manager_1.CronManagerService,
-        command_discovery_1.CommandDiscoveryService,
-        service_queue_1.ServiceQueueManager,
-        queue_events_manager_1.QueueEventsManagerService, Object])
+        processor_registry_1.ProcessorRegistry,
+        decorator_discovery_service_1.DecoratorDiscoveryService,
+        worker_factory_service_1.WorkerFactoryService,
+        scaling_registration_service_1.ScalingRegistrationService,
+        command_discovery_1.CommandDiscoveryService, Object])
 ], ProcessorDiscoveryService);
 //# sourceMappingURL=processor-discovery.service.js.map