@anchan828/nest-cloud-run-queue-worker 2.4.1 → 3.1.0

package/dist/constants.d.ts

@@ -4,5 +4,3 @@ export declare const QUEUE_WORKER_PROCESS_DECORATOR = "QUEUE_WORKER_PROCESS_DECO
 export declare const ERROR_INVALID_MESSAGE_FORMAT = "Invalid message format.";
 export declare const ERROR_QUEUE_WORKER_NAME_NOT_FOUND = "QueueWorker name not found.";
 export declare const ERROR_WORKER_NOT_FOUND: (name: string) => string;
-export declare const UNHANDLED_QUEUE_WORKER_NAME = "__unhandled_queue_worker";
-export declare const ALL_WORKERS_QUEUE_WORKER_NAME = "__all_queue_workers";

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALL_WORKERS_QUEUE_WORKER_NAME = exports.UNHANDLED_QUEUE_WORKER_NAME = exports.ERROR_WORKER_NOT_FOUND = exports.ERROR_QUEUE_WORKER_NAME_NOT_FOUND = exports.ERROR_INVALID_MESSAGE_FORMAT = exports.QUEUE_WORKER_PROCESS_DECORATOR = exports.QUEUE_WORKER_DECORATOR = exports.QUEUE_WORKER_MODULE_OPTIONS = void 0;
+exports.ERROR_WORKER_NOT_FOUND = exports.ERROR_QUEUE_WORKER_NAME_NOT_FOUND = exports.ERROR_INVALID_MESSAGE_FORMAT = exports.QUEUE_WORKER_PROCESS_DECORATOR = exports.QUEUE_WORKER_DECORATOR = exports.QUEUE_WORKER_MODULE_OPTIONS = void 0;
 exports.QUEUE_WORKER_MODULE_OPTIONS = "QUEUE_WORKER_MODULE_OPTIONS";
 exports.QUEUE_WORKER_DECORATOR = "QUEUE_WORKER_DECORATOR";
 exports.QUEUE_WORKER_PROCESS_DECORATOR = "QUEUE_WORKER_PROCESS_DECORATOR";
@@ -9,5 +9,3 @@ exports.ERROR_INVALID_MESSAGE_FORMAT = "Invalid message format.";
 exports.ERROR_QUEUE_WORKER_NAME_NOT_FOUND = "QueueWorker name not found.";
 const ERROR_WORKER_NOT_FOUND = (name) => `QueueWorker '${name}' not found.`;
 exports.ERROR_WORKER_NOT_FOUND = ERROR_WORKER_NOT_FOUND;
-exports.UNHANDLED_QUEUE_WORKER_NAME = "__unhandled_queue_worker";
-exports.ALL_WORKERS_QUEUE_WORKER_NAME = "__all_queue_workers";

package/dist/explorer.service.js

@@ -14,6 +14,7 @@ const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const metadata_scanner_1 = require("@nestjs/core/metadata-scanner");
 const constants_1 = require("./constants");
+const util_1 = require("./util");
 let QueueWorkerExplorerService = class QueueWorkerExplorerService {
     constructor(discoveryService, metadataScanner) {
         this.discoveryService = discoveryService;
@@ -22,9 +23,9 @@ let QueueWorkerExplorerService = class QueueWorkerExplorerService {
     explore() {
         const workers = this.getWorkers();
         for (const worker of workers) {
-            worker.processors = this.getQueueWorkerProcessors(worker);
+            worker.processors = (0, util_1.sortByPriority)(this.getQueueWorkerProcessors(worker));
         }
-        return workers;
+        return (0, util_1.sortByPriority)(workers);
     }
     getWorkers() {
         const metadata = [];

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { ALL_WORKERS_QUEUE_WORKER_NAME as ALL_QUEUE_WORKERS, UNHANDLED_QUEUE_WORKER_NAME as UNHANDLED_QUEUE_WORKER, } from "./constants";
 export { QueueWorker, QueueWorkerProcess } from "./decorators";
-export { QueueWorkerControllerInterface, QueueWorkerControllerMetadata, QueueWorkerDecodedMessage, QueueWorkerExtraConfig, QueueWorkerModuleAsyncOptions, QueueWorkerModuleOptions, QueueWorkerModuleOptionsFactory, QueueWorkerOptions, QueueWorkerProcessFailureResult, QueueWorkerProcessOptions, QueueWorkerProcessResult, QueueWorkerProcessSuccessResult, QueueWorkerProcessor, QueueWorkerProcessorStatus, QueueWorkerRawMessage, QueueWorkerReceivedMessage, } from "./interfaces";
+export { QueueWorkerControllerInterface, QueueWorkerControllerMetadata, QueueWorkerDecodedMessage, QueueWorkerModuleAsyncOptions, QueueWorkerModuleOptions, QueueWorkerModuleOptionsFactory, QueueWorkerOptions, QueueWorkerProcessFailureResult, QueueWorkerProcessOptions, QueueWorkerProcessResult, QueueWorkerProcessSuccessResult, QueueWorkerProcessor, QueueWorkerRawMessage, QueueWorkerReceivedMessage, } from "./interfaces";
 export { decodeMessage } from "./util";
+export { Processor, Worker } from "./worker";
 export { QueueWorkerModule } from "./worker.module";
 export { QueueWorkerService } from "./worker.service";

package/dist/index.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueWorkerService = exports.QueueWorkerModule = exports.decodeMessage = exports.QueueWorkerProcessorStatus = exports.QueueWorkerProcess = exports.QueueWorker = exports.UNHANDLED_QUEUE_WORKER = exports.ALL_QUEUE_WORKERS = void 0;
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "ALL_QUEUE_WORKERS", { enumerable: true, get: function () { return constants_1.ALL_WORKERS_QUEUE_WORKER_NAME; } });
-Object.defineProperty(exports, "UNHANDLED_QUEUE_WORKER", { enumerable: true, get: function () { return constants_1.UNHANDLED_QUEUE_WORKER_NAME; } });
+exports.QueueWorkerService = exports.QueueWorkerModule = exports.Worker = exports.Processor = exports.decodeMessage = exports.QueueWorkerProcess = exports.QueueWorker = void 0;
 var decorators_1 = require("./decorators");
 Object.defineProperty(exports, "QueueWorker", { enumerable: true, get: function () { return decorators_1.QueueWorker; } });
 Object.defineProperty(exports, "QueueWorkerProcess", { enumerable: true, get: function () { return decorators_1.QueueWorkerProcess; } });
-var interfaces_1 = require("./interfaces");
-Object.defineProperty(exports, "QueueWorkerProcessorStatus", { enumerable: true, get: function () { return interfaces_1.QueueWorkerProcessorStatus; } });
 var util_1 = require("./util");
 Object.defineProperty(exports, "decodeMessage", { enumerable: true, get: function () { return util_1.decodeMessage; } });
+var worker_1 = require("./worker");
+Object.defineProperty(exports, "Processor", { enumerable: true, get: function () { return worker_1.Processor; } });
+Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return worker_1.Worker; } });
 var worker_module_1 = require("./worker.module");
 Object.defineProperty(exports, "QueueWorkerModule", { enumerable: true, get: function () { return worker_module_1.QueueWorkerModule; } });
 var worker_service_1 = require("./worker.service");

package/dist/interfaces.d.ts

@@ -16,13 +16,6 @@ export interface QueueWorkerModuleOptions extends ModuleOptions {
      * @memberof QueueWorkerModuleOptions
      */
     maxRetryAttempts?: number;
-    /**
-     * extra config
-     *
-     * @type {QueueWorkerExtraConfig}
-     * @memberof QueueWorkerModuleOptions
-     */
-    extraConfig?: QueueWorkerExtraConfig;
     /**
      * Define a Route for the controller.
      * Default: POST /
@@ -47,14 +40,6 @@ export interface QueueWorkerProcessorMetadata extends QueueWorkerProcessDecorato
     processorName: string;
     processor: QueueWorkerProcessor;
 }
-export declare enum QueueWorkerProcessorStatus {
-    IN_PROGRESS = 0,
-    SKIP = 1
-}
-export type QueueWorkerExtraConfig = {
-    preProcessor?: (name: string, ...args: Parameters<QueueWorkerProcessor>) => (QueueWorkerProcessorStatus | undefined | void) | Promise<QueueWorkerProcessorStatus | undefined | void>;
-    postProcessor?: (name: string, ...args: Parameters<QueueWorkerProcessor>) => void | Promise<void>;
-};
 export interface QueueWorkerDecoratorArgs {
     names: QueueWorkerName[];
     /**
@@ -84,9 +69,17 @@ export interface QueueWorkerProcessDecoratorArgs {
 }
 export type QueueWorkerRawMessage<T = any> = {
     readonly data?: string | null | Message<T>;
+    readonly messageId?: string;
     readonly headers?: Record<string, string>;
 } & Record<string, any>;
 export type QueueWorkerDecodedMessage<T = any> = {
+    /**
+     * The message ID is a unique identifier.
+     * If controller recieve from Pub/Sub, it will be body.message.messageId.
+     * If controller recieve from Cloud Tasks, it will be body.message.headers["X-CloudTasks-TaskName"].
+     * If nothing is obtained, it will be an empty string.
+     */
+    readonly id: string;
     readonly data: Message<T>;
     readonly headers?: Record<string, string>;
     readonly raw: QueueWorkerRawMessage;
@@ -102,6 +95,10 @@ export interface QueueWorkerControllerMetadata extends RequestMappingMetadata {
      * @memberof QueueWorkerControllerMetadata
      */
     statusCode?: number;
+    /**
+     * Whether to throw the error as is when Processor throws an error. Default is true.
+     */
+    throwError?: boolean;
 }
 export interface QueueWorkerControllerInterface {
     execute(body: QueueWorkerReceivedMessage, headers: Record<string, string>): Promise<void>;
@@ -130,7 +127,7 @@ export interface QueueWorkerProcessOptions {
      */
     enabled?: boolean;
 }
-type QueueWorkerProcessResultBase<T = any> = {
+export type QueueWorkerProcessResultBase<T = any> = {
     workerName: QueueWorkerName;
     processorName: string;
     data?: T;
@@ -144,4 +141,3 @@ export type QueueWorkerProcessFailureResult<T = any> = {
     error: Error;
 } & QueueWorkerProcessResultBase<T>;
 export type QueueWorkerProcessResult<T = any> = QueueWorkerProcessSuccessResult<T> | QueueWorkerProcessFailureResult<T>;
-export {};

package/dist/interfaces.js

@@ -1,8 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueWorkerProcessorStatus = void 0;
-var QueueWorkerProcessorStatus;
-(function (QueueWorkerProcessorStatus) {
-    QueueWorkerProcessorStatus[QueueWorkerProcessorStatus["IN_PROGRESS"] = 0] = "IN_PROGRESS";
-    QueueWorkerProcessorStatus[QueueWorkerProcessorStatus["SKIP"] = 1] = "SKIP";
-})(QueueWorkerProcessorStatus || (exports.QueueWorkerProcessorStatus = QueueWorkerProcessorStatus = {}));

package/dist/util.js

@@ -70,15 +70,16 @@ function decodeMessage(message) {
         // tasks / http
         data = message;
     }
-    if (!data.name) {
-        throw new common_1.BadRequestException(constants_1.ERROR_QUEUE_WORKER_NAME_NOT_FOUND);
-    }
     return {
         data,
         headers: "headers" in message ? message.headers : undefined,
+        id: getMessageId(message),
         raw: message,
     };
 }
+function getMessageId(raw) {
+    return raw.messageId ?? raw.headers?.["x-cloudtasks-taskname"] ?? "";
+}
 function decodeData(data) {
     if (!data) {
         throw new common_1.BadRequestException(constants_1.ERROR_INVALID_MESSAGE_FORMAT);

package/dist/worker.controller.js

@@ -18,13 +18,18 @@ const worker_service_1 = require("./worker.service");
 function getWorkerController(metadata) {
     const path = metadata?.path;
     const method = metadata?.method || common_1.RequestMethod.POST;
+    const throwError = metadata?.throwError ?? true;
     let WorkerController = class WorkerController {
         constructor(service) {
             this.service = service;
         }
         async execute(body, headers) {
-            this.service.execute({});
-            await this.service.execute({ ...body.message, headers });
+            const results = await this.service.execute({ ...body.message, headers });
+            for (const result of results) {
+                if (!result.success && throwError) {
+                    throw result.error;
+                }
+            }
         }
     };
     __decorate([

package/dist/worker.d.ts

@@ -0,0 +1,31 @@
+import { QueueWorkerDecodedMessage, QueueWorkerMetadata, QueueWorkerModuleOptions, QueueWorkerProcessorMetadata, QueueWorkerProcessResult } from "./interfaces";
+export declare class Worker<T> {
+    private readonly message;
+    private readonly metadata;
+    private readonly options;
+    get name(): string;
+    get priority(): number;
+    get className(): string;
+    constructor(message: QueueWorkerDecodedMessage<T>, metadata: QueueWorkerMetadata, options: QueueWorkerModuleOptions);
+    /**
+     * Execute all processors in the worker. If you want to execute a each processor, use `getProcessors` method.
+     */
+    execute(): Promise<QueueWorkerProcessResult[]>;
+    /**
+     * Get all processors in the worker. Use this method to execute manually when you want to execute only on specific conditions using metadata such as class name or processor name.
+     */
+    getProcessors(): Processor<T>[];
+}
+export declare class Processor<T> {
+    private readonly message;
+    private readonly metadata;
+    private readonly options;
+    get name(): string;
+    get priority(): number;
+    get workerName(): string;
+    constructor(message: QueueWorkerDecodedMessage<T>, metadata: QueueWorkerProcessorMetadata, options: QueueWorkerModuleOptions);
+    /**
+     * Execute the processor.
+     */
+    execute(): Promise<QueueWorkerProcessResult<T>>;
+}

package/dist/worker.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Processor = exports.Worker = void 0;
+class Worker {
+    get name() {
+        return this.metadata.name;
+    }
+    get priority() {
+        return this.metadata.priority;
+    }
+    get className() {
+        return this.metadata.className;
+    }
+    constructor(message, metadata, options) {
+        this.message = message;
+        this.metadata = metadata;
+        this.options = options;
+    }
+    /**
+     * Execute all processors in the worker. If you want to execute a each processor, use `getProcessors` method.
+     */
+    async execute() {
+        const results = [];
+        const processors = this.getProcessors();
+        for (const processor of processors) {
+            results.push(await processor.execute());
+        }
+        return results;
+    }
+    /**
+     * Get all processors in the worker. Use this method to execute manually when you want to execute only on specific conditions using metadata such as class name or processor name.
+     */
+    getProcessors() {
+        return this.metadata.processors.map((processor) => new Processor(this.message, processor, this.options));
+    }
+}
+exports.Worker = Worker;
+class Processor {
+    get name() {
+        return this.metadata.processorName;
+    }
+    get priority() {
+        return this.metadata.priority;
+    }
+    get workerName() {
+        return this.metadata.workerName;
+    }
+    constructor(message, metadata, options) {
+        this.message = message;
+        this.metadata = metadata;
+        this.options = options;
+    }
+    /**
+     * Execute the processor.
+     */
+    async execute() {
+        const maxRetryAttempts = this.options.maxRetryAttempts ?? 1;
+        const resultBase = {
+            data: this.message.data.data,
+            processorName: this.metadata.processorName,
+            raw: this.message.raw,
+            workerName: this.metadata.workerName,
+        };
+        for (let i = 0; i < maxRetryAttempts; i++) {
+            try {
+                await this.metadata.processor(this.message.data.data, this.message.raw);
+                i = maxRetryAttempts;
+            }
+            catch (error) {
+                if (maxRetryAttempts === i + 1) {
+                    return {
+                        error,
+                        success: false,
+                        ...resultBase,
+                    };
+                }
+            }
+        }
+        return {
+            success: true,
+            ...resultBase,
+        };
+    }
+}
+exports.Processor = Processor;

package/dist/worker.service.d.ts

@@ -1,21 +1,24 @@
-import { Logger } from "@nestjs/common";
 import { Message } from "@anchan828/nest-cloud-run-queue-common";
 import { QueueWorkerExplorerService } from "./explorer.service";
 import { QueueWorkerDecodedMessage, QueueWorkerModuleOptions, QueueWorkerProcessResult, QueueWorkerRawMessage } from "./interfaces";
+import { Worker } from "./worker";
 export declare class QueueWorkerService {
     #private;
     private readonly options;
-    private readonly logger;
     private readonly explorerService;
-    constructor(options: QueueWorkerModuleOptions, logger: Logger, explorerService: QueueWorkerExplorerService);
+    constructor(options: QueueWorkerModuleOptions, explorerService: QueueWorkerExplorerService);
+    /**
+     * Execute all workers that match the worker name. If you want to execute a each worker, use `getWorkers` method.
+     */
+    execute<T = any>(meessage: QueueWorkerRawMessage<T>): Promise<QueueWorkerProcessResult<T>[]>;
     execute<T = any>(meessage: Message<T>): Promise<QueueWorkerProcessResult<T>[]>;
     execute<T = any>(meessage: QueueWorkerDecodedMessage<T>): Promise<QueueWorkerProcessResult<T>[]>;
-    execute<T = any>(meessage: QueueWorkerRawMessage<T>): Promise<QueueWorkerProcessResult<T>[]>;
     /**
-     * @deprecated Use `decodeMessage` function instead.
+     * Get all workers that match the worker name. Use this method to execute manually when you want to execute only on specific conditions using metadata such as class name or processor name.
+     * If you want to execute all workers simply, use `execute` method.
      */
-    decodeMessage<T = any>(message: QueueWorkerRawMessage | Message): QueueWorkerDecodedMessage<T>;
-    private runWorkers;
+    getWorkers<T = any>(meessage: QueueWorkerRawMessage<T>): Worker<T>[];
+    getWorkers<T = any>(meessage: Message<T>): Worker<T>[];
+    getWorkers<T = any>(meessage: QueueWorkerDecodedMessage<T>): Worker<T>[];
     private isDecodedMessage;
-    private executeProcessor;
 }

package/dist/worker.service.js

@@ -22,88 +22,48 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _QueueWorkerService_instances, _QueueWorkerService__allWorkers, _QueueWorkerService_allWorkers_get, _QueueWorkerService_spetialWorkers_get;
+var _QueueWorkerService_instances, _QueueWorkerService__allWorkers, _QueueWorkerService_allWorkers_get;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueWorkerService = void 0;
 const common_1 = require("@nestjs/common");
 const constants_1 = require("./constants");
 const explorer_service_1 = require("./explorer.service");
-const interfaces_1 = require("./interfaces");
 const util_1 = require("./util");
+const worker_1 = require("./worker");
 let QueueWorkerService = class QueueWorkerService {
-    constructor(options, logger, explorerService) {
+    constructor(options, explorerService) {
         _QueueWorkerService_instances.add(this);
         this.options = options;
-        this.logger = logger;
         this.explorerService = explorerService;
         _QueueWorkerService__allWorkers.set(this, void 0);
     }
     async execute(meessage) {
-        return await this.runWorkers(this.isDecodedMessage(meessage) ? meessage : (0, util_1.decodeMessage)(meessage));
-    }
-    /**
-     * @deprecated Use `decodeMessage` function instead.
-     */
-    decodeMessage(message) {
-        return (0, util_1.decodeMessage)(message);
-    }
-    async runWorkers(decodedMessage) {
-        const maxRetryAttempts = this.options.maxRetryAttempts ?? 1;
-        const workers = [];
-        workers.push(...__classPrivateFieldGet(this, _QueueWorkerService_instances, "a", _QueueWorkerService_allWorkers_get).filter((worker) => decodedMessage.data.name === worker.name));
-        if (this.options?.throwModuleError && workers.length === 0 && __classPrivateFieldGet(this, _QueueWorkerService_instances, "a", _QueueWorkerService_spetialWorkers_get).length === 0) {
+        const decodedMessage = this.isDecodedMessage(meessage) ? meessage : (0, util_1.decodeMessage)(meessage);
+        if (this.options.throwModuleError && !decodedMessage.data.name) {
+            throw new common_1.BadRequestException(constants_1.ERROR_QUEUE_WORKER_NAME_NOT_FOUND);
+        }
+        const workers = await this.getWorkers(decodedMessage);
+        if (this.options.throwModuleError && workers.length === 0) {
             throw new common_1.BadRequestException((0, constants_1.ERROR_WORKER_NOT_FOUND)(decodedMessage.data.name));
         }
-        const processors = (0, util_1.sortByPriority)(workers)
-            .map((w) => (0, util_1.sortByPriority)(w.processors))
-            .flat();
-        const spetialProcessors = (0, util_1.sortByPriority)(__classPrivateFieldGet(this, _QueueWorkerService_instances, "a", _QueueWorkerService_spetialWorkers_get))
-            .map((w) => (0, util_1.sortByPriority)(w.processors))
-            .flat();
-        const QueueWorkerProcessResults = [];
-        const processorStatus = await this.options.extraConfig?.preProcessor?.(decodedMessage.data.name, decodedMessage.data.data, decodedMessage.raw);
-        if (processorStatus !== interfaces_1.QueueWorkerProcessorStatus.SKIP) {
-            for (const processor of processors) {
-                QueueWorkerProcessResults.push(await this.executeProcessor(processor, maxRetryAttempts, decodedMessage.data.data, decodedMessage.raw));
-            }
-            for (const processor of spetialProcessors) {
-                await this.executeProcessor(processor, maxRetryAttempts, decodedMessage.data, decodedMessage.raw);
-            }
+        const results = [];
+        for (const worker of workers) {
+            results.push(...(await worker.execute()));
+        }
+        return results;
+    }
+    getWorkers(meessage) {
+        const decodedMessage = this.isDecodedMessage(meessage) ? meessage : (0, util_1.decodeMessage)(meessage);
+        if (!decodedMessage.data.name) {
+            return [];
         }
-        await this.options.extraConfig?.postProcessor?.(decodedMessage.data.name, decodedMessage.data.data, decodedMessage.raw);
-        return QueueWorkerProcessResults;
+        return __classPrivateFieldGet(this, _QueueWorkerService_instances, "a", _QueueWorkerService_allWorkers_get)
+            .filter((worker) => decodedMessage.data.name === worker.name)
+            .map((metadata) => new worker_1.Worker(decodedMessage, metadata, this.options));
     }
     isDecodedMessage(message) {
         return "raw" in message;
     }
-    async executeProcessor(processorMetadata, maxRetryAttempts, data, raw) {
-        for (let i = 0; i < maxRetryAttempts; i++) {
-            try {
-                await processorMetadata.processor(data, raw);
-                i = maxRetryAttempts;
-            }
-            catch (error) {
-                this.logger.error(error.message);
-                if (maxRetryAttempts === i + 1) {
-                    return {
-                        data,
-                        error,
-                        processorName: processorMetadata.processorName,
-                        raw,
-                        success: false,
-                        workerName: processorMetadata.workerName,
-                    };
-                }
-            }
-        }
-        return {
-            data,
-            processorName: processorMetadata.processorName,
-            raw,
-            success: true,
-            workerName: processorMetadata.workerName,
-        };
-    }
 };
 exports.QueueWorkerService = QueueWorkerService;
 _QueueWorkerService__allWorkers = new WeakMap();
@@ -114,12 +74,8 @@ _QueueWorkerService_allWorkers_get = function _QueueWorkerService_allWorkers_get
     }
     return __classPrivateFieldGet(this, _QueueWorkerService__allWorkers, "f");
 };
-_QueueWorkerService_spetialWorkers_get = function _QueueWorkerService_spetialWorkers_get() {
-    return (__classPrivateFieldGet(this, _QueueWorkerService__allWorkers, "f") || []).filter((worker) => [constants_1.ALL_WORKERS_QUEUE_WORKER_NAME, constants_1.UNHANDLED_QUEUE_WORKER_NAME].includes(worker.name));
-};
 exports.QueueWorkerService = QueueWorkerService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(constants_1.QUEUE_WORKER_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object, common_1.Logger,
-        explorer_service_1.QueueWorkerExplorerService])
+    __metadata("design:paramtypes", [Object, explorer_service_1.QueueWorkerExplorerService])
 ], QueueWorkerService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-cloud-run-queue-worker",
-  "version": "2.4.1",
+  "version": "3.1.0",
   "description": "> TODO: description",
   "homepage": "https://github.com/anchan828/nest-cloud-run-queue/tree/master/packages/worker#readme",
   "bugs": {
@@ -33,7 +33,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@anchan828/nest-cloud-run-queue-common": "^2.4.1"
+    "@anchan828/nest-cloud-run-queue-common": "^3.1.0"
   },
   "devDependencies": {
     "@nestjs/common": "10.3.10",
@@ -46,5 +46,5 @@
     "access": "public"
   },
   "packageManager": "npm@10.8.1",
-  "gitHead": "a129feb4af97620af2aeb55d7a89b39c710b0659"
+  "gitHead": "2cf06b0266993c6db926ddde524d4341d4d13668"
 }