@message-queue-toolkit/core 10.1.0 → 11.0.0

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { isShallowSubset, objectMatches } from './lib/utils/matchUtils';
 export { RetryMessageLaterError } from './lib/errors/RetryMessageLaterError';
 export { DoNotProcessMessageError } from './lib/errors/DoNotProcessError';
 export { HandlerContainer, MessageHandlerConfig, MessageHandlerConfigBuilder, } from './lib/queues/HandlerContainer';
-export type { BarrierCallback, BarrierResult, BarrierResultPositive, BarrierResultNegative, HandlerContainerOptions, Handler, Prehandler, PrehandlingOutputs, } from './lib/queues/HandlerContainer';
+export type { BarrierCallback, BarrierResult, BarrierResultPositive, BarrierResultNegative, HandlerContainerOptions, Handler, Prehandler, PreHandlingOutputs, } from './lib/queues/HandlerContainer';
 export { HandlerSpy } from './lib/queues/HandlerSpy';
 export type { SpyResult, HandlerSpyParams, PublicHandlerSpy } from './lib/queues/HandlerSpy';
 export { MessageSchemaContainer } from './lib/queues/MessageSchemaContainer';

package/dist/lib/queues/AbstractQueueService.d.ts

@@ -3,7 +3,7 @@ import type { ZodSchema, ZodType } from 'zod';
 import type { MessageInvalidFormatError, MessageValidationError } from '../errors/Errors';
 import type { Logger, MessageProcessingResult } from '../types/MessageQueueTypes';
 import type { DeletionConfig, QueueDependencies, QueueOptions } from '../types/queueOptionsTypes';
-import type { BarrierCallback, BarrierResult, Prehandler, PrehandlerResult, PrehandlingOutputs } from './HandlerContainer';
+import type { BarrierCallback, BarrierResult, Prehandler, PrehandlerResult, PreHandlingOutputs } from './HandlerContainer';
 import type { HandlerSpy, PublicHandlerSpy } from './HandlerSpy';
 export type Deserializer<MessagePayloadType extends object> = (message: unknown, type: ZodType<MessagePayloadType>, errorProcessor: ErrorResolver) => Either<MessageInvalidFormatError | MessageValidationError, MessagePayloadType>;
 type CommonQueueLocator = {
@@ -34,13 +34,13 @@ export declare abstract class AbstractQueueService<MessagePayloadSchemas extends
     protected logProcessedMessage(_message: MessagePayloadSchemas | null, processingResult: MessageProcessingResult, messageId?: string): void;
     protected handleError(err: unknown, context?: Record<string, unknown>): void;
     protected handleMessageProcessed(message: MessagePayloadSchemas | null, processingResult: MessageProcessingResult, messageId?: string): void;
-    protected processPrehandlersInternal(prehandlers: Prehandler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[], message: MessagePayloadSchemas): Promise<PrehandlerOutput>;
-    protected preHandlerBarrierInternal<BarrierOutput>(barrier: BarrierCallback<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput, BarrierOutput> | undefined, message: MessagePayloadSchemas, executionContext: ExecutionContext, prehandlerOutput: PrehandlerOutput): Promise<BarrierResult<BarrierOutput>>;
-    protected abstract resolveNextFunction(prehandlers: Prehandler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[], message: MessagePayloadSchemas, index: number, prehandlerOutput: PrehandlerOutput, resolve: (value: PrehandlerOutput | PromiseLike<PrehandlerOutput>) => void, reject: (err: Error) => void): (prehandlerResult: PrehandlerResult) => void;
-    protected resolveNextPreHandlerFunctionInternal(prehandlers: Prehandler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[], executionContext: ExecutionContext, message: MessagePayloadSchemas, index: number, prehandlerOutput: PrehandlerOutput, resolve: (value: PrehandlerOutput | PromiseLike<PrehandlerOutput>) => void, reject: (err: Error) => void): (prehandlerResult: PrehandlerResult) => void;
+    protected processPrehandlersInternal(preHandlers: Prehandler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[], message: MessagePayloadSchemas): Promise<PrehandlerOutput>;
+    protected preHandlerBarrierInternal<BarrierOutput>(barrier: BarrierCallback<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput, BarrierOutput> | undefined, message: MessagePayloadSchemas, executionContext: ExecutionContext, preHandlerOutput: PrehandlerOutput): Promise<BarrierResult<BarrierOutput>>;
+    protected abstract resolveNextFunction(preHandlers: Prehandler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[], message: MessagePayloadSchemas, index: number, preHandlerOutput: PrehandlerOutput, resolve: (value: PrehandlerOutput | PromiseLike<PrehandlerOutput>) => void, reject: (err: Error) => void): (preHandlerResult: PrehandlerResult) => void;
+    protected resolveNextPreHandlerFunctionInternal(preHandlers: Prehandler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[], executionContext: ExecutionContext, message: MessagePayloadSchemas, index: number, preHandlerOutput: PrehandlerOutput, resolve: (value: PrehandlerOutput | PromiseLike<PrehandlerOutput>) => void, reject: (err: Error) => void): (preHandlerResult: PrehandlerResult) => void;
     protected abstract processPrehandlers(message: MessagePayloadSchemas, messageType: string): Promise<PrehandlerOutput>;
-    protected abstract preHandlerBarrier<BarrierOutput>(message: MessagePayloadSchemas, messageType: string, prehandlerOutput: PrehandlerOutput): Promise<BarrierResult<BarrierOutput>>;
-    protected abstract processMessage(message: MessagePayloadSchemas, messageType: string, prehandlingOutputs: PrehandlingOutputs<PrehandlerOutput, any>): Promise<Either<'retryLater', 'success'>>;
+    protected abstract preHandlerBarrier<BarrierOutput>(message: MessagePayloadSchemas, messageType: string, preHandlerOutput: PrehandlerOutput): Promise<BarrierResult<BarrierOutput>>;
+    protected abstract processMessage(message: MessagePayloadSchemas, messageType: string, preHandlingOutputs: PreHandlingOutputs<PrehandlerOutput, any>): Promise<Either<'retryLater', 'success'>>;
     abstract close(): Promise<unknown>;
 }
 export {};

package/dist/lib/queues/AbstractQueueService.js

@@ -77,14 +77,14 @@ class AbstractQueueService {
             this.logProcessedMessage(message, processingResult, resolvedMessageId);
         }
     }
-    processPrehandlersInternal(prehandlers, message) {
-        if (prehandlers.length === 0) {
+    processPrehandlersInternal(preHandlers, message) {
+        if (preHandlers.length === 0) {
             return Promise.resolve({});
         }
         return new Promise((resolve, reject) => {
             try {
-                const prehandlerOutput = {};
-                const next = this.resolveNextFunction(prehandlers, message, 0, prehandlerOutput, resolve, reject);
+                const preHandlerOutput = {};
+                const next = this.resolveNextFunction(preHandlers, message, 0, preHandlerOutput, resolve, reject);
                 next({ result: 'success' });
             }
             catch (err) {
@@ -92,7 +92,7 @@ class AbstractQueueService {
             }
         });
     }
-    async preHandlerBarrierInternal(barrier, message, executionContext, prehandlerOutput) {
+    async preHandlerBarrierInternal(barrier, message, executionContext, preHandlerOutput) {
         if (!barrier) {
             // @ts-ignore
             return {
@@ -101,22 +101,22 @@ class AbstractQueueService {
             };
         }
         // @ts-ignore
-        return await barrier(message, executionContext, prehandlerOutput);
+        return await barrier(message, executionContext, preHandlerOutput);
     }
     // eslint-disable-next-line max-params
-    resolveNextPreHandlerFunctionInternal(prehandlers, executionContext, message, index, prehandlerOutput, resolve, reject) {
-        return (prehandlerResult) => {
-            if (prehandlerResult.error) {
-                reject(prehandlerResult.error);
+    resolveNextPreHandlerFunctionInternal(preHandlers, executionContext, message, index, preHandlerOutput, resolve, reject) {
+        return (preHandlerResult) => {
+            if (preHandlerResult.error) {
+                reject(preHandlerResult.error);
             }
-            if (prehandlers.length < index + 1) {
-                resolve(prehandlerOutput);
+            if (preHandlers.length < index + 1) {
+                resolve(preHandlerOutput);
             }
             else {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-                prehandlers[index](message, executionContext, 
+                preHandlers[index](message, executionContext, 
                 // @ts-ignore
-                prehandlerOutput, this.resolveNextPreHandlerFunctionInternal(prehandlers, executionContext, message, index + 1, prehandlerOutput, resolve, reject));
+                preHandlerOutput, this.resolveNextPreHandlerFunctionInternal(preHandlers, executionContext, message, index + 1, preHandlerOutput, resolve, reject));
             }
         };
     }

package/dist/lib/queues/HandlerContainer.d.ts

@@ -2,8 +2,8 @@ import type { Either } from '@lokalise/node-core';
 import type { ZodSchema } from 'zod';
 import type { DoNotProcessMessageError } from '../errors/DoNotProcessError';
 import type { RetryMessageLaterError } from '../errors/RetryMessageLaterError';
-export type PrehandlingOutputs<PrehandlerOutput = undefined, BarrierOutput = undefined> = {
-    prehandlerOutput: PrehandlerOutput;
+export type PreHandlingOutputs<PrehandlerOutput = undefined, BarrierOutput = undefined> = {
+    preHandlerOutput: PrehandlerOutput;
     barrierOutput: BarrierOutput;
 };
 export type LogFormatter<MessagePayloadSchema> = (message: MessagePayloadSchema) => unknown;
@@ -17,20 +17,20 @@ export type BarrierResultNegative = {
     output?: never;
 };
 export type PrehandlerResult = Either<DoNotProcessMessageError | RetryMessageLaterError, 'success'>;
-export type BarrierCallback<MessagePayloadSchema extends object, ExecutionContext, PrehandlerOutput, BarrierOutput> = (message: MessagePayloadSchema, context: ExecutionContext, prehandlerOutput: PrehandlerOutput) => Promise<BarrierResult<BarrierOutput>>;
-export type Prehandler<MessagePayloadSchema extends object, ExecutionContext, PrehandlerOutput> = (message: MessagePayloadSchema, context: ExecutionContext, prehandlerOutput: Partial<PrehandlerOutput>, next: (result: PrehandlerResult) => void) => void;
+export type BarrierCallback<MessagePayloadSchema extends object, ExecutionContext, PrehandlerOutput, BarrierOutput> = (message: MessagePayloadSchema, context: ExecutionContext, preHandlerOutput: PrehandlerOutput) => Promise<BarrierResult<BarrierOutput>>;
+export type Prehandler<MessagePayloadSchema extends object, ExecutionContext, PrehandlerOutput> = (message: MessagePayloadSchema, context: ExecutionContext, preHandlerOutput: Partial<PrehandlerOutput>, next: (result: PrehandlerResult) => void) => void;
 export declare const defaultLogFormatter: <MessagePayloadSchema>(message: MessagePayloadSchema) => MessagePayloadSchema;
 export type HandlerConfigOptions<MessagePayloadSchema extends object, ExecutionContext, PrehandlerOutput, BarrierOutput> = {
     messageLogFormatter?: LogFormatter<MessagePayloadSchema>;
     preHandlerBarrier?: BarrierCallback<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>;
-    prehandlers?: Prehandler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput>[];
+    preHandlers?: Prehandler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput>[];
 };
 export declare class MessageHandlerConfig<const MessagePayloadSchema extends object, const ExecutionContext, const PrehandlerOutput = undefined, const BarrierOutput = unknown> {
     readonly schema: ZodSchema<MessagePayloadSchema>;
     readonly handler: Handler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>;
     readonly messageLogFormatter: LogFormatter<MessagePayloadSchema>;
     readonly preHandlerBarrier?: BarrierCallback<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>;
-    readonly prehandlers: Prehandler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput>[];
+    readonly preHandlers: Prehandler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput>[];
     constructor(schema: ZodSchema<MessagePayloadSchema>, handler: Handler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>, options?: HandlerConfigOptions<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>);
 }
 export declare class MessageHandlerConfigBuilder<MessagePayloadSchemas extends object, ExecutionContext, PrehandlerOutput = undefined> {
@@ -39,7 +39,7 @@ export declare class MessageHandlerConfigBuilder<MessagePayloadSchemas extends o
     addConfig<MessagePayloadSchema extends MessagePayloadSchemas, const BarrierOutput>(schema: ZodSchema<MessagePayloadSchema>, handler: Handler<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>, options?: HandlerConfigOptions<MessagePayloadSchema, ExecutionContext, PrehandlerOutput, BarrierOutput>): this;
     build(): MessageHandlerConfig<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput, any>[];
 }
-export type Handler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput = undefined, BarrierOutput = undefined> = (message: MessagePayloadSchemas, context: ExecutionContext, prehandlingOutputs: PrehandlingOutputs<PrehandlerOutput, BarrierOutput>) => Promise<Either<'retryLater', 'success'>>;
+export type Handler<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput = undefined, BarrierOutput = undefined> = (message: MessagePayloadSchemas, context: ExecutionContext, preHandlingOutputs: PreHandlingOutputs<PrehandlerOutput, BarrierOutput>) => Promise<Either<'retryLater', 'success'>>;
 export type HandlerContainerOptions<MessagePayloadSchemas extends object, ExecutionContext, PrehandlerOutput = undefined> = {
     messageHandlers: MessageHandlerConfig<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[];
     messageTypeField: string;

package/dist/lib/queues/HandlerContainer.js

@@ -8,13 +8,13 @@ class MessageHandlerConfig {
     handler;
     messageLogFormatter;
     preHandlerBarrier;
-    prehandlers;
+    preHandlers;
     constructor(schema, handler, options) {
         this.schema = schema;
         this.handler = handler;
         this.messageLogFormatter = options?.messageLogFormatter ?? exports.defaultLogFormatter;
         this.preHandlerBarrier = options?.preHandlerBarrier;
-        this.prehandlers = options?.prehandlers ?? [];
+        this.preHandlers = options?.preHandlers ?? [];
     }
 }
 exports.MessageHandlerConfig = MessageHandlerConfig;

package/dist/lib/types/queueOptionsTypes.d.ts

@@ -41,8 +41,8 @@ export type QueuePublisherOptions<CreationConfigType extends CommonCreationConfi
 export type DeadLetterQueueOptions<CreationConfigType extends object, QueueLocatorType extends object, DeadLetterQueueIntegrationOptions extends object> = {
     deletionConfig?: DeletionConfig;
 } & DeadLetterQueueIntegrationOptions & (NewQueueOptions<CreationConfigType> | ExistingQueueOptions<QueueLocatorType>);
-export type QueueConsumerOptions<CreationConfigType extends object, QueueLocatorType extends object, DeadLetterQueueIntegrationOptions extends object, MessagePayloadSchemas extends object, ExecutionContext, PrehandlerOutput = undefined> = QueueOptions<CreationConfigType, QueueLocatorType> & {
+export type QueueConsumerOptions<CreationConfigType extends object, QueueLocatorType extends object, DeadLetterQueueIntegrationOptions extends object, MessagePayloadSchemas extends object, ExecutionContext, PrehandlerOutput = undefined, DeadLetterQueueCreationConfigType extends object = CreationConfigType, DeadLetterQueueQueueLocatorType extends object = QueueLocatorType> = QueueOptions<CreationConfigType, QueueLocatorType> & {
     handlers: MessageHandlerConfig<MessagePayloadSchemas, ExecutionContext, PrehandlerOutput>[];
-    deadLetterQueue?: DeadLetterQueueOptions<CreationConfigType, QueueLocatorType, DeadLetterQueueIntegrationOptions>;
+    deadLetterQueue?: DeadLetterQueueOptions<DeadLetterQueueCreationConfigType, DeadLetterQueueQueueLocatorType, DeadLetterQueueIntegrationOptions>;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@message-queue-toolkit/core",
-  "version": "10.1.0",
+  "version": "11.0.0",
   "private": false,
   "license": "MIT",
   "description": "Useful utilities, interfaces and base classes for message queue handling. Supports AMQP and SQS with a common abstraction on top currently",
@@ -25,23 +25,22 @@
     "prepublishOnly": "npm run build:release"
   },
   "dependencies": {
-    "@lokalise/node-core": "^9.10.1",
+    "@lokalise/node-core": "^9.14.0",
     "fast-equals": "^5.0.1",
     "toad-cache": "^3.7.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.25",
-    "@typescript-eslint/eslint-plugin": "^7.1.1",
-    "@typescript-eslint/parser": "^7.1.1",
-    "@vitest/coverage-v8": "^1.4.0",
+    "@typescript-eslint/eslint-plugin": "^7.7.1",
+    "@typescript-eslint/parser": "^7.7.1",
+    "@vitest/coverage-v8": "^1.5.0",
     "del-cli": "^5.1.0",
     "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-vitest": "0.4.1",
     "prettier": "^3.2.5",
-    "typescript": "^5.4.2",
-    "vitest": "^1.4.0"
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.0"
   },
   "homepage": "https://github.com/kibertoad/message-queue-toolkit",
   "repository": {