@anchan828/nest-cloud-run-queue-worker 3.1.6 → 3.1.8

package/dist/{util.js → cjs/util.js}

@@ -58,7 +58,7 @@ function isBase64(value) {
     if (len <= 4 && customBase64Strs.some((base64Str) => value.startsWith(base64Str))) {
         return true;
     }
-    if ((len === 4 && ![2, 3].every((n) => value[n] === "=")) || !len || len % 4 !== 0 || /[^A-Z0-9+\/=]/i.test(value)) {
+    if ((len === 4 && ![2, 3].every((n) => value[n] === "=")) || !len || len % 4 !== 0 || /[^A-Z0-9+/=]/i.test(value)) {
         return false;
     }
     const firstPaddingChar = value.indexOf("=");

package/dist/esm/constants.d.ts

@@ -0,0 +1,6 @@
+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. The message must be an object that has a 'name' property.";
+export declare const ERROR_QUEUE_WORKER_NAME_NOT_FOUND = "Worker name not found.";
+export declare const ERROR_WORKER_NOT_FOUND: (name: string) => string;

package/dist/esm/constants.js

@@ -0,0 +1,7 @@
+export const QUEUE_WORKER_MODULE_OPTIONS = "QUEUE_WORKER_MODULE_OPTIONS";
+export const QUEUE_WORKER_DECORATOR = "QUEUE_WORKER_DECORATOR";
+export const QUEUE_WORKER_PROCESS_DECORATOR = "QUEUE_WORKER_PROCESS_DECORATOR";
+// errors
+export const ERROR_INVALID_MESSAGE_FORMAT = "Invalid message format. The message must be an object that has a 'name' property.";
+export const ERROR_QUEUE_WORKER_NAME_NOT_FOUND = "Worker name not found.";
+export const ERROR_WORKER_NOT_FOUND = (name) => `Worker '${name}' not found.`;

package/dist/esm/decorators.d.ts

@@ -0,0 +1,22 @@
+import { QueueWorkerName } from "@anchan828/nest-cloud-run-queue-common";
+import { QueueWorkerOptions, QueueWorkerProcessOptions } from "./interfaces";
+/**
+ * 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;
+export declare function QueueWorker(names: QueueWorkerName[], priority?: number): ClassDecorator;
+export declare function QueueWorker(options: QueueWorkerOptions): 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;
+export declare function QueueWorkerProcess(options?: QueueWorkerProcessOptions): MethodDecorator;

package/dist/esm/decorators.js

@@ -0,0 +1,27 @@
+import { SetMetadata } from "@nestjs/common";
+import { QUEUE_WORKER_DECORATOR, QUEUE_WORKER_PROCESS_DECORATOR } from "./constants";
+export function QueueWorker(nameOrOptions, priority = 0) {
+    if (Array.isArray(nameOrOptions)) {
+        return SetMetadata(QUEUE_WORKER_DECORATOR, {
+            names: nameOrOptions,
+            priority,
+        });
+    }
+    if (typeof nameOrOptions === "string") {
+        return SetMetadata(QUEUE_WORKER_DECORATOR, {
+            names: [nameOrOptions],
+            priority,
+        });
+    }
+    return SetMetadata(QUEUE_WORKER_DECORATOR, {
+        enabled: nameOrOptions.enabled,
+        names: Array.isArray(nameOrOptions.name) ? nameOrOptions.name : [nameOrOptions.name],
+        priority: nameOrOptions.priority || 0,
+    });
+}
+export function QueueWorkerProcess(priorityOrOptions) {
+    const options = typeof priorityOrOptions === "number"
+        ? { priority: priorityOrOptions }
+        : Object.assign({ priority: 0 }, priorityOrOptions);
+    return SetMetadata(QUEUE_WORKER_PROCESS_DECORATOR, options);
+}

package/dist/esm/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/esm/explorer.service.js

@@ -0,0 +1,76 @@
+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);
+};
+import { Injectable } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core";
+import { MetadataScanner } from "@nestjs/core/metadata-scanner";
+import { QUEUE_WORKER_DECORATOR, QUEUE_WORKER_PROCESS_DECORATOR } from "./constants";
+import { sortByPriority } from "./util";
+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 = sortByPriority(this.getQueueWorkerProcessors(worker));
+        }
+        return sortByPriority(workers);
+    }
+    getWorkers() {
+        const metadata = [];
+        for (const classInstanceWrapper of this.discoveryService
+            .getProviders()
+            .filter((instanceWrapper) => instanceWrapper.instance?.constructor)) {
+            const args = Reflect.getMetadata(QUEUE_WORKER_DECORATOR, classInstanceWrapper.instance.constructor);
+            if (args && Array.isArray(args.names)) {
+                if (args.enabled === false) {
+                    continue;
+                }
+                for (const name of args.names) {
+                    metadata.push({
+                        className: classInstanceWrapper.metatype.name,
+                        instance: classInstanceWrapper.instance,
+                        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.getAllMethodNames(prototype)) {
+            const args = Reflect.getMetadata(QUEUE_WORKER_PROCESS_DECORATOR, prototype[methodName]);
+            if (args) {
+                if (args.enabled === false) {
+                    continue;
+                }
+                metadata.push({
+                    priority: args.priority || 0,
+                    processor: prototype[methodName].bind(instance),
+                    processorName: `${worker.className}.${methodName}`,
+                    workerName: worker.name,
+                });
+            }
+        }
+        return metadata;
+    }
+};
+QueueWorkerExplorerService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DiscoveryService,
+        MetadataScanner])
+], QueueWorkerExplorerService);
+export { QueueWorkerExplorerService };

package/dist/esm/index.d.ts

@@ -0,0 +1,6 @@
+export { QueueWorker, QueueWorkerProcess } from "./decorators";
+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/esm/index.js

@@ -0,0 +1,5 @@
+export { QueueWorker, QueueWorkerProcess } from "./decorators";
+export { decodeMessage } from "./util";
+export { Processor, Worker } from "./worker";
+export { QueueWorkerModule } from "./worker.module";
+export { QueueWorkerService } from "./worker.service";

package/dist/esm/interfaces.d.ts

@@ -0,0 +1,153 @@
+import { Message, ModuleAsyncOptions, ModuleOptions, ModuleOptionsFactory, QueueWorkerName } 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 /
+     * If you provide your own Controller, set it to null.
+     * @type {(QueueWorkerControllerMetadata | null)}
+     * @memberof QueueWorkerModuleOptions
+     */
+    workerController?: QueueWorkerControllerMetadata | null;
+}
+export type QueueWorkerModuleAsyncOptions = ModuleAsyncOptions<Omit<QueueWorkerModuleOptions, "workerController">> & Pick<QueueWorkerModuleOptions, "workerController">;
+export type QueueWorkerModuleOptionsFactory = ModuleOptionsFactory<Omit<QueueWorkerModuleOptions, "workerController">> & Pick<QueueWorkerModuleOptions, "workerController">;
+export type QueueWorkerProcessor = <T>(message: T, raw: QueueWorkerRawMessage) => Promise<void> | void;
+export interface QueueWorkerMetadata {
+    className: string;
+    instance: Injectable;
+    processors: QueueWorkerProcessorMetadata[];
+    name: QueueWorkerName;
+    priority: number;
+}
+export interface QueueWorkerProcessorMetadata extends QueueWorkerProcessDecoratorArgs {
+    workerName: QueueWorkerName;
+    processorName: string;
+    processor: QueueWorkerProcessor;
+}
+export type QueueWorkerExtraConfig = {
+    parseReviver?: (key: string, value: any) => any;
+};
+export interface QueueWorkerDecoratorArgs {
+    names: QueueWorkerName[];
+    /**
+     * Highest priority is 0, and lower the larger integer you use.
+     *
+     * @type {number}
+     * @memberof QueueWorkerDecoratorArgs
+     */
+    priority: number;
+    /**
+     * If you want to disable the worker, set it to false. Defaults to true.
+     */
+    enabled?: boolean;
+}
+export interface QueueWorkerProcessDecoratorArgs {
+    /**
+     * Highest priority is 0, and lower the larger integer you use.
+     *
+     * @type {number}
+     * @memberof QueueWorkerProcessDecoratorArgs
+     */
+    priority: number;
+    /**
+     * If you want to disable the process, set it to false. Defaults to true.
+     */
+    enabled?: boolean;
+}
+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;
+};
+export type QueueWorkerReceivedMessage = {
+    readonly message: QueueWorkerRawMessage;
+};
+export interface QueueWorkerControllerMetadata extends RequestMappingMetadata {
+    /**
+     * Default: 200
+     *
+     * @type {number}
+     * @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>;
+}
+export interface QueueWorkerOptions {
+    /**
+     * Worker name. If you want to define multiple names, use an array.
+     */
+    name: QueueWorkerName | QueueWorkerName[];
+    /**
+     * Highest priority is 0, and lower the larger integer you use.
+     */
+    priority?: number;
+    /**
+     * If you want to disable the worker, set it to false. Defaults to true.
+     */
+    enabled?: boolean;
+}
+export interface QueueWorkerProcessOptions {
+    /**
+     * Highest priority is 0, and lower the larger integer you use.
+     */
+    priority?: number;
+    /**
+     * If you want to disable the process, set it to false. Defaults to true.
+     */
+    enabled?: boolean;
+}
+export type QueueWorkerProcessResultBase<T = any> = {
+    workerName: QueueWorkerName;
+    processorName: string;
+    data?: T;
+    raw: QueueWorkerRawMessage<T>;
+};
+export type QueueWorkerProcessSuccessResult<T = any> = {
+    success: true;
+} & QueueWorkerProcessResultBase<T>;
+export type QueueWorkerProcessFailureResult<T = any> = {
+    success: false;
+    error: Error;
+} & QueueWorkerProcessResultBase<T>;
+export type QueueWorkerProcessResult<T = any> = QueueWorkerProcessSuccessResult<T> | QueueWorkerProcessFailureResult<T>;

package/dist/esm/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/util.d.ts

@@ -0,0 +1,33 @@
+import { Message } from "@anchan828/nest-cloud-run-queue-common";
+import { QueueWorkerDecodedMessage, QueueWorkerRawMessage } from "./interfaces";
+/**
+ * parse json string to javascript object.
+ * JSON.parse has receiver for Date.parse.
+ * @param json
+ */
+export declare const parseJSON: <T>(json: string, reviver?: (key: string, value: any) => any) => 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[];
+/**
+ * Check if a string is base64 encoded.
+ *
+ * @export
+ * @param {string} value
+ * @return {*}  {boolean}
+ */
+export declare function isBase64<T = any>(value?: string | null | Message<T>): value is string;
+export declare function decodeMessage<T = any>(message: QueueWorkerRawMessage<T> | Message, reviver?: (key: string, value: any) => any): QueueWorkerDecodedMessage<T>;
+export declare function isDecodedMessage<T = any>(message: QueueWorkerRawMessage<T> | QueueWorkerDecodedMessage<T> | Message<T>): message is QueueWorkerDecodedMessage<T>;
+export declare function isTaskMessage<T>(message?: QueueWorkerRawMessage<T> | Message<T> | null): message is Message<T> & {
+    headers?: Record<string, string>;
+};
+export declare function isMessage<T>(message?: QueueWorkerRawMessage<T> | Message<T> | null): message is Message<T>;

package/dist/esm/util.js

@@ -0,0 +1,136 @@
+import { BadRequestException } from "@nestjs/common";
+import { ERROR_INVALID_MESSAGE_FORMAT } from "./constants";
+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
+ */
+export const parseJSON = (json, reviver) => {
+    return JSON.parse(json, (key, value) => reviver ? reviver(key, parseDate(key, value)) : parseDate(key, value));
+};
+function parseDate(key, value) {
+    if (typeof value === "string" && value.length === 24 && dateRegExp.test(value)) {
+        const date = new Date(value);
+        if (+date === +date) {
+            return date;
+        }
+    }
+    return value;
+}
+/**
+ * sort array by priority prop
+ *
+ * @export
+ * @template T
+ * @param {T[]} items
+ * @returns {T[]}
+ */
+export function sortByPriority(items) {
+    return items.sort((x, y) => x.priority - y.priority);
+}
+const customBase64Strs = ["e30"];
+/**
+ * Check if a string is base64 encoded.
+ *
+ * @export
+ * @param {string} value
+ * @return {*}  {boolean}
+ */
+export function isBase64(value) {
+    if (!value) {
+        return false;
+    }
+    if (typeof value !== "string") {
+        return false;
+    }
+    const len = value.length;
+    if (len <= 4 && customBase64Strs.some((base64Str) => value.startsWith(base64Str))) {
+        return true;
+    }
+    if ((len === 4 && ![2, 3].every((n) => value[n] === "=")) || !len || len % 4 !== 0 || /[^A-Z0-9+/=]/i.test(value)) {
+        return false;
+    }
+    const firstPaddingChar = value.indexOf("=");
+    return (firstPaddingChar === -1 || firstPaddingChar === len - 1 || (firstPaddingChar === len - 2 && value[len - 1] === "="));
+}
+export function decodeMessage(message, reviver) {
+    let data;
+    if (isBase64(message.data)) {
+        // pubsub
+        data = decodeData(message.data, reviver);
+    }
+    else if (isTaskMessage(message)) {
+        // tasks
+        data = { data: JSON.parse(JSON.stringify(message.data), reviver), name: message.name };
+    }
+    else {
+        // http / raw
+        const _message = isMessage(message) ? message : isMessage(message.data) ? message.data : undefined;
+        if (!_message) {
+            throw new BadRequestException(ERROR_INVALID_MESSAGE_FORMAT);
+        }
+        data = _message;
+    }
+    if (!data) {
+        throw new BadRequestException(ERROR_INVALID_MESSAGE_FORMAT);
+    }
+    return {
+        data,
+        headers: "headers" in message ? message.headers : undefined,
+        id: getMessageId(message),
+        raw: message,
+    };
+}
+export function isDecodedMessage(message) {
+    return "raw" in message;
+}
+export function isTaskMessage(message) {
+    if (!message) {
+        return false;
+    }
+    const keys = Object.keys(message);
+    return keys.length <= 3 && keys.includes("name") && keys.includes("headers");
+}
+export function isMessage(message) {
+    if (!message) {
+        return false;
+    }
+    const keys = Object.keys(message);
+    return keys.length <= 3 && keys.includes("name");
+}
+function getMessageId(raw) {
+    if (!raw) {
+        return "";
+    }
+    if ("messageId" in raw) {
+        return raw.messageId ?? "";
+    }
+    if ("headers" in raw && raw.headers?.["x-cloudtasks-taskname"]) {
+        return raw.headers["x-cloudtasks-taskname"];
+    }
+    return "";
+}
+function decodeData(data, reviver) {
+    if (!data) {
+        throw new BadRequestException(ERROR_INVALID_MESSAGE_FORMAT);
+    }
+    if (Buffer.isBuffer(data)) {
+        data = data.toString();
+    }
+    if (data instanceof Uint8Array) {
+        data = new TextDecoder("utf8").decode(data);
+    }
+    if (isBase64(data)) {
+        data = Buffer.from(data, "base64").toString();
+    }
+    try {
+        if (typeof data === "string") {
+            return parseJSON(data, reviver);
+        }
+        return data;
+    }
+    catch {
+        throw new BadRequestException(ERROR_INVALID_MESSAGE_FORMAT);
+    }
+}

package/dist/esm/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/esm/worker.controller.js

@@ -0,0 +1,46 @@
+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); }
+};
+import { Body, Controller, Headers, HttpCode, RequestMapping, RequestMethod } from "@nestjs/common";
+import { QueueWorkerService } from "./worker.service";
+export function getWorkerController(metadata) {
+    const path = metadata?.path;
+    const method = metadata?.method || RequestMethod.POST;
+    const throwError = metadata?.throwError ?? true;
+    let WorkerController = class WorkerController {
+        constructor(service) {
+            this.service = service;
+        }
+        async execute(body, headers) {
+            const results = await this.service.execute({ ...body.message, headers });
+            for (const result of results) {
+                if (!result.success && throwError) {
+                    throw result.error;
+                }
+            }
+        }
+    };
+    __decorate([
+        RequestMapping({ method, path }),
+        HttpCode(metadata?.statusCode || 200),
+        __param(0, Body()),
+        __param(1, Headers()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Object]),
+        __metadata("design:returntype", Promise)
+    ], WorkerController.prototype, "execute", null);
+    WorkerController = __decorate([
+        Controller(),
+        __metadata("design:paramtypes", [QueueWorkerService])
+    ], WorkerController);
+    return WorkerController;
+}

package/dist/esm/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/esm/worker.js

@@ -0,0 +1,80 @@
+export 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));
+    }
+}
+export 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,
+        };
+    }
+}

package/dist/esm/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/esm/worker.module.js

@@ -0,0 +1,59 @@
+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;
+import { createAsyncProviders, createOptionProvider } from "@anchan828/nest-cloud-run-queue-common";
+import { Logger, Module } from "@nestjs/common";
+import { DiscoveryModule } from "@nestjs/core";
+import { MetadataScanner } from "@nestjs/core/metadata-scanner";
+import { QUEUE_WORKER_MODULE_OPTIONS } from "./constants";
+import { QueueWorkerExplorerService } from "./explorer.service";
+import { getWorkerController } from "./worker.controller";
+import { QueueWorkerService } from "./worker.service";
+let QueueWorkerModule = QueueWorkerModule_1 = class QueueWorkerModule {
+    static register(options = {}) {
+        const controllers = [];
+        const providers = [createOptionProvider(QUEUE_WORKER_MODULE_OPTIONS, options)];
+        if (options.workerController !== null) {
+            const WorkerController = getWorkerController(options.workerController);
+            controllers.push(WorkerController);
+        }
+        return {
+            controllers,
+            global: true,
+            module: QueueWorkerModule_1,
+            providers,
+        };
+    }
+    static registerAsync(options) {
+        const controllers = [];
+        const providers = [...createAsyncProviders(QUEUE_WORKER_MODULE_OPTIONS, options)];
+        if (options.workerController !== null) {
+            const WorkerController = getWorkerController(options.workerController);
+            controllers.push(WorkerController);
+        }
+        return {
+            controllers,
+            global: true,
+            imports: [...(options.imports || [])],
+            module: QueueWorkerModule_1,
+            providers,
+        };
+    }
+};
+QueueWorkerModule = QueueWorkerModule_1 = __decorate([
+    Module({
+        exports: [QueueWorkerService],
+        imports: [DiscoveryModule],
+        providers: [
+            MetadataScanner,
+            QueueWorkerExplorerService,
+            QueueWorkerService,
+            { provide: Logger, useValue: new Logger("QueueWorkerModule") },
+        ],
+    })
+], QueueWorkerModule);
+export { QueueWorkerModule };

package/dist/esm/worker.service.d.ts

@@ -0,0 +1,23 @@
+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 explorerService;
+    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>[]>;
+    /**
+     * 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.
+     */
+    getWorkers<T = any>(meessage: QueueWorkerRawMessage<T>): Worker<T>[];
+    getWorkers<T = any>(meessage: Message<T>): Worker<T>[];
+    getWorkers<T = any>(meessage: QueueWorkerDecodedMessage<T>): Worker<T>[];
+}

package/dist/esm/worker.service.js

@@ -0,0 +1,79 @@
+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 __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_instances, _QueueWorkerService__allWorkers, _QueueWorkerService_allWorkers_get;
+import { BadRequestException, Inject, Injectable } from "@nestjs/common";
+import { ERROR_QUEUE_WORKER_NAME_NOT_FOUND, ERROR_WORKER_NOT_FOUND, QUEUE_WORKER_MODULE_OPTIONS } from "./constants";
+import { QueueWorkerExplorerService } from "./explorer.service";
+import { decodeMessage, isDecodedMessage } from "./util";
+import { Worker } from "./worker";
+let QueueWorkerService = class QueueWorkerService {
+    constructor(options, explorerService) {
+        _QueueWorkerService_instances.add(this);
+        this.options = options;
+        this.explorerService = explorerService;
+        _QueueWorkerService__allWorkers.set(this, void 0);
+    }
+    async execute(meessage) {
+        const decodedMessage = isDecodedMessage(meessage)
+            ? meessage
+            : decodeMessage(meessage, this.options.extraConfig?.parseReviver);
+        if (this.options.throwModuleError && !decodedMessage.data.name) {
+            throw new BadRequestException(ERROR_QUEUE_WORKER_NAME_NOT_FOUND);
+        }
+        const workers = await this.getWorkers(decodedMessage);
+        if (this.options.throwModuleError && workers.length === 0) {
+            throw new BadRequestException(ERROR_WORKER_NOT_FOUND(decodedMessage.data.name));
+        }
+        const results = [];
+        for (const worker of workers) {
+            results.push(...(await worker.execute()));
+        }
+        return results;
+    }
+    getWorkers(meessage) {
+        const decodedMessage = isDecodedMessage(meessage)
+            ? meessage
+            : decodeMessage(meessage, this.options.extraConfig?.parseReviver);
+        if (!decodedMessage.data.name) {
+            return [];
+        }
+        return __classPrivateFieldGet(this, _QueueWorkerService_instances, "a", _QueueWorkerService_allWorkers_get)
+            .filter((worker) => decodedMessage.data.name === worker.name)
+            .map((metadata) => new Worker(decodedMessage, metadata, this.options));
+    }
+};
+_QueueWorkerService__allWorkers = new WeakMap();
+_QueueWorkerService_instances = new WeakSet();
+_QueueWorkerService_allWorkers_get = function _QueueWorkerService_allWorkers_get() {
+    if (!__classPrivateFieldGet(this, _QueueWorkerService__allWorkers, "f")) {
+        __classPrivateFieldSet(this, _QueueWorkerService__allWorkers, this.explorerService.explore(), "f");
+    }
+    return __classPrivateFieldGet(this, _QueueWorkerService__allWorkers, "f");
+};
+QueueWorkerService = __decorate([
+    Injectable(),
+    __param(0, Inject(QUEUE_WORKER_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, QueueWorkerExplorerService])
+], QueueWorkerService);
+export { QueueWorkerService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-cloud-run-queue-worker",
-  "version": "3.1.6",
+  "version": "3.1.8",
   "description": "> TODO: description",
   "homepage": "https://github.com/anchan828/nest-cloud-run-queue/tree/master/packages/worker#readme",
   "bugs": {
@@ -12,8 +12,8 @@
   },
   "license": "MIT",
   "author": "anchan828 <anchan828@gmail.com>",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
   "directories": {
     "dist": "dist"
   },
@@ -21,10 +21,10 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json",
     "build:watch": "tsc --watch",
     "copy:license": "cp ../../LICENSE ./",
-    "lint": "TIMING=1 eslint --ignore-path ../../.eslintignore '**/*.ts'",
+    "lint": "TIMING=1 eslint '**/*.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",
@@ -33,7 +33,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@anchan828/nest-cloud-run-queue-common": "^3.1.6"
+    "@anchan828/nest-cloud-run-queue-common": "^3.1.8"
   },
   "devDependencies": {
     "@nestjs/common": "10.3.10",
@@ -46,5 +46,19 @@
     "access": "public"
   },
   "packageManager": "npm@10.8.2",
-  "gitHead": "67c758aff5e7ea4fc721cbdfd908b95e08305810"
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "types": "./dist/cjs/index.d.ts",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "gitHead": "c6565dcca7c5ed619b5929f3342f55804b05519c"
 }