@palmetto/pubsub 1.0.0

package/README.md

@@ -0,0 +1,154 @@
+# @palmetto/pubsub
+
+Provides a standard mechanism to publish and subscribe to events using a zod v4 schema. The schema is used to validate that the message published or subscribed is valid.
+
+Messages pub/sub is done using JSON strings. The JSON strings are converted into the type using the schema. JSON strings that fail the schema parsing are rejected.
+
+Subscribers must return one of 3 results from MessageResult:
+
+- Ok - the message was processed successfully
+- Retry - the message should be retried.
+- Fail - the message processing failed and can be discarded [or dead-lettered, depending on the queue implementation]
+
+It is up to the pub/sub implementations what to do with rejected messages. Options include:
+
+- Dead letter queue
+- Log an error
+- Retry the message
+
+## Installation
+
+```sh
+yarn add @palmetto/pubsub zod
+```
+
+## Usage
+
+1. Create a publisher and send a message
+
+   ```ts
+   import { z as z4 } from "zod/v4";
+   import { IdMetaSchema, Publisher, RabbitMqPublisher, RabbitQueueExchangeConfiguration } from "@palmetto/pubsub";
+
+   const rabbitMqPublisher = new RabbitMqPublisher(...);
+
+   const schema = IdMetaSchema.extend({
+     message: z4.string(),
+   });
+
+   const Model = z.infer<typeof schema>;
+
+   const schemaConfig: RabbitQueueExchangeConfiguration = {
+     name: "TestModel",
+     schema: TestModelSchema,
+     transport: RABBITMQ_TRANSPORT,
+     type: "direct",
+   };
+
+   const publisher = new Publisher(console, [rabbitMqPublisher]);
+
+   const message: Model = {
+     id: undefined,
+     meta: undefined,
+     message: "Hello, world!",
+   };
+
+   await publisher.publish(schemaConfig, message);
+   ```
+
+1. Create subscriber and subscriber to a message
+
+   ```ts
+   import { z as z4 } from "zod/v4";
+   import { BaseMessage, IdMetaSchema, MessageResult, Subscriber, RabbitMqSubscriber } from "@palmetto/pubsub";
+
+   const rabbitMqSubscriber = new RabbitMqSubscriber(...);
+
+   const schema = IdMetaSchema.extend({
+     message: z4.string(),
+     code: z4.string(),
+   });
+
+   const Model = z.infer<typeof schema>;
+
+   const schemaConfig: RabbitQueueExchangeConfiguration = {
+     name: "TestModel",
+     schema: TestModelSchema,
+     retryDelay: 1_000,
+     retries: 20,
+     transport: RABBITMQ_TRANSPORT,
+     type: "direct",
+   };
+
+   function onMessage(message: Model) {
+     console.log(message.message);
+     const success = ...;
+
+     return success ? MessageResult.Ok : MessageResult.Retry;
+   };
+
+   const subscriber = new Subscriber(console, [rabbitMqSubscriber]);
+
+   await subscriber.startSubscribe(schemaConfig, onMessage);
+   ```
+
+### Defining schemas
+
+All schemas must be defined using `zod/z4`. By convention, all messages should extend the `IdMetaSchema` schema, but it is not strictly required.
+
+IdMetaSchema provides several fields useful for message tracking:
+
+- id: a string GUID representing the unique message
+- meta.createdAt: when the message was originally sent (ISO datetime string)
+- meta.schemaId: a string value representing the schema
+  - currently: a hash of the JSON schema itself
+  - future use: an id into a schema registry that supports schema evolution
+- meta.publishedBy: [[future use]] the name of the service that published the message
+
+## Handling errors
+
+### Schema failures
+
+The message is checked against the provided schema for every publish and subscribe.
+
+- Publisher: catch the `SchemaValidationError` exception.
+
+  ```ts
+  try {
+    await publisher.publish(config, message);
+  } catch (err: unknown) {
+    if (error instanceof SchemaValidationError) {
+      // TODO
+    }
+  }
+  ```
+
+- Subscriber: add an event monitor on `schemaError`
+
+  ```ts
+  subscriber.on(
+    "schemaError",
+    (
+      message: string, // the JSON string of the message
+      context: MessageContext, // the context of the message provided by the SubscriptionProvider
+      config: PubSubConfiguration, // the configuration for the message (eg: BullMqQueueConfiguration, RabbitQueueExchangeConfiguration)
+    ) => {
+      // TODO
+    },
+  );
+  ```
+
+### Subscriber errors
+
+When a subscriber handler fails, the SubscriberProvider should retry or fail the message.
+
+Retries should occur when
+
+- The user-provided handler throws an exception
+- The handler returns MessageResult.Retry
+
+It is up to the provider to obey the `retries` and `retryDelay` configuration properties.
+
+### Publisher errors
+
+When a message publish fails, it is up to the calling code to handle exceptions.

package/dist/bullmq/config.d.ts

@@ -0,0 +1,21 @@
+import { MessageContext, PubSubConfiguration } from "../interfaces";
+export interface BullMqQueueConfiguration extends PubSubConfiguration {
+    /**
+     * The name of the queue
+     */
+    name: string;
+    /**
+     * The name of the job to use
+     */
+    job?: string;
+}
+export interface BullMqMessageContext extends MessageContext {
+    /**
+     * name of the bull mq job
+     */
+    job: string;
+    /**
+     * Provide an optional reply for the job here
+     */
+    reply?: unknown;
+}

package/dist/bullmq/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/bullmq/connection.d.ts

@@ -0,0 +1,2 @@
+export declare const BULLMQ_TRANSPORT = "bullmq";
+export declare const BULLMQ_DEFAULTJOB = "pubsub";

package/dist/bullmq/connection.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BULLMQ_DEFAULTJOB = exports.BULLMQ_TRANSPORT = void 0;
+exports.BULLMQ_TRANSPORT = "bullmq";
+exports.BULLMQ_DEFAULTJOB = "pubsub";

package/dist/bullmq/main.d.ts

@@ -0,0 +1,6 @@
+export * from "./config.js";
+export * from "./connection.js";
+export * from "./publisher.js";
+export * from "./subscriber.js";
+export * from "./pubsub.js";
+export type { ConnectionOptions } from "bullmq";

package/dist/bullmq/main.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./connection.js"), exports);
+__exportStar(require("./publisher.js"), exports);
+__exportStar(require("./subscriber.js"), exports);
+__exportStar(require("./pubsub.js"), exports);

package/dist/bullmq/publisher.d.ts

@@ -0,0 +1,13 @@
+import type * as bullmq from "bullmq";
+import { Logger, PublisherProvider } from "../interfaces";
+import { BullMqQueueConfiguration } from "./config";
+export declare class BullMqPublisher implements PublisherProvider {
+    private readonly connection;
+    private readonly logger;
+    private queues;
+    constructor(connection: bullmq.ConnectionOptions, logger: Logger);
+    readonly transport: string;
+    private getQueue;
+    publish(config: BullMqQueueConfiguration, message: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/bullmq/publisher.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullMqPublisher = void 0;
+const connection_1 = require("./connection");
+const lazy_load_1 = require("../lazy-load");
+class BullMqPublisher {
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.queues = new Map();
+        this.transport = connection_1.BULLMQ_TRANSPORT;
+    }
+    getQueue(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let queue = this.queues.get(config);
+            if (queue) {
+                return queue;
+            }
+            const BullMqPackage = yield (0, lazy_load_1.lazyLoad)({
+                packageName: "bullmq",
+                context: "BullMqPublisher",
+            });
+            queue = new BullMqPackage.Queue(config.name, {
+                connection: this.connection,
+            });
+            this.queues.set(config, queue);
+            return queue;
+        });
+    }
+    publish(config, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const queue = yield this.getQueue(config);
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `Publishing message to ${queue.name} - ${message}`);
+            yield queue.add(config.job || connection_1.BULLMQ_DEFAULTJOB, message, {
+                attempts: config.retries,
+                backoff: {
+                    type: "fixed",
+                    delay: config.retryDelay || 30000,
+                },
+            });
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const queue of this.queues.values()) {
+                yield queue.close();
+            }
+            this.queues.clear();
+        });
+    }
+}
+exports.BullMqPublisher = BullMqPublisher;

package/dist/bullmq/pubsub.d.ts

@@ -0,0 +1,12 @@
+import { Logger, MessageContext, MessageResult, PubSubProvider, StopSubscribe } from "../interfaces";
+import { BullMqQueueConfiguration } from "./config";
+import type { ConnectionOptions } from "bullmq";
+export declare class BullMqPubSubProvider implements PubSubProvider {
+    private readonly publisher;
+    private readonly subscriber;
+    constructor(connection: ConnectionOptions, logger: Logger);
+    readonly transport: string;
+    publish(config: BullMqQueueConfiguration, message: string): Promise<void>;
+    startSubscribe(config: BullMqQueueConfiguration, onMessage: (s: string, context: MessageContext) => Promise<MessageResult> | MessageResult): Promise<StopSubscribe>;
+    close(): Promise<void>;
+}

package/dist/bullmq/pubsub.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullMqPubSubProvider = void 0;
+const connection_1 = require("./connection");
+const publisher_1 = require("./publisher");
+const subscriber_1 = require("./subscriber");
+class BullMqPubSubProvider {
+    constructor(connection, logger) {
+        this.transport = connection_1.BULLMQ_TRANSPORT;
+        this.publisher = new publisher_1.BullMqPublisher(connection, logger);
+        this.subscriber = new subscriber_1.BullMqSubscriber(connection, logger);
+    }
+    publish(config, message) {
+        return this.publisher.publish(config, message);
+    }
+    startSubscribe(config, onMessage) {
+        return this.subscriber.startSubscribe(config, onMessage);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.subscriber.close();
+            yield this.publisher.close();
+        });
+    }
+}
+exports.BullMqPubSubProvider = BullMqPubSubProvider;

package/dist/bullmq/subscriber.d.ts

@@ -0,0 +1,27 @@
+import type * as bullmq from "bullmq";
+import { Logger, MessageResult, StopSubscribe, SubscriberProvider } from "../interfaces";
+import { BullMqMessageContext, BullMqQueueConfiguration } from "./config";
+declare class SubscribedMessage {
+    private readonly owner;
+    private readonly worker;
+    private readonly logger;
+    constructor(owner: BullMqSubscriber, worker: bullmq.Worker, logger: Logger);
+    stopSubscribe(): Promise<void>;
+}
+export declare class MessageFailError extends Error {
+    constructor();
+}
+export declare class MessageRetryError extends Error {
+    constructor();
+}
+export declare class BullMqSubscriber implements SubscriberProvider {
+    private readonly connection;
+    private readonly logger;
+    private readonly stops;
+    constructor(connection: bullmq.ConnectionOptions, logger: Logger);
+    readonly transport: string;
+    removeSubscriber(subscribedMessage: SubscribedMessage): void;
+    startSubscribe(config: BullMqQueueConfiguration, onMessage: (s: string, context: BullMqMessageContext) => Promise<MessageResult> | MessageResult): Promise<StopSubscribe>;
+    close(): Promise<void>;
+}
+export {};

package/dist/bullmq/subscriber.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullMqSubscriber = exports.MessageRetryError = exports.MessageFailError = void 0;
+const interfaces_1 = require("../interfaces");
+const connection_1 = require("./connection");
+const lazy_load_1 = require("../lazy-load");
+class SubscribedMessage {
+    constructor(owner, worker, logger) {
+        this.owner = owner;
+        this.worker = worker;
+        this.logger = logger;
+    }
+    stopSubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `BullMq closing worker for ${this.worker.name}`);
+            yield this.worker.close();
+            this.owner.removeSubscriber(this);
+        });
+    }
+}
+class MessageFailError extends Error {
+    constructor() {
+        super("Handler asked to fail this job");
+    }
+}
+exports.MessageFailError = MessageFailError;
+class MessageRetryError extends Error {
+    constructor() {
+        super("Handler asked to retry this job");
+    }
+}
+exports.MessageRetryError = MessageRetryError;
+class BullMqSubscriber {
+    constructor(connection, logger) {
+        this.connection = connection;
+        this.logger = logger;
+        this.stops = new Map();
+        this.transport = connection_1.BULLMQ_TRANSPORT;
+    }
+    removeSubscriber(subscribedMessage) {
+        for (const [key, value] of this.stops) {
+            if (value === subscribedMessage) {
+                this.stops.delete(key);
+                break;
+            }
+        }
+    }
+    startSubscribe(config, onMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const BullMqPackage = yield (0, lazy_load_1.lazyLoad)({
+                packageName: "bullmq",
+                context: "BullMqSubscriber",
+            });
+            const worker = new BullMqPackage.Worker(config.name, (job) => __awaiter(this, void 0, void 0, function* () {
+                const context = {
+                    job: job.name,
+                    retries: job.attemptsMade,
+                    firstSent: new Date(job.timestamp),
+                    // lastSent: new Date(job.attemptsStarted),
+                };
+                const result = yield onMessage(job.data, context);
+                if (result === interfaces_1.MessageResult.Ok) {
+                    return context.reply;
+                }
+                if (result === interfaces_1.MessageResult.Retry) {
+                    throw new MessageRetryError();
+                }
+                throw new BullMqPackage.UnrecoverableError("Handler asked to fail this job");
+            }), {
+                connection: this.connection,
+                autorun: false,
+            });
+            worker.on("failed", (job, err) => {
+                if (!job) {
+                    return;
+                }
+                this.logger.log(`Job failed ${err}`);
+            });
+            worker.on("error", (err) => {
+                this.logger.error(`BullMq PubSub handler exception: ${err}`);
+            });
+            (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `BullMq PubSub subscriber starting for ${worker.name}`);
+            worker
+                .run()
+                .then(() => {
+                var _a, _b;
+                (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, `BullMq PubSub subscriber stopped for ${worker.name}`);
+            })
+                .catch((err) => {
+                this.logger.error(`BullMq PubSub subscriber crashed for ${worker.name}`, err);
+            });
+            const subscribedMessage = new SubscribedMessage(this, worker, this.logger);
+            this.stops.set(config, subscribedMessage);
+            (_d = (_c = this.logger).debug) === null || _d === void 0 ? void 0 : _d.call(_c, `BullMq PubSub subscriber started for ${worker.name}`);
+            return () => subscribedMessage.stopSubscribe();
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const sub of this.stops.values()) {
+                yield sub.stopSubscribe();
+            }
+            this.stops.clear();
+        });
+    }
+}
+exports.BullMqSubscriber = BullMqSubscriber;

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class AlreadySubscribingError extends Error {
+    name: string;
+    constructor(name: string);
+    static isAlreadySubscribingError(err: unknown): err is AlreadySubscribingError;
+}
+export declare class ConfigurationError extends Error {
+    static isConfigurationError(err: unknown): err is ConfigurationError;
+}
+export declare class MissingPubSubProviderError extends Error {
+    static isMissingPubSubProviderError(err: unknown): err is MissingPubSubProviderError;
+}
+export declare class PublishError extends Error {
+    static isPublishError(err: unknown): err is PublishError;
+}
+export declare class SchemaValidationError extends Error {
+    static isSchemaValidationError(err: unknown): err is SchemaValidationError;
+}

package/dist/errors.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidationError = exports.PublishError = exports.MissingPubSubProviderError = exports.ConfigurationError = exports.AlreadySubscribingError = void 0;
+class AlreadySubscribingError extends Error {
+    constructor(name) {
+        super(`Subscription for ${name} already started`);
+        this.name = name;
+    }
+    static isAlreadySubscribingError(err) {
+        return err instanceof AlreadySubscribingError;
+    }
+}
+exports.AlreadySubscribingError = AlreadySubscribingError;
+class ConfigurationError extends Error {
+    static isConfigurationError(err) {
+        return err instanceof ConfigurationError;
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+class MissingPubSubProviderError extends Error {
+    static isMissingPubSubProviderError(err) {
+        return err instanceof MissingPubSubProviderError;
+    }
+}
+exports.MissingPubSubProviderError = MissingPubSubProviderError;
+class PublishError extends Error {
+    static isPublishError(err) {
+        return err instanceof PublishError;
+    }
+}
+exports.PublishError = PublishError;
+class SchemaValidationError extends Error {
+    static isSchemaValidationError(err) {
+        return err instanceof SchemaValidationError;
+    }
+}
+exports.SchemaValidationError = SchemaValidationError;

package/dist/interfaces.d.ts

@@ -0,0 +1,120 @@
+import { z as z4 } from "zod/v4";
+export declare const MetaSchema: z4.ZodObject<{
+    createdAt: z4.ZodISODateTime;
+    schemaId: z4.ZodString;
+    publishedBy: z4.ZodString;
+}, z4.core.$strip>;
+export declare const IdMetaSchema: z4.ZodObject<{
+    id: z4.ZodOptional<z4.ZodString>;
+    meta: z4.ZodOptional<z4.ZodObject<{
+        createdAt: z4.ZodISODateTime;
+        schemaId: z4.ZodString;
+        publishedBy: z4.ZodString;
+    }, z4.core.$strip>>;
+}, z4.core.$strip>;
+export type Meta = z4.infer<typeof MetaSchema>;
+/**
+ * All messages should be based on this schema
+ */
+export type BaseMessage = z4.infer<typeof IdMetaSchema>;
+/**
+ * All pubsub publishers must implement this interface
+ */
+export interface PublisherProvider {
+    transport: string;
+    publish(config: PubSubConfiguration, message: string): Promise<void> | void;
+    close(): Promise<void> | void;
+}
+/**
+ * Minimal configuration needed to publish or subscribe to a message
+ */
+export interface PubSubConfiguration {
+    /**
+     * The name of the message
+     */
+    name: string;
+    /**
+     * The schema for the message - the message is verfied during publish and subscribe
+     */
+    schema: z4.ZodType;
+    /**
+     * The message transport to use (defined by the event-pubsub implementations)
+     */
+    transport: string;
+    /**
+     * Maximum number of times to retry a message
+     */
+    retries?: number;
+    /**
+     * Minimum amount of time to wait, in milliseconds, before retrying a message
+     */
+    retryDelay?: number;
+}
+export declare enum MessageResult {
+    /**
+     * the message was handled successfully or can otherwise be ignored
+     */
+    Ok = "ok",
+    /**
+     * The message should be retried
+     */
+    Retry = "retry",
+    /**
+     * The message failed and is either discarded or stored in a dead-letter queue
+     */
+    Fail = "fail"
+}
+/**
+ * Simple interface for logging, should match console/NestJS LoggerService/etc.
+ */
+export interface Logger {
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: unknown, ...optionalParams: unknown[]): unknown;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: unknown, ...optionalParams: unknown[]): unknown;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: unknown, ...optionalParams: unknown[]): unknown;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: unknown, ...optionalParams: unknown[]): unknown;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?(message: unknown, ...optionalParams: unknown[]): unknown;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal?(message: unknown, ...optionalParams: unknown[]): unknown;
+}
+/**
+ * A callback the stops the subscriber
+ */
+export type StopSubscribe = () => Promise<void>;
+/**
+ * All pubsub subscribers must implement this interface
+ */
+export interface SubscriberProvider {
+    transport: string;
+    startSubscribe(config: PubSubConfiguration, onMessage: (s: string, context: MessageContext) => Promise<MessageResult> | MessageResult): Promise<StopSubscribe> | StopSubscribe;
+    close(): Promise<void> | void;
+}
+/**
+ * A class that implements both the publisher and subscriber
+ */
+export type PubSubProvider = PublisherProvider & SubscriberProvider;
+/**
+ * A class that implements either a publisher, subscriber or both
+ */
+export type PubOrSubProvider = PubSubProvider | PublisherProvider | SubscriberProvider;
+export interface MessageContext {
+    firstSent?: Date;
+    lastSent?: Date;
+    retries?: number;
+}