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

package/dist/explorer.service.js

@@ -38,6 +38,7 @@ let QueueWorkerExplorerService = class QueueWorkerExplorerService {
                 }
                 for (const name of args.names) {
                     metadata.push({
+                        className: classInstanceWrapper.metatype.name,
                         instance: classInstanceWrapper.instance,
                         name,
                         priority: args.priority || 0,
@@ -61,6 +62,8 @@ let QueueWorkerExplorerService = class QueueWorkerExplorerService {
                 metadata.push({
                     priority: args.priority || 0,
                     processor: prototype[methodName].bind(instance),
+                    processorName: `${worker.className}.${methodName}`,
+                    workerName: worker.name,
                 });
             }
         }

package/dist/index.d.ts

@@ -1,5 +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, QueueWorkerProcessOptions, QueueWorkerProcessor, QueueWorkerProcessorStatus, QueueWorkerRawMessage, QueueWorkerReceivedMessage, } from "./interfaces";
+export { QueueWorkerControllerInterface, QueueWorkerControllerMetadata, QueueWorkerDecodedMessage, QueueWorkerExtraConfig, QueueWorkerModuleAsyncOptions, QueueWorkerModuleOptions, QueueWorkerModuleOptionsFactory, QueueWorkerOptions, QueueWorkerProcessFailureResult, QueueWorkerProcessOptions, QueueWorkerProcessResult, QueueWorkerProcessSuccessResult, QueueWorkerProcessor, QueueWorkerProcessorStatus, QueueWorkerRawMessage, QueueWorkerReceivedMessage, } from "./interfaces";
+export { decodeMessage } from "./util";
 export { QueueWorkerModule } from "./worker.module";
 export { QueueWorkerService } from "./worker.service";

package/dist/index.js

@@ -1,6 +1,6 @@
 "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;
+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; } });
@@ -9,6 +9,8 @@ Object.defineProperty(exports, "QueueWorker", { enumerable: true, get: function
 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_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

@@ -36,12 +36,15 @@ export type QueueWorkerModuleAsyncOptions = ModuleAsyncOptions<Omit<QueueWorkerM
 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 declare enum QueueWorkerProcessorStatus {
@@ -51,24 +54,6 @@ export declare enum QueueWorkerProcessorStatus {
 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>;
-    /**
-     * Exceptions thrown in the processor do not reach the top level and are not detected by the application. If you want to do something with processor exceptions, use this property.
-     * @example
-     * ```ts
-     * catchProcessorException: (error: Error) => {
-     *   captureException(error); // Sentry
-     * }
-     * ```
-     *
-     * @example
-     * ```ts
-     * catchProcessorException: async (error: Error) => {
-     *  // You can throw errors and let them reach the top level. Use an ExceptionFilter or similar to handle them appropriately.
-     *  throw error;
-     * }
-     * ```
-     */
-    catchProcessorException?: <T extends Error = Error>(error: T, raw: QueueWorkerRawMessage) => void | Promise<void>;
 };
 export interface QueueWorkerDecoratorArgs {
     names: QueueWorkerName[];
@@ -145,3 +130,18 @@ export interface QueueWorkerProcessOptions {
      */
     enabled?: boolean;
 }
+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>;
+export {};

package/dist/worker.service.d.ts

@@ -1,21 +1,21 @@
 import { Logger } from "@nestjs/common";
 import { Message } from "@anchan828/nest-cloud-run-queue-common";
 import { QueueWorkerExplorerService } from "./explorer.service";
-import { QueueWorkerDecodedMessage, QueueWorkerModuleOptions, QueueWorkerRawMessage } from "./interfaces";
+import { QueueWorkerDecodedMessage, QueueWorkerModuleOptions, QueueWorkerProcessResult, 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<T = any>(meessage: Message<T>): Promise<void>;
-    execute<T = any>(meessage: QueueWorkerDecodedMessage<T>): Promise<void>;
-    execute<T = any>(meessage: QueueWorkerRawMessage<T>): Promise<void>;
+    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.
      */
     decodeMessage<T = any>(message: QueueWorkerRawMessage | Message): QueueWorkerDecodedMessage<T>;
     private runWorkers;
     private isDecodedMessage;
-    private execProcessor;
+    private executeProcessor;
 }

package/dist/worker.service.js

@@ -39,7 +39,7 @@ let QueueWorkerService = class QueueWorkerService {
         _QueueWorkerService__allWorkers.set(this, void 0);
     }
     async execute(meessage) {
-        await this.runWorkers(this.isDecodedMessage(meessage) ? meessage : (0, util_1.decodeMessage)(meessage));
+        return await this.runWorkers(this.isDecodedMessage(meessage) ? meessage : (0, util_1.decodeMessage)(meessage));
     }
     /**
      * @deprecated Use `decodeMessage` function instead.
@@ -60,31 +60,49 @@ let QueueWorkerService = class QueueWorkerService {
         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) {
-                await this.execProcessor(processor.processor, maxRetryAttempts, decodedMessage.data.data, decodedMessage.raw);
+                QueueWorkerProcessResults.push(await this.executeProcessor(processor, maxRetryAttempts, decodedMessage.data.data, decodedMessage.raw));
             }
             for (const processor of spetialProcessors) {
-                await this.execProcessor(processor.processor, maxRetryAttempts, decodedMessage.data, decodedMessage.raw);
+                await this.executeProcessor(processor, maxRetryAttempts, decodedMessage.data, decodedMessage.raw);
             }
         }
         await this.options.extraConfig?.postProcessor?.(decodedMessage.data.name, decodedMessage.data.data, decodedMessage.raw);
+        return QueueWorkerProcessResults;
     }
     isDecodedMessage(message) {
         return "raw" in message;
     }
-    async execProcessor(processor, maxRetryAttempts, data, raw) {
+    async executeProcessor(processorMetadata, maxRetryAttempts, data, raw) {
         for (let i = 0; i < maxRetryAttempts; i++) {
             try {
-                await processor(data, raw);
+                await processorMetadata.processor(data, raw);
                 i = maxRetryAttempts;
             }
             catch (error) {
                 this.logger.error(error.message);
-                await this.options.extraConfig?.catchProcessorException?.(error, raw);
+                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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchan828/nest-cloud-run-queue-worker",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "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.3.1"
+    "@anchan828/nest-cloud-run-queue-common": "^2.4.1"
   },
   "devDependencies": {
     "@nestjs/common": "10.3.10",
@@ -46,5 +46,5 @@
     "access": "public"
   },
   "packageManager": "npm@10.8.1",
-  "gitHead": "b6dedf4cb4eb303f706f1db38fe8f94d419a67c0"
+  "gitHead": "a129feb4af97620af2aeb55d7a89b39c710b0659"
 }