@carno.js/queue 0.2.3

package/dist/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUEUE_MODULE_OPTIONS = exports.INJECT_QUEUE_METADATA = exports.JOB_EVENT_METADATA = exports.QUEUE_EVENT_METADATA = exports.PROCESS_METADATA = exports.QUEUE_METADATA = void 0;
+exports.QUEUE_METADATA = 'queue:metadata';
+exports.PROCESS_METADATA = 'queue:process';
+exports.QUEUE_EVENT_METADATA = 'queue:event';
+exports.JOB_EVENT_METADATA = 'queue:job:event';
+exports.INJECT_QUEUE_METADATA = 'queue:inject';
+exports.QUEUE_MODULE_OPTIONS = 'queue:module:options';

package/dist/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './queue.decorator';
+export * from './process.decorator';
+export * from './inject-queue.decorator';
+export * from './job-events.decorator';
+export * from './queue-events.decorator';

package/dist/decorators/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./queue.decorator"), exports);
+__exportStar(require("./process.decorator"), exports);
+__exportStar(require("./inject-queue.decorator"), exports);
+__exportStar(require("./job-events.decorator"), exports);
+__exportStar(require("./queue-events.decorator"), exports);

package/dist/decorators/inject-queue.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare function InjectQueue(queueName: string): ParameterDecorator;
+export declare function getQueueToken(queueName: string): string;

package/dist/decorators/inject-queue.decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectQueue = InjectQueue;
+exports.getQueueToken = getQueueToken;
+function InjectQueue(queueName) {
+    return (target, propertyKey, parameterIndex) => {
+        const token = getQueueToken(queueName);
+        const existingParams = Reflect.getMetadata('design:paramtypes', target, propertyKey) || [];
+        existingParams[parameterIndex] = token;
+        Reflect.defineMetadata('design:paramtypes', existingParams, target, propertyKey);
+    };
+}
+function getQueueToken(queueName) {
+    return `Queue:${queueName}`;
+}

package/dist/decorators/job-events.decorator.d.ts

@@ -0,0 +1,8 @@
+export declare const OnJobCompleted: (jobName?: string) => MethodDecorator;
+export declare const OnJobFailed: (jobName?: string) => MethodDecorator;
+export declare const OnJobProgress: (jobName?: string) => MethodDecorator;
+export declare const OnJobActive: (jobName?: string) => MethodDecorator;
+export declare const OnJobWaiting: (jobName?: string) => MethodDecorator;
+export declare const OnJobDelayed: (jobName?: string) => MethodDecorator;
+export declare const OnJobRemoved: (jobName?: string) => MethodDecorator;
+export declare const OnJobStalled: (jobName?: string) => MethodDecorator;

package/dist/decorators/job-events.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnJobStalled = exports.OnJobRemoved = exports.OnJobDelayed = exports.OnJobWaiting = exports.OnJobActive = exports.OnJobProgress = exports.OnJobFailed = exports.OnJobCompleted = void 0;
+const core_1 = require("@carno.js/core");
+const constants_1 = require("../constants");
+function createJobEventDecorator(eventName) {
+    return (jobName) => {
+        return (target, propertyKey) => {
+            addEventMetadata(eventName, jobName, target, propertyKey);
+        };
+    };
+}
+function addEventMetadata(eventName, jobName, target, propertyKey) {
+    const metadata = {
+        eventName,
+        jobName,
+        methodName: propertyKey,
+        target,
+    };
+    const existing = core_1.Metadata.get(constants_1.JOB_EVENT_METADATA, Reflect) || [];
+    core_1.Metadata.set(constants_1.JOB_EVENT_METADATA, [...existing, metadata], Reflect);
+}
+exports.OnJobCompleted = createJobEventDecorator('completed');
+exports.OnJobFailed = createJobEventDecorator('failed');
+exports.OnJobProgress = createJobEventDecorator('progress');
+exports.OnJobActive = createJobEventDecorator('active');
+exports.OnJobWaiting = createJobEventDecorator('waiting');
+exports.OnJobDelayed = createJobEventDecorator('delayed');
+exports.OnJobRemoved = createJobEventDecorator('removed');
+exports.OnJobStalled = createJobEventDecorator('stalled');

package/dist/decorators/process.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ProcessOptions } from '../interfaces';
+export declare function Process(nameOrOptions?: string | ProcessOptions): MethodDecorator;

package/dist/decorators/process.decorator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Process = Process;
+const core_1 = require("@carno.js/core");
+const constants_1 = require("../constants");
+function Process(nameOrOptions) {
+    return (target, propertyKey) => {
+        const options = normalizeOptions(nameOrOptions);
+        const metadata = {
+            ...options,
+            methodName: propertyKey,
+            target,
+        };
+        const existingMetadata = core_1.Metadata.get(constants_1.PROCESS_METADATA, Reflect) || [];
+        core_1.Metadata.set(constants_1.PROCESS_METADATA, [...existingMetadata, metadata], Reflect);
+    };
+}
+function normalizeOptions(nameOrOptions) {
+    if (!nameOrOptions) {
+        return {};
+    }
+    if (typeof nameOrOptions === 'string') {
+        return { name: nameOrOptions };
+    }
+    return nameOrOptions;
+}

package/dist/decorators/queue-events.decorator.d.ts

@@ -0,0 +1,6 @@
+export declare const OnQueueCleaned: () => MethodDecorator;
+export declare const OnQueueDrained: () => MethodDecorator;
+export declare const OnQueueError: () => MethodDecorator;
+export declare const OnQueuePaused: () => MethodDecorator;
+export declare const OnQueueResumed: () => MethodDecorator;
+export declare const OnQueueWaiting: () => MethodDecorator;

package/dist/decorators/queue-events.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnQueueWaiting = exports.OnQueueResumed = exports.OnQueuePaused = exports.OnQueueError = exports.OnQueueDrained = exports.OnQueueCleaned = void 0;
+const core_1 = require("@carno.js/core");
+const constants_1 = require("../constants");
+function createQueueEventDecorator(eventName) {
+    return () => {
+        return (target, propertyKey) => {
+            addEventMetadata(eventName, target, propertyKey);
+        };
+    };
+}
+function addEventMetadata(eventName, target, propertyKey) {
+    const metadata = {
+        eventName,
+        methodName: propertyKey,
+        target,
+    };
+    const existing = core_1.Metadata.get(constants_1.QUEUE_EVENT_METADATA, Reflect) || [];
+    core_1.Metadata.set(constants_1.QUEUE_EVENT_METADATA, [...existing, metadata], Reflect);
+}
+exports.OnQueueCleaned = createQueueEventDecorator('cleaned');
+exports.OnQueueDrained = createQueueEventDecorator('drained');
+exports.OnQueueError = createQueueEventDecorator('error');
+exports.OnQueuePaused = createQueueEventDecorator('paused');
+exports.OnQueueResumed = createQueueEventDecorator('resumed');
+exports.OnQueueWaiting = createQueueEventDecorator('waiting');

package/dist/decorators/queue.decorator.d.ts

@@ -0,0 +1,2 @@
+import { QueueOptions } from '../interfaces';
+export declare function Queue(name: string, options?: Omit<QueueOptions, 'name'>): ClassDecorator;

package/dist/decorators/queue.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = Queue;
+const core_1 = require("@carno.js/core");
+const constants_1 = require("../constants");
+function Queue(name, options = {}) {
+    return (target) => {
+        const metadata = {
+            name,
+            options,
+            target,
+        };
+        const existingMetadata = core_1.Metadata.get(constants_1.QUEUE_METADATA, Reflect) || [];
+        core_1.Metadata.set(constants_1.QUEUE_METADATA, [...existingMetadata, metadata], Reflect);
+        return (0, core_1.Injectable)()(target);
+    };
+}

package/dist/entry.d.ts

@@ -0,0 +1,3 @@
+import { Carno } from '@carno.js/core';
+import { QueueModuleOptions } from './interfaces';
+export declare function CarnoQueue(options?: QueueModuleOptions): Carno;

package/dist/entry.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarnoQueue = CarnoQueue;
+const core_1 = require("@carno.js/core");
+const queue_orchestration_service_1 = require("./queue-orchestration.service");
+const queue_registry_1 = require("./queue.registry");
+const queue_discovery_service_1 = require("./services/queue-discovery.service");
+const queue_builder_service_1 = require("./services/queue-builder.service");
+const event_binder_service_1 = require("./services/event-binder.service");
+const connection_manager_service_1 = require("./services/connection-manager.service");
+const constants_1 = require("./constants");
+function CarnoQueue(options = {}) {
+    const connectionManager = new connection_manager_service_1.ConnectionManagerService();
+    connectionManager.setDefaultConnection(options.connection);
+    return new core_1.Carno({
+        providers: [
+            {
+                provide: constants_1.QUEUE_MODULE_OPTIONS,
+                useValue: options,
+            },
+            {
+                provide: connection_manager_service_1.ConnectionManagerService,
+                useValue: () => connectionManager,
+            },
+        ],
+        exports: [
+            queue_orchestration_service_1.QueueOrchestration,
+            queue_registry_1.QueueRegistry,
+            queue_discovery_service_1.QueueDiscoveryService,
+            queue_builder_service_1.QueueBuilderService,
+            event_binder_service_1.EventBinderService,
+            connection_manager_service_1.ConnectionManagerService,
+        ],
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './decorators';
+export * from './interfaces';
+export * from './constants';
+export * from './queue.registry';
+export * from './queue-orchestration.service';
+export * from './entry';
+export { getQueueToken } from './decorators/inject-queue.decorator';
+export { QueueDiscoveryService } from './services/queue-discovery.service';
+export { QueueBuilderService } from './services/queue-builder.service';
+export { EventBinderService } from './services/event-binder.service';
+export { ConnectionManagerService } from './services/connection-manager.service';
+export { QueueClient } from './services/queue-client.service';
+export { QueueClientProxy } from './services/queue-client-proxy.service';
+export { Queue as BullQueue, Worker, Job } from 'bullmq';

package/dist/index.js

@@ -0,0 +1,41 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = exports.Worker = exports.BullQueue = exports.QueueClientProxy = exports.QueueClient = exports.ConnectionManagerService = exports.EventBinderService = exports.QueueBuilderService = exports.QueueDiscoveryService = exports.getQueueToken = void 0;
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./queue.registry"), exports);
+__exportStar(require("./queue-orchestration.service"), exports);
+__exportStar(require("./entry"), exports);
+var inject_queue_decorator_1 = require("./decorators/inject-queue.decorator");
+Object.defineProperty(exports, "getQueueToken", { enumerable: true, get: function () { return inject_queue_decorator_1.getQueueToken; } });
+var queue_discovery_service_1 = require("./services/queue-discovery.service");
+Object.defineProperty(exports, "QueueDiscoveryService", { enumerable: true, get: function () { return queue_discovery_service_1.QueueDiscoveryService; } });
+var queue_builder_service_1 = require("./services/queue-builder.service");
+Object.defineProperty(exports, "QueueBuilderService", { enumerable: true, get: function () { return queue_builder_service_1.QueueBuilderService; } });
+var event_binder_service_1 = require("./services/event-binder.service");
+Object.defineProperty(exports, "EventBinderService", { enumerable: true, get: function () { return event_binder_service_1.EventBinderService; } });
+var connection_manager_service_1 = require("./services/connection-manager.service");
+Object.defineProperty(exports, "ConnectionManagerService", { enumerable: true, get: function () { return connection_manager_service_1.ConnectionManagerService; } });
+var queue_client_service_1 = require("./services/queue-client.service");
+Object.defineProperty(exports, "QueueClient", { enumerable: true, get: function () { return queue_client_service_1.QueueClient; } });
+var queue_client_proxy_service_1 = require("./services/queue-client-proxy.service");
+Object.defineProperty(exports, "QueueClientProxy", { enumerable: true, get: function () { return queue_client_proxy_service_1.QueueClientProxy; } });
+var bullmq_1 = require("bullmq");
+Object.defineProperty(exports, "BullQueue", { enumerable: true, get: function () { return bullmq_1.Queue; } });
+Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return bullmq_1.Worker; } });
+Object.defineProperty(exports, "Job", { enumerable: true, get: function () { return bullmq_1.Job; } });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './queue-options.interface';
+export * from './process-options.interface';
+export * from './queue-module-options.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./queue-options.interface"), exports);
+__exportStar(require("./process-options.interface"), exports);
+__exportStar(require("./queue-module-options.interface"), exports);

package/dist/interfaces/process-options.interface.d.ts

@@ -0,0 +1,4 @@
+export interface ProcessOptions {
+    name?: string;
+    concurrency?: number;
+}

package/dist/interfaces/process-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/queue-module-options.interface.d.ts

@@ -0,0 +1,4 @@
+import { ConnectionOptions } from 'bullmq';
+export interface QueueModuleOptions {
+    connection?: ConnectionOptions;
+}

package/dist/interfaces/queue-module-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/queue-options.interface.d.ts

@@ -0,0 +1,15 @@
+import { ConnectionOptions } from 'bullmq';
+export interface QueueOptions {
+    name?: string;
+    connection?: ConnectionOptions;
+    defaultJobOptions?: {
+        attempts?: number;
+        backoff?: number | {
+            type: string;
+            delay: number;
+        };
+        delay?: number;
+        removeOnComplete?: boolean | number;
+        removeOnFail?: boolean | number;
+    };
+}

package/dist/interfaces/queue-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue-orchestration.service.d.ts

@@ -0,0 +1,38 @@
+import { InjectorService } from '@carno.js/core';
+import { QueueRegistry } from './queue.registry';
+import { QueueDiscoveryService } from './services/queue-discovery.service';
+import { QueueBuilderService } from './services/queue-builder.service';
+import { EventBinderService } from './services/event-binder.service';
+export declare class QueueOrchestration {
+    private queueRegistry;
+    private discoveryService;
+    private builderService;
+    private eventBinder;
+    private injector;
+    constructor(queueRegistry: QueueRegistry, discoveryService: QueueDiscoveryService, builderService: QueueBuilderService, eventBinder: EventBinderService, injector: InjectorService);
+    onApplicationInit(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    private setupQueues;
+    private isProviderNotFoundError;
+    private setupQueue;
+    private createQueue;
+    private setupProcessors;
+    private findProcessors;
+    private createUnifiedWorker;
+    private buildWorkerId;
+    private getOrCreateInstance;
+    private createProcessorFunction;
+    private buildProcessorMap;
+    private createRouterProcessor;
+    private executeProcessorWithContext;
+    private findProcessorMethodName;
+    private calculateMaxConcurrency;
+    private setupAllJobEvents;
+    private deduplicateEvents;
+    private setupJobEvents;
+    private findJobEvents;
+    private isEventForProcessor;
+    private setupQueueEvents;
+    private findQueueEvents;
+    private registerQueueProvider;
+}

package/dist/queue-orchestration.service.js

@@ -0,0 +1,243 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueOrchestration = void 0;
+const core_1 = require("@carno.js/core");
+const queue_registry_1 = require("./queue.registry");
+const queue_discovery_service_1 = require("./services/queue-discovery.service");
+const queue_builder_service_1 = require("./services/queue-builder.service");
+const event_binder_service_1 = require("./services/event-binder.service");
+const inject_queue_decorator_1 = require("./decorators/inject-queue.decorator");
+const queue_proxy_factory_service_1 = require("./services/queue-proxy-factory.service");
+let QueueOrchestration = class QueueOrchestration {
+    constructor(queueRegistry, discoveryService, builderService, eventBinder, injector) {
+        this.queueRegistry = queueRegistry;
+        this.discoveryService = discoveryService;
+        this.builderService = builderService;
+        this.eventBinder = eventBinder;
+        this.injector = injector;
+    }
+    async onApplicationInit() {
+        this.setupQueues();
+    }
+    async onApplicationShutdown() {
+        await this.queueRegistry.closeAll();
+    }
+    setupQueues() {
+        const queues = this.discoveryService.discoverQueues();
+        // First pass: Create all queues and register their providers
+        queues.forEach(queueMetadata => {
+            try {
+                const queue = this.createQueue(queueMetadata);
+                this.registerQueueProvider(queueMetadata.name, queue);
+            }
+            catch (error) {
+                if (this.isProviderNotFoundError(error)) {
+                    return;
+                }
+                throw error;
+            }
+        });
+        // Second pass: Setup processors and workers for all queues
+        queues.forEach(queueMetadata => {
+            try {
+                this.setupProcessors(queueMetadata);
+                const queue = this.queueRegistry.getQueue(queueMetadata.name);
+                this.setupQueueEvents(queueMetadata, queue);
+            }
+            catch (error) {
+                if (this.isProviderNotFoundError(error)) {
+                    return;
+                }
+                throw error;
+            }
+        });
+    }
+    isProviderNotFoundError(error) {
+        return error?.message?.includes('Provider not found');
+    }
+    setupQueue(queueMetadata) {
+        const queue = this.createQueue(queueMetadata);
+        this.registerQueueProvider(queueMetadata.name, queue);
+        this.setupProcessors(queueMetadata);
+        this.setupQueueEvents(queueMetadata, queue);
+    }
+    createQueue(metadata) {
+        return this.builderService.createQueue(metadata.name, metadata.options);
+    }
+    setupProcessors(queueMetadata) {
+        const processors = this.findProcessors(queueMetadata);
+        if (processors.length === 0) {
+            return;
+        }
+        this.createUnifiedWorker(queueMetadata, processors);
+    }
+    findProcessors(queueMetadata) {
+        const all = this.discoveryService.discoverProcessors();
+        const filtered = all.filter(p => {
+            const matches = p.target === queueMetadata.target.prototype;
+            return matches;
+        });
+        return filtered;
+    }
+    createUnifiedWorker(queueMetadata, processors) {
+        try {
+            const instance = this.getOrCreateInstance(queueMetadata);
+            const processorMap = this.buildProcessorMap(instance, processors);
+            const routerProcessor = this.createRouterProcessor(queueMetadata, processorMap);
+            const maxConcurrency = this.calculateMaxConcurrency(processors);
+            const worker = this.builderService.createWorker(queueMetadata.name, queueMetadata.name, routerProcessor, { concurrency: maxConcurrency });
+            // Add worker event listeners for debugging
+            worker.on('ready', () => {
+                console.log(`[WORKER READY] Worker for queue ${queueMetadata.name} is ready and waiting for jobs`);
+            });
+            this.setupAllJobEvents(queueMetadata, worker, instance, processors);
+        }
+        catch (error) {
+            console.error(`[ERROR] Failed to create unified worker for queue ${queueMetadata.name}:`, error);
+            throw error;
+        }
+    }
+    buildWorkerId(queueName, jobName) {
+        return `${queueName}:${jobName}`;
+    }
+    getOrCreateInstance(metadata) {
+        return this.injector.invoke(metadata.target);
+    }
+    createProcessorFunction(instance, metadata) {
+        return instance[metadata.methodName].bind(instance);
+    }
+    buildProcessorMap(instance, processors) {
+        const map = new Map();
+        processors.forEach(processor => {
+            const jobName = processor.name || '__default__';
+            const fn = instance[processor.methodName].bind(instance);
+            map.set(jobName, fn);
+        });
+        return map;
+    }
+    createRouterProcessor(queueMetadata, processorMap) {
+        return async (job) => {
+            const jobName = job.name;
+            const processor = processorMap.get(jobName);
+            if (!processor) {
+                const defaultProcessor = processorMap.get('__default__');
+                if (defaultProcessor) {
+                    return this.executeProcessorWithContext(queueMetadata, defaultProcessor, job);
+                }
+                throw new Error(`No processor found for job \"${jobName}\"`);
+            }
+            return this.executeProcessorWithContext(queueMetadata, processor, job);
+        };
+    }
+    executeProcessorWithContext(queueMetadata, processor, job) {
+        const context = core_1.Context.createFromJob(job);
+        const locals = new core_1.LocalsContainer();
+        locals.set(core_1.Context, context);
+        const instance = this.injector.invoke(queueMetadata.target, locals);
+        const boundProcessor = instance[this.findProcessorMethodName(queueMetadata, job.name)].bind(instance);
+        return boundProcessor(job);
+    }
+    findProcessorMethodName(queueMetadata, jobName) {
+        const processors = this.findProcessors(queueMetadata);
+        const processor = processors.find(p => (p.name || '__default__') === jobName);
+        if (!processor) {
+            const defaultProcessor = processors.find(p => !p.name || p.name === '__default__');
+            return defaultProcessor?.methodName;
+        }
+        return processor.methodName;
+    }
+    calculateMaxConcurrency(processors) {
+        const concurrencies = processors
+            .map(p => p.concurrency ?? 1)
+            .filter(c => typeof c === 'number');
+        if (concurrencies.length === 0) {
+            return 1;
+        }
+        return Math.max(...concurrencies);
+    }
+    setupAllJobEvents(queueMetadata, worker, instance, processors) {
+        const allEvents = processors.flatMap(processor => {
+            return this.findJobEvents(queueMetadata, processor);
+        });
+        const uniqueEvents = this.deduplicateEvents(allEvents);
+        this.eventBinder.bindJobEvents(worker, uniqueEvents, instance);
+    }
+    deduplicateEvents(events) {
+        const seen = new Set();
+        const unique = [];
+        events.forEach(event => {
+            const key = `${event.eventName}:${event.methodName}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                unique.push(event);
+            }
+        });
+        return unique;
+    }
+    setupJobEvents(queueMetadata, worker, instance, processorMetadata) {
+        const events = this.findJobEvents(queueMetadata, processorMetadata);
+        this.eventBinder.bindJobEvents(worker, events, instance);
+    }
+    findJobEvents(queueMetadata, processorMetadata) {
+        const all = this.discoveryService.discoverJobEvents();
+        return all.filter(e => {
+            return this.isEventForProcessor(e, queueMetadata, processorMetadata);
+        });
+    }
+    isEventForProcessor(event, queueMetadata, processorMetadata) {
+        const sameTarget = event.target === queueMetadata.target.prototype;
+        const sameJob = !event.jobName ||
+            event.jobName === processorMetadata.name;
+        return sameTarget && sameJob;
+    }
+    setupQueueEvents(queueMetadata, queue) {
+        const events = this.findQueueEvents(queueMetadata);
+        const instance = this.getOrCreateInstance(queueMetadata);
+        this.eventBinder.bindQueueEvents(queue, events, instance);
+    }
+    findQueueEvents(queueMetadata) {
+        const all = this.discoveryService.discoverQueueEvents();
+        return all.filter(e => {
+            return e.target === queueMetadata.target.prototype;
+        });
+    }
+    registerQueueProvider(name, queue) {
+        const token = (0, inject_queue_decorator_1.getQueueToken)(name);
+        const ProxyFactory = (0, queue_proxy_factory_service_1.createQueueProxyFactory)(queue);
+        this.injector.container.addProvider(token, {
+            provide: token,
+            useClass: ProxyFactory,
+            scope: core_1.ProviderScope.SINGLETON,
+        });
+    }
+};
+exports.QueueOrchestration = QueueOrchestration;
+__decorate([
+    (0, core_1.OnApplicationInit)(100),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], QueueOrchestration.prototype, "onApplicationInit", null);
+__decorate([
+    (0, core_1.OnApplicationShutdown)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], QueueOrchestration.prototype, "onApplicationShutdown", null);
+exports.QueueOrchestration = QueueOrchestration = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [queue_registry_1.QueueRegistry,
+        queue_discovery_service_1.QueueDiscoveryService,
+        queue_builder_service_1.QueueBuilderService,
+        event_binder_service_1.EventBinderService,
+        core_1.InjectorService])
+], QueueOrchestration);