@message-queue-toolkit/core 10.1.1 → 12.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';
@@ -14,4 +14,12 @@ export type { MessageSchemaContainerOptions } from './lib/queues/MessageSchemaCo
 export { objectToBuffer } from './lib/utils/queueUtils';
 export { waitAndRetry } from './lib/utils/waitUtils';
 export { parseMessage } from './lib/utils/parseUtils';
+export { toDatePreprocessor } from './lib/utils/toDateProcessor';
 export { reloadConfig, isProduction } from './lib/utils/envUtils';
+export { DomainEventEmitter } from './lib/events/DomainEventEmitter';
+export { EventRegistry } from './lib/events/EventRegistry';
+export { FakeListener } from './lib/events/fakes/FakeListener';
+export * from './lib/events/eventTypes';
+export * from './lib/events/baseEventSchemas';
+export * from './lib/messages/baseMessageSchemas';
+export * from './lib/messages/MetadataFiller';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isProduction = exports.reloadConfig = exports.parseMessage = exports.waitAndRetry = exports.objectToBuffer = exports.MessageSchemaContainer = exports.HandlerSpy = exports.MessageHandlerConfigBuilder = exports.MessageHandlerConfig = exports.HandlerContainer = exports.DoNotProcessMessageError = exports.RetryMessageLaterError = exports.objectMatches = exports.isShallowSubset = exports.MessageInvalidFormatError = exports.MessageValidationError = exports.isMessageError = exports.AbstractQueueService = void 0;
+exports.FakeListener = exports.EventRegistry = exports.DomainEventEmitter = exports.isProduction = exports.reloadConfig = exports.toDatePreprocessor = exports.parseMessage = exports.waitAndRetry = exports.objectToBuffer = exports.MessageSchemaContainer = exports.HandlerSpy = exports.MessageHandlerConfigBuilder = exports.MessageHandlerConfig = exports.HandlerContainer = exports.DoNotProcessMessageError = exports.RetryMessageLaterError = exports.objectMatches = exports.isShallowSubset = exports.MessageInvalidFormatError = exports.MessageValidationError = exports.isMessageError = exports.AbstractQueueService = void 0;
 const tslib_1 = require("tslib");
 var AbstractQueueService_1 = require("./lib/queues/AbstractQueueService");
 Object.defineProperty(exports, "AbstractQueueService", { enumerable: true, get: function () { return AbstractQueueService_1.AbstractQueueService; } });
@@ -30,7 +30,19 @@ var waitUtils_1 = require("./lib/utils/waitUtils");
 Object.defineProperty(exports, "waitAndRetry", { enumerable: true, get: function () { return waitUtils_1.waitAndRetry; } });
 var parseUtils_1 = require("./lib/utils/parseUtils");
 Object.defineProperty(exports, "parseMessage", { enumerable: true, get: function () { return parseUtils_1.parseMessage; } });
+var toDateProcessor_1 = require("./lib/utils/toDateProcessor");
+Object.defineProperty(exports, "toDatePreprocessor", { enumerable: true, get: function () { return toDateProcessor_1.toDatePreprocessor; } });
 var envUtils_1 = require("./lib/utils/envUtils");
 Object.defineProperty(exports, "reloadConfig", { enumerable: true, get: function () { return envUtils_1.reloadConfig; } });
 Object.defineProperty(exports, "isProduction", { enumerable: true, get: function () { return envUtils_1.isProduction; } });
+var DomainEventEmitter_1 = require("./lib/events/DomainEventEmitter");
+Object.defineProperty(exports, "DomainEventEmitter", { enumerable: true, get: function () { return DomainEventEmitter_1.DomainEventEmitter; } });
+var EventRegistry_1 = require("./lib/events/EventRegistry");
+Object.defineProperty(exports, "EventRegistry", { enumerable: true, get: function () { return EventRegistry_1.EventRegistry; } });
+var FakeListener_1 = require("./lib/events/fakes/FakeListener");
+Object.defineProperty(exports, "FakeListener", { enumerable: true, get: function () { return FakeListener_1.FakeListener; } });
+tslib_1.__exportStar(require("./lib/events/eventTypes"), exports);
+tslib_1.__exportStar(require("./lib/events/baseEventSchemas"), exports);
+tslib_1.__exportStar(require("./lib/messages/baseMessageSchemas"), exports);
+tslib_1.__exportStar(require("./lib/messages/MetadataFiller"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;AAWA,0EAAsF;AAA7E,4HAAA,oBAAoB,OAAA;AAC7B,wEAA6C;AAE7C,8CAI4B;AAH1B,wGAAA,cAAc,OAAA;AACd,gHAAA,sBAAsB,OAAA;AACtB,mHAAA,yBAAyB,OAAA;AAG3B,qDAAuE;AAA9D,6GAAA,eAAe,OAAA;AAAE,2GAAA,aAAa,OAAA;AAEvC,8EAA4E;AAAnE,gIAAA,sBAAsB,OAAA;AAE/B,oEAAyE;AAAhE,6HAAA,wBAAwB,OAAA;AAEjC,kEAIsC;AAHpC,oHAAA,gBAAgB,OAAA;AAChB,wHAAA,oBAAoB,OAAA;AACpB,+HAAA,2BAA2B,OAAA;AAY7B,sDAAoD;AAA3C,wGAAA,UAAU,OAAA;AAGnB,8EAA4E;AAAnE,gIAAA,sBAAsB,OAAA;AAG/B,qDAAuD;AAA9C,4GAAA,cAAc,OAAA;AACvB,mDAAoD;AAA3C,yGAAA,YAAY,OAAA;AACrB,qDAAqD;AAA5C,0GAAA,YAAY,OAAA;AAErB,iDAAiE;AAAxD,wGAAA,YAAY,OAAA;AAAE,wGAAA,YAAY,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;AAWA,0EAAsF;AAA7E,4HAAA,oBAAoB,OAAA;AAC7B,wEAA6C;AAE7C,8CAI4B;AAH1B,wGAAA,cAAc,OAAA;AACd,gHAAA,sBAAsB,OAAA;AACtB,mHAAA,yBAAyB,OAAA;AAG3B,qDAAuE;AAA9D,6GAAA,eAAe,OAAA;AAAE,2GAAA,aAAa,OAAA;AAEvC,8EAA4E;AAAnE,gIAAA,sBAAsB,OAAA;AAE/B,oEAAyE;AAAhE,6HAAA,wBAAwB,OAAA;AAEjC,kEAIsC;AAHpC,oHAAA,gBAAgB,OAAA;AAChB,wHAAA,oBAAoB,OAAA;AACpB,+HAAA,2BAA2B,OAAA;AAY7B,sDAAoD;AAA3C,wGAAA,UAAU,OAAA;AAGnB,8EAA4E;AAAnE,gIAAA,sBAAsB,OAAA;AAG/B,qDAAuD;AAA9C,4GAAA,cAAc,OAAA;AACvB,mDAAoD;AAA3C,yGAAA,YAAY,OAAA;AACrB,qDAAqD;AAA5C,0GAAA,YAAY,OAAA;AACrB,+DAAgE;AAAvD,qHAAA,kBAAkB,OAAA;AAE3B,iDAAiE;AAAxD,wGAAA,YAAY,OAAA;AAAE,wGAAA,YAAY,OAAA;AAEnC,sEAAoE;AAA3D,wHAAA,kBAAkB,OAAA;AAC3B,4DAA0D;AAAjD,8GAAA,aAAa,OAAA;AACtB,gEAA8D;AAArD,4GAAA,YAAY,OAAA;AAErB,kEAAuC;AACvC,wEAA6C;AAC7C,4EAAiD;AAEjD,wEAA6C"}

package/dist/lib/events/DomainEventEmitter.d.ts

@@ -0,0 +1,24 @@
+import type { EventRegistry } from './EventRegistry';
+import type { AnyEventHandler, SingleEventHandler, CommonEventDefinition, CommonEventDefinitionSchemaType, EventTypeNames } from './eventTypes';
+export declare class DomainEventEmitter<SupportedEvents extends CommonEventDefinition[]> {
+    private readonly eventRegistry;
+    private readonly eventHandlerMap;
+    private readonly anyHandlers;
+    constructor({ eventRegistry }: {
+        eventRegistry: EventRegistry<SupportedEvents>;
+    });
+    emit<SupportedEvent extends SupportedEvents[number]>(supportedEvent: SupportedEvent, data: Omit<CommonEventDefinitionSchemaType<SupportedEvent>, 'type'>): Promise<void>;
+    /**
+     * Register handler for a specific event
+     */
+    on<EventTypeName extends EventTypeNames<SupportedEvents[number]>>(eventTypeName: EventTypeName, handler: SingleEventHandler<SupportedEvents, EventTypeName>): void;
+    /**
+     * Register handler for multiple events
+     */
+    onMany<EventTypeName extends EventTypeNames<SupportedEvents[number]>>(eventTypeNames: EventTypeName[], handler: SingleEventHandler<SupportedEvents, EventTypeName>): void;
+    /**
+     * Register handler for all events supported by the emitter
+     */
+    onAny(handler: AnyEventHandler<SupportedEvents>): void;
+    private addOnHandler;
+}

package/dist/lib/events/DomainEventEmitter.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEventEmitter = void 0;
+const node_core_1 = require("@lokalise/node-core");
+class DomainEventEmitter {
+    eventRegistry;
+    eventHandlerMap = {};
+    anyHandlers = [];
+    constructor({ eventRegistry }) {
+        this.eventRegistry = eventRegistry;
+    }
+    async emit(supportedEvent, data) {
+        const eventTypeName = supportedEvent.schema.shape.type.value;
+        if (!this.eventRegistry.isSupportedEvent(eventTypeName)) {
+            throw new node_core_1.InternalError({
+                errorCode: 'UNKNOWN_EVENT',
+                message: `Unknown event ${eventTypeName}`,
+            });
+        }
+        const eventHandlers = this.eventHandlerMap[eventTypeName];
+        // No relevant handlers are registered, we can stop processing
+        if (!eventHandlers && this.anyHandlers.length === 0) {
+            return;
+        }
+        const validatedEvent = this.eventRegistry
+            .getEventDefinitionByTypeName(eventTypeName)
+            .schema.parse({
+            type: eventTypeName,
+            ...data,
+        });
+        if (eventHandlers) {
+            for (const handler of eventHandlers) {
+                await handler.handleEvent(validatedEvent);
+            }
+        }
+        for (const handler of this.anyHandlers) {
+            await handler.handleEvent(validatedEvent);
+        }
+    }
+    /**
+     * Register handler for a specific event
+     */
+    on(eventTypeName, handler) {
+        this.addOnHandler(eventTypeName, handler);
+    }
+    /**
+     * Register handler for multiple events
+     */
+    onMany(eventTypeNames, handler) {
+        for (const eventTypeName of eventTypeNames) {
+            this.on(eventTypeName, handler);
+        }
+    }
+    /**
+     * Register handler for all events supported by the emitter
+     */
+    onAny(handler) {
+        this.anyHandlers.push(handler);
+    }
+    addOnHandler(eventTypeName, handler) {
+        if (!this.eventHandlerMap[eventTypeName]) {
+            this.eventHandlerMap[eventTypeName] = [];
+        }
+        this.eventHandlerMap[eventTypeName].push(handler);
+    }
+}
+exports.DomainEventEmitter = DomainEventEmitter;
+//# sourceMappingURL=DomainEventEmitter.js.map

package/dist/lib/events/DomainEventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomainEventEmitter.js","sourceRoot":"","sources":["../../../lib/events/DomainEventEmitter.ts"],"names":[],"mappings":";;;AAAA,mDAAmD;AAYnD,MAAa,kBAAkB;IACZ,aAAa,CAAgC;IAE7C,eAAe,GAG5B,EAAE,CAAA;IACW,WAAW,GAAuC,EAAE,CAAA;IAErE,YAAY,EAAE,aAAa,EAAqD;QAC9E,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;IACpC,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,cAA8B,EAC9B,IAAmE;QAEnE,MAAM,aAAa,GAAG,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAA;QAE5D,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,aAAa,CAAC,EAAE,CAAC;YACxD,MAAM,IAAI,yBAAa,CAAC;gBACtB,SAAS,EAAE,eAAe;gBAC1B,OAAO,EAAE,iBAAiB,aAAa,EAAE;aAC1C,CAAC,CAAA;QACJ,CAAC;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAA;QAEzD,8DAA8D;QAC9D,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpD,OAAM;QACR,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa;aACtC,4BAA4B,CAAC,aAAa,CAAC;aAC3C,MAAM,CAAC,KAAK,CAAC;YACZ,IAAI,EAAE,aAAa;YACnB,GAAG,IAAI;SACR,CAAC,CAAA;QAEJ,IAAI,aAAa,EAAE,CAAC;YAClB,KAAK,MAAM,OAAO,IAAI,aAAa,EAAE,CAAC;gBACpC,MAAM,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAA;YAC3C,CAAC;QACH,CAAC;QAED,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACvC,MAAM,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAA;QAC3C,CAAC;IACH,CAAC;IAED;;OAEG;IACI,EAAE,CACP,aAA4B,EAC5B,OAA2D;QAE3D,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,OAAO,CAAC,CAAA;IAC3C,CAAC;IAED;;OAEG;IACI,MAAM,CACX,cAA+B,EAC/B,OAA2D;QAE3D,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YAC3C,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE,OAAO,CAAC,CAAA;QACjC,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAyC;QACpD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAChC,CAAC;IAEO,YAAY,CAClB,aAAsD,EACtD,OAAqB;QAErB,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,GAAG,EAAE,CAAA;QAC1C,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACnD,CAAC;CACF;AA1FD,gDA0FC"}

package/dist/lib/events/EventRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { CommonEventDefinition, EventTypeNames } from './eventTypes';
+export declare class EventRegistry<SupportedEvents extends CommonEventDefinition[]> {
+    readonly supportedEvents: SupportedEvents;
+    private readonly supportedEventsSet;
+    private readonly supportedEventMap;
+    constructor(supportedEvents: SupportedEvents);
+    getEventDefinitionByTypeName: <EventTypeName extends EventTypeNames<SupportedEvents[number]>>(eventTypeName: EventTypeName) => CommonEventDefinition;
+    isSupportedEvent(eventTypeName: string): boolean;
+}

package/dist/lib/events/EventRegistry.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRegistry = void 0;
+class EventRegistry {
+    supportedEvents;
+    supportedEventsSet;
+    supportedEventMap = {};
+    constructor(supportedEvents) {
+        this.supportedEvents = supportedEvents;
+        this.supportedEventsSet = new Set();
+        for (const supportedEvent of supportedEvents) {
+            this.supportedEventMap[supportedEvent.schema.shape.type.value] = supportedEvent;
+            this.supportedEventsSet.add(supportedEvent.schema.shape.type.value);
+        }
+    }
+    getEventDefinitionByTypeName = (eventTypeName) => {
+        return this.supportedEventMap[eventTypeName];
+    };
+    isSupportedEvent(eventTypeName) {
+        return this.supportedEventsSet.has(eventTypeName);
+    }
+}
+exports.EventRegistry = EventRegistry;
+//# sourceMappingURL=EventRegistry.js.map

package/dist/lib/events/EventRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventRegistry.js","sourceRoot":"","sources":["../../../lib/events/EventRegistry.ts"],"names":[],"mappings":";;;AAEA,MAAa,aAAa;IACR,eAAe,CAAiB;IAC/B,kBAAkB,CAAa;IAC/B,iBAAiB,GAA0C,EAAE,CAAA;IAE9E,YAAY,eAAgC;QAC1C,IAAI,CAAC,eAAe,GAAG,eAAe,CAAA;QACtC,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAA;QAE3C,KAAK,MAAM,cAAc,IAAI,eAAe,EAAE,CAAC;YAC7C,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,cAAc,CAAA;YAC/E,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACrE,CAAC;IACH,CAAC;IAEM,4BAA4B,GAAG,CAGpC,aAA4B,EACL,EAAE;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAA;IAC9C,CAAC,CAAA;IAEM,gBAAgB,CAAC,aAAqB;QAC3C,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IACnD,CAAC;CACF;AA1BD,sCA0BC"}

package/dist/lib/events/baseEventSchemas.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const BASE_EVENT_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<string>;
+    payload: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    timestamp: string;
+    type: string;
+    payload?: {} | undefined;
+}, {
+    id: string;
+    timestamp: string;
+    type: string;
+    payload?: {} | undefined;
+}>;
+export type BaseEventType = z.infer<typeof BASE_EVENT_SCHEMA>;

package/dist/lib/events/baseEventSchemas.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_EVENT_SCHEMA = void 0;
+const zod_1 = require("zod");
+// Core fields that describe either internal event or external message
+exports.BASE_EVENT_SCHEMA = zod_1.z.object({
+    id: zod_1.z.string().describe('event unique identifier'),
+    timestamp: zod_1.z.string().datetime().describe('iso 8601 datetime'),
+    type: zod_1.z.literal('<replace.me>').describe('event type name'),
+    payload: zod_1.z.optional(zod_1.z.object({})).describe('event payload based on type'),
+});
+//# sourceMappingURL=baseEventSchemas.js.map

package/dist/lib/events/baseEventSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseEventSchemas.js","sourceRoot":"","sources":["../../../lib/events/baseEventSchemas.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AAEvB,sEAAsE;AACzD,QAAA,iBAAiB,GAAG,OAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;IAClD,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IAC9D,IAAI,EAAE,OAAC,CAAC,OAAO,CAAS,cAAc,CAAC,CAAC,QAAQ,CAAC,iBAAiB,CAAC;IACnE,OAAO,EAAE,OAAC,CAAC,QAAQ,CAAC,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,6BAA6B,CAAC;CAC1E,CAAC,CAAA"}

package/dist/lib/events/eventTypes.d.ts

@@ -0,0 +1,20 @@
+import type { ZodObject, ZodTypeAny } from 'zod';
+import type z from 'zod';
+import type { BASE_EVENT_SCHEMA } from './baseEventSchemas';
+export type EventTypeNames<EventDefinition extends CommonEventDefinition> = CommonEventDefinitionSchemaType<EventDefinition>['type'];
+export type CommonEventDefinition = {
+    schema: ZodObject<Omit<(typeof BASE_EVENT_SCHEMA)['shape'], 'payload'> & {
+        payload: ZodTypeAny;
+    }>;
+    schemaVersion?: string;
+};
+export type CommonEventDefinitionSchemaType<T extends CommonEventDefinition> = z.infer<T['schema']>;
+export type EventHandler<EventDefinitionSchema extends CommonEventDefinitionSchemaType<CommonEventDefinition> = CommonEventDefinitionSchemaType<CommonEventDefinition>> = {
+    handleEvent(event: EventDefinitionSchema): void | Promise<void>;
+};
+export type AnyEventHandler<EventDefinitions extends CommonEventDefinition[]> = EventHandler<CommonEventDefinitionSchemaType<EventDefinitions[number]>>;
+export type SingleEventHandler<EventDefinition extends CommonEventDefinition[], EventTypeName extends EventTypeNames<EventDefinition[number]>> = EventHandler<EventFromArrayByTypeName<EventDefinition, EventTypeName>>;
+type EventFromArrayByTypeName<EventDefinition extends CommonEventDefinition[], EventTypeName extends EventTypeNames<EventDefinition[number]>> = Extract<CommonEventDefinitionSchemaType<EventDefinition[number]>, {
+    type: EventTypeName;
+}>;
+export {};

package/dist/lib/events/eventTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=eventTypes.js.map

package/dist/lib/events/eventTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventTypes.js","sourceRoot":"","sources":["../../../lib/events/eventTypes.ts"],"names":[],"mappings":""}

package/dist/lib/events/fakes/FakeListener.d.ts

@@ -0,0 +1,6 @@
+import type { AnyEventHandler, CommonEventDefinition } from '../eventTypes';
+export declare class FakeListener<SupportedEvents extends CommonEventDefinition[]> implements AnyEventHandler<SupportedEvents> {
+    receivedEvents: SupportedEvents[number]['schema']['_output'][];
+    constructor(_supportedEvents: SupportedEvents);
+    handleEvent(event: SupportedEvents[number]['schema']['_output']): void | Promise<void>;
+}

package/dist/lib/events/fakes/FakeListener.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeListener = void 0;
+class FakeListener {
+    receivedEvents = [];
+    constructor(_supportedEvents) {
+        this.receivedEvents = [];
+    }
+    handleEvent(event) {
+        this.receivedEvents.push(event);
+    }
+}
+exports.FakeListener = FakeListener;
+//# sourceMappingURL=FakeListener.js.map

package/dist/lib/events/fakes/FakeListener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeListener.js","sourceRoot":"","sources":["../../../../lib/events/fakes/FakeListener.ts"],"names":[],"mappings":";;;AAEA,MAAa,YAAY;IAGhB,cAAc,GAAmD,EAAE,CAAA;IAE1E,YAAY,gBAAiC;QAC3C,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;IAC1B,CAAC;IAED,WAAW,CAAC,KAAmD;QAC7D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACjC,CAAC;CACF;AAZD,oCAYC"}

package/dist/lib/messages/MetadataFiller.d.ts

@@ -0,0 +1,25 @@
+import type { BaseEventType } from '../events/baseEventSchemas';
+import type { CommonEventDefinition } from '../events/eventTypes';
+import type { MessageMetadataType } from './baseMessageSchemas';
+export type IdGenerator = () => string;
+export type TimestampGenerator = () => string;
+export type MetadataFillerOptions = {
+    serviceId: string;
+    schemaVersion: string;
+    idGenerator?: IdGenerator;
+    timestampGenerator?: TimestampGenerator;
+    defaultVersion?: string;
+};
+export type MetadataFiller<T extends BaseEventType = BaseEventType, D = CommonEventDefinition, M = MessageMetadataType> = {
+    produceMetadata(currentMessage: T, eventDefinition: D, precedingMessageMetadata?: M): M;
+    produceId(): string;
+    produceTimestamp(): string;
+};
+export declare class CommonMetadataFiller implements MetadataFiller {
+    private readonly serviceId;
+    readonly produceId: IdGenerator;
+    readonly produceTimestamp: TimestampGenerator;
+    private readonly defaultVersion;
+    constructor(options: MetadataFillerOptions);
+    produceMetadata(_currentMessage: BaseEventType, eventDefinition: CommonEventDefinition, precedingMessageMetadata?: MessageMetadataType): MessageMetadataType;
+}

package/dist/lib/messages/MetadataFiller.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonMetadataFiller = void 0;
+const node_crypto_1 = require("node:crypto");
+class CommonMetadataFiller {
+    serviceId;
+    produceId;
+    produceTimestamp;
+    defaultVersion;
+    constructor(options) {
+        this.serviceId = options.serviceId;
+        this.defaultVersion = options.defaultVersion ?? '1.0.0';
+        this.produceId =
+            options.idGenerator ??
+                (() => {
+                    return (0, node_crypto_1.randomUUID)();
+                });
+        this.produceTimestamp =
+            options.timestampGenerator ??
+                (() => {
+                    return new Date().toISOString();
+                });
+    }
+    produceMetadata(_currentMessage, eventDefinition, precedingMessageMetadata) {
+        return {
+            producedBy: this.serviceId,
+            originatedFrom: precedingMessageMetadata?.originatedFrom ?? this.serviceId,
+            schemaVersion: eventDefinition.schemaVersion ?? this.defaultVersion,
+            correlationId: precedingMessageMetadata?.correlationId ?? this.produceId(),
+        };
+    }
+}
+exports.CommonMetadataFiller = CommonMetadataFiller;
+//# sourceMappingURL=MetadataFiller.js.map

package/dist/lib/messages/MetadataFiller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataFiller.js","sourceRoot":"","sources":["../../../lib/messages/MetadataFiller.ts"],"names":[],"mappings":";;;AAAA,6CAAwC;AA4BxC,MAAa,oBAAoB;IACd,SAAS,CAAQ;IAClB,SAAS,CAAa;IACtB,gBAAgB,CAAoB;IACnC,cAAc,CAAQ;IAEvC,YAAY,OAA8B;QACxC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAA;QAClC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,OAAO,CAAA;QACvD,IAAI,CAAC,SAAS;YACZ,OAAO,CAAC,WAAW;gBACnB,CAAC,GAAG,EAAE;oBACJ,OAAO,IAAA,wBAAU,GAAE,CAAA;gBACrB,CAAC,CAAC,CAAA;QACJ,IAAI,CAAC,gBAAgB;YACnB,OAAO,CAAC,kBAAkB;gBAC1B,CAAC,GAAG,EAAE;oBACJ,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;gBACjC,CAAC,CAAC,CAAA;IACN,CAAC;IAED,eAAe,CACb,eAA8B,EAC9B,eAAsC,EACtC,wBAA8C;QAE9C,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,SAAS;YAC1B,cAAc,EAAE,wBAAwB,EAAE,cAAc,IAAI,IAAI,CAAC,SAAS;YAC1E,aAAa,EAAE,eAAe,CAAC,aAAa,IAAI,IAAI,CAAC,cAAc;YACnE,aAAa,EAAE,wBAAwB,EAAE,aAAa,IAAI,IAAI,CAAC,SAAS,EAAE;SAC3E,CAAA;IACH,CAAC;CACF;AAjCD,oDAiCC"}

package/dist/lib/messages/baseMessageSchemas.d.ts

@@ -0,0 +1,64 @@
+import z from 'zod';
+export declare const MESSAGE_METADATA_SCHEMA: z.ZodObject<{
+    schemaVersion: z.ZodString;
+    producedBy: z.ZodString;
+    originatedFrom: z.ZodString;
+    correlationId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: string;
+    producedBy: string;
+    originatedFrom: string;
+    correlationId: string;
+}, {
+    schemaVersion: string;
+    producedBy: string;
+    originatedFrom: string;
+    correlationId: string;
+}>;
+export declare const BASE_MESSAGE_SCHEMA: z.ZodObject<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<string>;
+    payload: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+}, {
+    metadata: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodString;
+        producedBy: z.ZodString;
+        originatedFrom: z.ZodString;
+        correlationId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        schemaVersion: string;
+        producedBy: string;
+        originatedFrom: string;
+        correlationId: string;
+    }, {
+        schemaVersion: string;
+        producedBy: string;
+        originatedFrom: string;
+        correlationId: string;
+    }>>;
+}>, "strip", z.ZodTypeAny, {
+    id: string;
+    timestamp: string;
+    type: string;
+    payload?: {} | undefined;
+    metadata?: {
+        schemaVersion: string;
+        producedBy: string;
+        originatedFrom: string;
+        correlationId: string;
+    } | undefined;
+}, {
+    id: string;
+    timestamp: string;
+    type: string;
+    payload?: {} | undefined;
+    metadata?: {
+        schemaVersion: string;
+        producedBy: string;
+        originatedFrom: string;
+        correlationId: string;
+    } | undefined;
+}>;
+export type BaseMessageType = z.infer<typeof BASE_MESSAGE_SCHEMA>;
+export type MessageMetadataType = z.infer<typeof MESSAGE_METADATA_SCHEMA>;

package/dist/lib/messages/baseMessageSchemas.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_MESSAGE_SCHEMA = exports.MESSAGE_METADATA_SCHEMA = void 0;
+const tslib_1 = require("tslib");
+const zod_1 = tslib_1.__importDefault(require("zod"));
+const baseEventSchemas_1 = require("../events/baseEventSchemas");
+// External message metadata that describe the context in which the message was created, primarily used for debugging purposes
+exports.MESSAGE_METADATA_SCHEMA = zod_1.default
+    .object({
+    schemaVersion: zod_1.default.string().min(1).describe('message schema version'),
+    // this is always set to a service that created the message
+    producedBy: zod_1.default.string().min(1).describe('app/service that produced the message'),
+    // this is always propagated within the message chain. For the first message in the chain it is equal to "producedBy"
+    originatedFrom: zod_1.default
+        .string()
+        .min(1)
+        .describe('app/service that initiated entire workflow that led to creating this message'),
+    // this is always propagated within the message chain.
+    correlationId: zod_1.default.string().describe('unique identifier passed to all events in workflow chain'),
+})
+    .describe('external message metadata');
+exports.BASE_MESSAGE_SCHEMA = baseEventSchemas_1.BASE_EVENT_SCHEMA.extend({
+    // For internal domain events that did not originate within a message chain metadata field can be omitted, producer should then assume it is initiating a new chain
+    metadata: exports.MESSAGE_METADATA_SCHEMA.optional(),
+});
+//# sourceMappingURL=baseMessageSchemas.js.map

package/dist/lib/messages/baseMessageSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseMessageSchemas.js","sourceRoot":"","sources":["../../../lib/messages/baseMessageSchemas.ts"],"names":[],"mappings":";;;;AAAA,sDAAmB;AAEnB,iEAA8D;AAE9D,8HAA8H;AACjH,QAAA,uBAAuB,GAAG,aAAC;KACrC,MAAM,CAAC;IACN,aAAa,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,wBAAwB,CAAC;IACnE,2DAA2D;IAC3D,UAAU,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,uCAAuC,CAAC;IAC/E,qHAAqH;IACrH,cAAc,EAAE,aAAC;SACd,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CAAC,8EAA8E,CAAC;IAC3F,sDAAsD;IACtD,aAAa,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0DAA0D,CAAC;CAC/F,CAAC;KACD,QAAQ,CAAC,2BAA2B,CAAC,CAAA;AAE3B,QAAA,mBAAmB,GAAG,oCAAiB,CAAC,MAAM,CAAC;IAC1D,mKAAmK;IACnK,QAAQ,EAAE,+BAAuB,CAAC,QAAQ,EAAE;CAC7C,CAAC,CAAA"}

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/MessageQueueTypes.d.ts

@@ -1,3 +1,4 @@
+import type { TransactionObservabilityManager } from '@lokalise/node-core';
 import type { ZodSchema } from 'zod';
 export interface QueueConsumer {
     start(): Promise<unknown>;
@@ -10,10 +11,7 @@ export interface SyncPublisher<MessagePayloadType> {
 export interface AsyncPublisher<MessagePayloadType, MessageOptions> {
     publish(message: MessagePayloadType, options: MessageOptions): Promise<unknown>;
 }
-export type TransactionObservabilityManager = {
-    start: (transactionSpanId: string) => unknown;
-    stop: (transactionSpanId: string) => unknown;
-};
+export { TransactionObservabilityManager };
 export type LogFn = {
     <T extends object>(obj: T, msg?: string, ...args: any[]): void;
     (obj: unknown, msg?: string, ...args: any[]): void;

package/dist/lib/utils/toDateProcessor.d.ts

@@ -0,0 +1 @@
+export declare const toDatePreprocessor: (value: unknown) => unknown;

package/dist/lib/utils/toDateProcessor.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDatePreprocessor = void 0;
+const toDatePreprocessor = (value) => {
+    switch (typeof value) {
+        case 'string':
+        case 'number':
+            return new Date(value);
+        default:
+            return value; // could not coerce, return the original and face the consequences during validation
+    }
+};
+exports.toDatePreprocessor = toDatePreprocessor;
+//# sourceMappingURL=toDateProcessor.js.map

package/dist/lib/utils/toDateProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toDateProcessor.js","sourceRoot":"","sources":["../../../lib/utils/toDateProcessor.ts"],"names":[],"mappings":";;;AAAO,MAAM,kBAAkB,GAAG,CAAC,KAAc,EAAE,EAAE;IACnD,QAAQ,OAAO,KAAK,EAAE,CAAC;QACrB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,CAAA;QAExB;YACE,OAAO,KAAK,CAAA,CAAC,oFAAoF;IACrG,CAAC;AACH,CAAC,CAAA;AATY,QAAA,kBAAkB,sBAS9B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@message-queue-toolkit/core",
-  "version": "10.1.1",
+  "version": "12.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,23 @@
     "prepublishOnly": "npm run build:release"
   },
   "dependencies": {
-    "@lokalise/node-core": "^9.10.1",
+    "@lokalise/node-core": "^9.17.0",
     "fast-equals": "^5.0.1",
-    "toad-cache": "^3.7.0"
+    "toad-cache": "^3.7.0",
+    "zod": "^3.23.6"
   },
   "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",
+    "@types/node": "^20.12.8",
+    "@typescript-eslint/eslint-plugin": "^7.7.1",
+    "@typescript-eslint/parser": "^7.7.1",
+    "@vitest/coverage-v8": "^1.6.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.6.0"
   },
   "homepage": "https://github.com/kibertoad/message-queue-toolkit",
   "repository": {