@anchan828/nest-cloud-run-queue-worker 1.0.3-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 anchan828
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @anchan828/nest-cloud-run-queue-worker
+
+## Install
+
+```shell
+npm i @anchan828/nest-cloud-run-queue-worker
+```
+
+## Usage
+
+See [https://github.com/anchan828/nest-cloud-run-queue#readme](https://github.com/anchan828/nest-cloud-run-queue#readme)

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const QUEUE_WORKER_MODULE_OPTIONS = "QUEUE_WORKER_MODULE_OPTIONS";
+export declare const QUEUE_WORKER_DECORATOR = "QUEUE_WORKER_DECORATOR";
+export declare const QUEUE_WORKER_PROCESS_DECORATOR = "QUEUE_WORKER_PROCESS_DECORATOR";
+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

@@ -0,0 +1,13 @@
+"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.QUEUE_WORKER_MODULE_OPTIONS = "QUEUE_WORKER_MODULE_OPTIONS";
+exports.QUEUE_WORKER_DECORATOR = "QUEUE_WORKER_DECORATOR";
+exports.QUEUE_WORKER_PROCESS_DECORATOR = "QUEUE_WORKER_PROCESS_DECORATOR";
+// errors
+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/decorators.d.ts

@@ -0,0 +1,18 @@
+import { QueueWorkerName } from "@anchan828/nest-cloud-run-queue-common";
+/**
+ * Define worker
+ *
+ * @export
+ * @param {QueueWorkerName} name
+ * @param {number} [priority=0] Highest priority is 0, and lower the larger integer you use.
+ * @returns {ClassDecorator}
+ */
+export declare function QueueWorker(name: QueueWorkerName, priority?: number): ClassDecorator;
+/**
+ * Define worker processor
+ *
+ * @export
+ * @param {number} [priority=0] Highest priority is 0, and lower the larger integer you use.
+ * @returns {MethodDecorator}
+ */
+export declare function QueueWorkerProcess(priority?: number): MethodDecorator;

package/dist/decorators.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueWorkerProcess = exports.QueueWorker = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+/**
+ * Define worker
+ *
+ * @export
+ * @param {QueueWorkerName} name
+ * @param {number} [priority=0] Highest priority is 0, and lower the larger integer you use.
+ * @returns {ClassDecorator}
+ */
+function QueueWorker(name, priority = 0) {
+    return (0, common_1.SetMetadata)(constants_1.QUEUE_WORKER_DECORATOR, { name, priority });
+}
+exports.QueueWorker = QueueWorker;
+/**
+ * Define worker processor
+ *
+ * @export
+ * @param {number} [priority=0] Highest priority is 0, and lower the larger integer you use.
+ * @returns {MethodDecorator}
+ */
+function QueueWorkerProcess(priority = 0) {
+    return (0, common_1.SetMetadata)(constants_1.QUEUE_WORKER_PROCESS_DECORATOR, { priority });
+}
+exports.QueueWorkerProcess = QueueWorkerProcess;

package/dist/explorer.service.d.ts

@@ -0,0 +1,11 @@
+import { DiscoveryService } from "@nestjs/core";
+import { MetadataScanner } from "@nestjs/core/metadata-scanner";
+import { QueueWorkerMetadata } from "./interfaces";
+export declare class QueueWorkerExplorerService {
+    private readonly discoveryService;
+    private readonly metadataScanner;
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner);
+    explore(): QueueWorkerMetadata[];
+    private getWorkers;
+    private getQueueWorkerProcessors;
+}

package/dist/explorer.service.js

@@ -0,0 +1,66 @@
+"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.QueueWorkerExplorerService = void 0;
+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");
+let QueueWorkerExplorerService = class QueueWorkerExplorerService {
+    constructor(discoveryService, metadataScanner) {
+        this.discoveryService = discoveryService;
+        this.metadataScanner = metadataScanner;
+    }
+    explore() {
+        const workers = this.getWorkers();
+        for (const worker of workers) {
+            worker.processors = this.getQueueWorkerProcessors(worker);
+        }
+        return workers;
+    }
+    getWorkers() {
+        const metadata = [];
+        for (const classInstanceWrapper of this.discoveryService
+            .getProviders()
+            .filter((instanceWrapper) => { var _a; return (_a = instanceWrapper.instance) === null || _a === void 0 ? void 0 : _a.constructor; })) {
+            const args = Reflect.getMetadata(constants_1.QUEUE_WORKER_DECORATOR, classInstanceWrapper.instance.constructor);
+            if (args) {
+                metadata.push({
+                    instance: classInstanceWrapper.instance,
+                    name: args.name,
+                    priority: args.priority || 0,
+                    processors: [],
+                });
+            }
+        }
+        return metadata;
+    }
+    getQueueWorkerProcessors(worker) {
+        const metadata = [];
+        const instance = worker.instance;
+        const prototype = Object.getPrototypeOf(instance);
+        for (const methodName of this.metadataScanner.getAllFilteredMethodNames(prototype)) {
+            const args = Reflect.getMetadata(constants_1.QUEUE_WORKER_PROCESS_DECORATOR, prototype[methodName]);
+            if (args) {
+                metadata.push({
+                    priority: args.priority || 0,
+                    processor: prototype[methodName].bind(instance),
+                });
+            }
+        }
+        return metadata;
+    }
+};
+QueueWorkerExplorerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.DiscoveryService, metadata_scanner_1.MetadataScanner])
+], QueueWorkerExplorerService);
+exports.QueueWorkerExplorerService = QueueWorkerExplorerService;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+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 { QueueWorkerModuleAsyncOptions, QueueWorkerModuleOptions, QueueWorkerModuleOptionsFactory, QueueWorkerProcessor, QueueWorkerProcessorStatus, QueueWorkerExtraConfig, QueueWorkerRawMessage, QueueWorkerControllerInterface, QueueWorkerControllerMetadata, } from "./interfaces";
+export { QueueWorkerModule } from "./worker.module";
+export { QueueWorkerService } from "./worker.service";

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueWorkerService = exports.QueueWorkerModule = 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; } });
+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 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");
+Object.defineProperty(exports, "QueueWorkerService", { enumerable: true, get: function () { return worker_service_1.QueueWorkerService; } });

package/dist/interfaces.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" />
+import { QueueWorkerName, ModuleAsyncOptions, ModuleOptions, ModuleOptionsFactory } from "@anchan828/nest-cloud-run-queue-common";
+import { RequestMappingMetadata } from "@nestjs/common";
+import { Injectable } from "@nestjs/common/interfaces";
+export interface QueueWorkerModuleOptions extends ModuleOptions {
+    /**
+     * Whether to return 4xx codes when throw error about nest-cloud-run-queue-pubsub module. Default is false.
+     * ex, Returns 204 instead of 400 when worker name not found. Returns 204 instead of 400 when message data is invalid.
+     * @type {boolean}
+     * @memberof QueueWorkerModuleOptions
+     */
+    throwModuleError?: boolean;
+    /**
+     * Max number of processor retry attempts. If an error occurs in a processor, it will try again.
+     *
+     * @type {number}
+     * @memberof QueueWorkerModuleOptions
+     */
+    maxRetryAttempts?: number;
+    /**
+     * extra config
+     *
+     * @type {QueueWorkerExtraConfig}
+     * @memberof QueueWorkerModuleOptions
+     */
+    extraConfig?: QueueWorkerExtraConfig;
+    /**
+     * Define a Route for the controller.
+     * Default: POST /
+     * @type {QueueWorkerControllerMetadata}
+     * @memberof QueueWorkerModuleOptions
+     */
+    workerController?: QueueWorkerControllerMetadata;
+}
+export declare type QueueWorkerModuleAsyncOptions = ModuleAsyncOptions<Omit<QueueWorkerModuleOptions, "workerController">> & Pick<QueueWorkerModuleOptions, "workerController">;
+export declare type QueueWorkerModuleOptionsFactory = ModuleOptionsFactory<Omit<QueueWorkerModuleOptions, "workerController">> & Pick<QueueWorkerModuleOptions, "workerController">;
+export declare type QueueWorkerProcessor = <T>(message: T, rawMessage: QueueWorkerRawMessage) => Promise<void> | void;
+export interface QueueWorkerMetadata extends QueueWorkerDecoratorArgs {
+    instance: Injectable;
+    processors: QueueWorkerProcessorMetadata[];
+}
+export interface QueueWorkerProcessorMetadata extends QueueWorkerProcessDecoratorArgs {
+    processor: QueueWorkerProcessor;
+}
+export declare enum QueueWorkerProcessorStatus {
+    IN_PROGRESS = 0,
+    SKIP = 1
+}
+export declare 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 {
+    name: QueueWorkerName;
+    /**
+     * Highest priority is 0, and lower the larger integer you use.
+     *
+     * @type {number}
+     * @memberof QueueWorkerDecoratorArgs
+     */
+    priority: number;
+}
+export interface QueueWorkerProcessDecoratorArgs {
+    /**
+     * Highest priority is 0, and lower the larger integer you use.
+     *
+     * @type {number}
+     * @memberof QueueWorkerProcessDecoratorArgs
+     */
+    priority: number;
+}
+export declare type QueueWorkerRawMessage<T = Record<string, any>> = {
+    readonly data?: string | Uint8Array | Buffer | null;
+    readonly headers?: Record<string, string>;
+} & T;
+export declare type ReceivedMessage = {
+    readonly message: QueueWorkerRawMessage;
+};
+export interface QueueWorkerControllerMetadata extends RequestMappingMetadata {
+    /**
+     * Default: 200
+     *
+     * @type {number}
+     * @memberof QueueWorkerControllerMetadata
+     */
+    statusCode?: number;
+}
+export interface QueueWorkerControllerInterface {
+    execute(body: ReceivedMessage, headers: Record<string, string>): Promise<void>;
+}

package/dist/interfaces.js

@@ -0,0 +1,8 @@
+"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 || (exports.QueueWorkerProcessorStatus = {}));

package/dist/util.d.ts

@@ -0,0 +1,17 @@
+/**
+ * parse json string to javascript object.
+ * JSON.parse has receiver for Date.parse.
+ * @param json
+ */
+export declare const parseJSON: <T>(json: string) => T;
+/**
+ * sort array by priority prop
+ *
+ * @export
+ * @template T
+ * @param {T[]} items
+ * @returns {T[]}
+ */
+export declare function sortByPriority<T extends {
+    priority: number;
+}>(items: T[]): T[];

package/dist/util.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByPriority = exports.parseJSON = void 0;
+const dateRegExp = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+/**
+ * parse json string to javascript object.
+ * JSON.parse has receiver for Date.parse.
+ * @param json
+ */
+const parseJSON = (json) => {
+    return JSON.parse(json, (_, value) => {
+        if (typeof value === "string" && value.length === 24 && dateRegExp.test(value)) {
+            const date = new Date(value);
+            if (+date === +date) {
+                return date;
+            }
+        }
+        return value;
+    });
+};
+exports.parseJSON = parseJSON;
+/**
+ * sort array by priority prop
+ *
+ * @export
+ * @template T
+ * @param {T[]} items
+ * @returns {T[]}
+ */
+function sortByPriority(items) {
+    return items.sort((x, y) => x.priority - y.priority);
+}
+exports.sortByPriority = sortByPriority;

package/dist/worker.controller.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "@nestjs/common";
+import { QueueWorkerControllerInterface, QueueWorkerControllerMetadata } from "./interfaces";
+export declare function getWorkerController(metadata?: QueueWorkerControllerMetadata): Type<QueueWorkerControllerInterface>;

package/dist/worker.controller.js

@@ -0,0 +1,55 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkerController = void 0;
+const common_1 = require("@nestjs/common");
+const worker_service_1 = require("./worker.service");
+function getWorkerController(metadata) {
+    const path = metadata === null || metadata === void 0 ? void 0 : metadata.path;
+    const method = (metadata === null || metadata === void 0 ? void 0 : metadata.method) || common_1.RequestMethod.POST;
+    let WorkerController = class WorkerController {
+        constructor(service) {
+            this.service = service;
+        }
+        execute(body, headers) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.service.execute(Object.assign(Object.assign({}, body.message), { headers }));
+            });
+        }
+    };
+    __decorate([
+        (0, common_1.RequestMapping)({ method, path }),
+        (0, common_1.HttpCode)((metadata === null || metadata === void 0 ? void 0 : metadata.statusCode) || 200),
+        __param(0, (0, common_1.Body)()),
+        __param(1, (0, common_1.Headers)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Object]),
+        __metadata("design:returntype", Promise)
+    ], WorkerController.prototype, "execute", null);
+    WorkerController = __decorate([
+        (0, common_1.Controller)(),
+        __metadata("design:paramtypes", [worker_service_1.QueueWorkerService])
+    ], WorkerController);
+    return WorkerController;
+}
+exports.getWorkerController = getWorkerController;

package/dist/worker.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from "@nestjs/common";
+import { QueueWorkerModuleAsyncOptions, QueueWorkerModuleOptions } from "./interfaces";
+export declare class QueueWorkerModule {
+    static register(options?: QueueWorkerModuleOptions): DynamicModule;
+    static registerAsync(options: QueueWorkerModuleAsyncOptions): DynamicModule;
+}

package/dist/worker.module.js

@@ -0,0 +1,54 @@
+"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 QueueWorkerModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueWorkerModule = void 0;
+const nest_cloud_run_queue_common_1 = require("@anchan828/nest-cloud-run-queue-common");
+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 explorer_service_1 = require("./explorer.service");
+const worker_controller_1 = require("./worker.controller");
+const worker_service_1 = require("./worker.service");
+let QueueWorkerModule = QueueWorkerModule_1 = class QueueWorkerModule {
+    static register(options = {}) {
+        const WorkerController = (0, worker_controller_1.getWorkerController)(options.workerController);
+        const providers = [(0, nest_cloud_run_queue_common_1.createOptionProvider)(constants_1.QUEUE_WORKER_MODULE_OPTIONS, options)];
+        return {
+            controllers: [WorkerController],
+            global: true,
+            module: QueueWorkerModule_1,
+            providers,
+        };
+    }
+    static registerAsync(options) {
+        const WorkerController = (0, worker_controller_1.getWorkerController)(options.workerController);
+        const providers = [...(0, nest_cloud_run_queue_common_1.createAsyncProviders)(constants_1.QUEUE_WORKER_MODULE_OPTIONS, options)];
+        return {
+            controllers: [WorkerController],
+            global: true,
+            imports: [...(options.imports || [])],
+            module: QueueWorkerModule_1,
+            providers,
+        };
+    }
+};
+QueueWorkerModule = QueueWorkerModule_1 = __decorate([
+    (0, common_1.Module)({
+        exports: [worker_service_1.QueueWorkerService],
+        imports: [core_1.DiscoveryModule],
+        providers: [
+            metadata_scanner_1.MetadataScanner,
+            explorer_service_1.QueueWorkerExplorerService,
+            worker_service_1.QueueWorkerService,
+            { provide: common_1.Logger, useValue: new common_1.Logger("QueueWorkerModule") },
+        ],
+    })
+], QueueWorkerModule);
+exports.QueueWorkerModule = QueueWorkerModule;

package/dist/worker.service.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from "@nestjs/common";
+import { QueueWorkerModuleOptions } from "./interfaces";
+import { QueueWorkerExplorerService } from "./explorer.service";
+import { QueueWorkerRawMessage } from "./interfaces";
+export declare class QueueWorkerService {
+    #private;
+    private readonly options;
+    private readonly logger;
+    private readonly explorerService;
+    constructor(options: QueueWorkerModuleOptions, logger: Logger, explorerService: QueueWorkerExplorerService);
+    execute(message: QueueWorkerRawMessage): Promise<void>;
+    private execProcessor;
+    private decodeData;
+}

package/dist/worker.service.js

@@ -0,0 +1,140 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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_allWorkers;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueWorkerService = void 0;
+const common_1 = require("@nestjs/common");
+const class_validator_1 = require("class-validator");
+const constants_1 = require("./constants");
+const explorer_service_1 = require("./explorer.service");
+const interfaces_1 = require("./interfaces");
+const util_1 = require("./util");
+let QueueWorkerService = class QueueWorkerService {
+    constructor(options, logger, explorerService) {
+        this.options = options;
+        this.logger = logger;
+        this.explorerService = explorerService;
+        _QueueWorkerService_allWorkers.set(this, void 0);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    execute(message) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _QueueWorkerService_allWorkers, "f")) {
+                __classPrivateFieldSet(this, _QueueWorkerService_allWorkers, this.explorerService.explore(), "f");
+            }
+            const maxRetryAttempts = (_a = this.options.maxRetryAttempts) !== null && _a !== void 0 ? _a : 1;
+            const workers = [];
+            const spetialWorkers = [];
+            let data = { name: "" };
+            try {
+                data = this.decodeData(message.data);
+                if (!data.name) {
+                    throw new Error(constants_1.ERROR_QUEUE_WORKER_NAME_NOT_FOUND);
+                }
+                workers.push(...__classPrivateFieldGet(this, _QueueWorkerService_allWorkers, "f").filter((worker) => data.name === worker.name));
+                spetialWorkers.push(...__classPrivateFieldGet(this, _QueueWorkerService_allWorkers, "f").filter((worker) => [constants_1.ALL_WORKERS_QUEUE_WORKER_NAME, constants_1.UNHANDLED_QUEUE_WORKER_NAME].includes(worker.name)));
+                if (workers.length === 0) {
+                    throw new Error((0, constants_1.ERROR_WORKER_NOT_FOUND)(data.name));
+                }
+            }
+            catch (error) {
+                this.logger.error(error.message);
+                if (((_b = this.options) === null || _b === void 0 ? void 0 : _b.throwModuleError) && spetialWorkers.length === 0) {
+                    throw new common_1.BadRequestException(error.message);
+                }
+            }
+            const processors = (0, util_1.sortByPriority)(workers)
+                .map((w) => (0, util_1.sortByPriority)(w.processors))
+                .flat();
+            const spetialProcessors = (0, util_1.sortByPriority)(spetialWorkers)
+                .map((w) => (0, util_1.sortByPriority)(w.processors))
+                .flat();
+            const processorStatus = yield ((_d = (_c = this.options.extraConfig) === null || _c === void 0 ? void 0 : _c.preProcessor) === null || _d === void 0 ? void 0 : _d.call(_c, data.name, data.data, message));
+            if (processorStatus !== interfaces_1.QueueWorkerProcessorStatus.SKIP) {
+                for (const processor of processors) {
+                    yield this.execProcessor(processor.processor, maxRetryAttempts, data.data, message);
+                }
+                for (const processor of spetialProcessors) {
+                    yield this.execProcessor(processor.processor, maxRetryAttempts, data, message);
+                }
+            }
+            yield ((_f = (_e = this.options.extraConfig) === null || _e === void 0 ? void 0 : _e.postProcessor) === null || _f === void 0 ? void 0 : _f.call(_e, data.name, data.data, message));
+        });
+    }
+    execProcessor(processor, maxRetryAttempts, data, rawMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < maxRetryAttempts; i++) {
+                try {
+                    yield processor(data, rawMessage);
+                    i = maxRetryAttempts;
+                }
+                catch (error) {
+                    this.logger.error(error.message);
+                }
+            }
+        });
+    }
+    decodeData(data) {
+        if (!data) {
+            throw new Error(constants_1.ERROR_INVALID_MESSAGE_FORMAT);
+        }
+        if (Buffer.isBuffer(data)) {
+            data = data.toString();
+        }
+        if (data instanceof Uint8Array) {
+            data = new TextDecoder("utf8").decode(data);
+        }
+        if ((0, class_validator_1.isBase64)(data)) {
+            data = Buffer.from(data, "base64").toString();
+        }
+        try {
+            if (typeof data === "string") {
+                return (0, util_1.parseJSON)(data);
+            }
+            return data;
+        }
+        catch (_a) {
+            throw new Error(constants_1.ERROR_INVALID_MESSAGE_FORMAT);
+        }
+    }
+};
+_QueueWorkerService_allWorkers = new WeakMap();
+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])
+], QueueWorkerService);
+exports.QueueWorkerService = QueueWorkerService;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@anchan828/nest-cloud-run-queue-worker",
+  "version": "1.0.3-next.0",
+  "description": "> TODO: description",
+  "homepage": "https://github.com/anchan828/nest-cloud-run-queue/tree/master/packages/worker#readme",
+  "bugs": {
+    "url": "https://github.com/anchan828/nest-cloud-run-queue/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anchan828/nest-cloud-run-queue.git"
+  },
+  "license": "MIT",
+  "author": "anchan828 <anchan828@gmail.com>",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "directories": {
+    "dist": "dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:watch": "tsc --watch",
+    "copy:license": "cp ../../LICENSE ./",
+    "lint": "eslint --ignore-path ../../.eslintignore '**/*.ts'",
+    "lint:fix": "npm run lint -- --fix",
+    "prepublishOnly": "rm -rf dist && npm run build && rm -f dist/*.tsbuildinfo && npm run copy:license",
+    "test": "jest --coverage --logHeapUsage --runInBand",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --logHeapUsage",
+    "test:watch": "jest --watch",
+    "watch": "tsc -w"
+  },
+  "dependencies": {
+    "@anchan828/nest-cloud-run-queue-common": "^1.0.3-next.0",
+    "class-validator": "0.13.2"
+  },
+  "devDependencies": {
+    "@nestjs/common": "8.4.4",
+    "rxjs": "7.5.5"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^8.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "470341e04eead0d62396245ff1a3fe0c7ad4143e"
+}