@hastehaul/common 1.0.12 → 1.0.14

package/build/connections-wrappers/nats-wrapper.d.ts

@@ -0,0 +1,27 @@
+import { ConnectionOptions, NatsConnection } from 'nats';
+/**
+ * A wrapper class for the NATS client to manage connections and provide a centralized client instance.
+ */
+declare class NatsWrapper {
+    private _client?;
+    /**
+     * Get the NATS client instance.
+     *
+     * @throws {Error} - Throws an error if the NATS client is accessed before connecting.
+     * @returns {NatsConnection} - The NATS client instance.
+     */
+    get client(): NatsConnection;
+    /**
+     * Connect to the NATS server using the specified connection options.
+     *
+     * The client instance will be stored in the `_client` property for later access.
+     *
+     * @param {ConnectionOptions} opts - The options for connecting to the NATS server.
+     */
+    connect(opts?: ConnectionOptions): Promise<void>;
+}
+/**
+ * Singleton instance of the NatsWrapper class to provide a centralized NATS client connection.
+ */
+export declare const natsWrapper: NatsWrapper;
+export {};

package/build/connections-wrappers/nats-wrapper.js

@@ -0,0 +1,50 @@
+"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.natsWrapper = void 0;
+const nats_1 = require("nats");
+/**
+ * A wrapper class for the NATS client to manage connections and provide a centralized client instance.
+ */
+class NatsWrapper {
+    /**
+     * Get the NATS client instance.
+     *
+     * @throws {Error} - Throws an error if the NATS client is accessed before connecting.
+     * @returns {NatsConnection} - The NATS client instance.
+     */
+    get client() {
+        if (!this._client)
+            throw new Error("Cannot access NATS CLIENT before connecting");
+        return this._client;
+    }
+    /**
+     * Connect to the NATS server using the specified connection options.
+     *
+     * The client instance will be stored in the `_client` property for later access.
+     *
+     * @param {ConnectionOptions} opts - The options for connecting to the NATS server.
+     */
+    connect(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this._client = yield (0, nats_1.connect)(opts);
+            }
+            catch (error) {
+                console.log(`error connecting to ${JSON.stringify(opts === null || opts === void 0 ? void 0 : opts.servers)}`);
+            }
+        });
+    }
+}
+/**
+ * Singleton instance of the NatsWrapper class to provide a centralized NATS client connection.
+ */
+exports.natsWrapper = new NatsWrapper();

package/build/events/base/base-consumer.d.ts

@@ -0,0 +1,83 @@
+import { NatsConnection, ConsumerConfig, JsMsg } from "nats";
+import { DurableName, Subjects, Streams } from "../common/enums";
+import { MainSubjects, ValidateSubjectFormat } from "../common/enums/subjects/main-subjects";
+/**
+ * Interface representing an event published to NATS.
+ */
+interface Event {
+    subject: ValidateSubjectFormat<Subjects, MainSubjects>;
+    durableName?: DurableName;
+    stream: Streams;
+    data: any;
+}
+/**
+ * Abstract class representing a NATS consumer for processing messages from a JetStream stream.
+ *
+ * @typeparam {T} - The type of event to be consumed, extending the Event interface.
+ */
+export declare abstract class NatsConsumer<T extends Event> {
+    protected client: NatsConnection;
+    protected jc: import("nats").Codec<T>;
+    protected sc: import("nats").Codec<string>;
+    /**
+     * The name of the JetStream stream to consume messages from.
+    */
+    abstract stream: T["stream"];
+    /**
+     * The subject to filter messages for this consumer.
+    */
+    abstract subject: T["subject"];
+    /**
+    * The name of the durable consumer, if applicable.
+    */
+    abstract durableName: T["durableName"];
+    /**
+     * The maximum number of messages that can be processed concurrently.
+    */
+    abstract maxConcurrentMessages: number;
+    protected ackWait: number;
+    /**
+     * Creates an instance of NatsConsumer.
+     *
+     * @param {NatsConnection} client - The NATS connection instance.
+     */
+    constructor(client: NatsConnection);
+    /**
+     * Provides the consumer options for JetStream.
+     *
+     * @returns {Partial<ConsumerConfig>} - The partial consumer options.
+     */
+    get consumerOptions(): Partial<ConsumerConfig>;
+    /**
+     * Consume messages from the JetStream stream and process them concurrently.
+     *
+     * Messages are processed asynchronously up to the maximum concurrent limit.
+     */
+    consume(): Promise<void>;
+    /**
+      * Abstract method to process a single message received from the stream.
+      *
+      * This method should be implemented by subclasses to define custom logic for processing messages.
+      *
+      * @param {T["data"]} data - The data representing the message payload.
+      * @param {JsMsg} msg - The message object received from the stream.
+      * @returns {Promise<void>} - A Promise that resolves once the message processing is completed successfully.
+    */
+    abstract processMessage(data: T["data"], msg: JsMsg): Promise<void>;
+    /**
+     * Closes the NATS connection when message processing is finished.
+     *
+     * @protected
+     * @returns {Promise<void>} - A Promise that resolves once the NATS connection is drained and closed.
+   */
+    protected close(): Promise<void>;
+    /**
+     * Utility method to parse the message data using the appropriate codec (JSON or string).
+     *
+     * @protected
+     * @param {JsMsg} msg - The message object received from the stream.
+     * @returns {T["data"]} - The parsed message data.
+   */
+    protected parsedMessage: (msg: JsMsg) => string | T;
+}
+export {};

package/build/events/base/base-consumer.js

@@ -0,0 +1,129 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsConsumer = void 0;
+const nats_1 = require("nats");
+/**
+ * Abstract class representing a NATS consumer for processing messages from a JetStream stream.
+ *
+ * @typeparam {T} - The type of event to be consumed, extending the Event interface.
+ */
+class NatsConsumer {
+    /**
+     * Creates an instance of NatsConsumer.
+     *
+     * @param {NatsConnection} client - The NATS connection instance.
+     */
+    constructor(client) {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.sc = (0, nats_1.StringCodec)();
+        this.ackWait = (0, nats_1.nanos)(5 * 1000);
+        /**
+         * Utility method to parse the message data using the appropriate codec (JSON or string).
+         *
+         * @protected
+         * @param {JsMsg} msg - The message object received from the stream.
+         * @returns {T["data"]} - The parsed message data.
+       */
+        this.parsedMessage = (msg) => typeof msg.data === "string" ? this.sc.decode(msg.data) : this.jc.decode(msg.data);
+        this.client = client;
+    }
+    /**
+     * Provides the consumer options for JetStream.
+     *
+     * @returns {Partial<ConsumerConfig>} - The partial consumer options.
+     */
+    get consumerOptions() {
+        return {
+            deliver_policy: nats_1.DeliverPolicy.All,
+            ack_policy: nats_1.AckPolicy.Explicit,
+            ack_wait: this.ackWait,
+            durable_name: this.durableName,
+            replay_policy: nats_1.ReplayPolicy.Instant,
+            filter_subject: this.subject,
+        };
+    }
+    /**
+     * Consume messages from the JetStream stream and process them concurrently.
+     *
+     * Messages are processed asynchronously up to the maximum concurrent limit.
+     */
+    consume() {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(this.stream, this.durableName, this.subject);
+            try {
+                const jsm = yield this.client.jetstreamManager();
+                yield jsm.consumers.add(this.stream, this.consumerOptions);
+                const js = this.client.jetstream();
+                const consumer = yield js.consumers.get(this.stream, this.durableName);
+                const messages = yield consumer.consume({ max_messages: 5 });
+                let pendingMessages = [];
+                let inFlight = 0;
+                try {
+                    for (var _d = true, messages_1 = __asyncValues(messages), messages_1_1; messages_1_1 = yield messages_1.next(), _a = messages_1_1.done, !_a; _d = true) {
+                        _c = messages_1_1.value;
+                        _d = false;
+                        const msg = _c;
+                        // Process messages asynchronously up to the maximum concurrent limit
+                        if (inFlight < this.maxConcurrentMessages) {
+                            const parsedMessage = this.parsedMessage(msg);
+                            inFlight++;
+                            yield this.processMessage(parsedMessage, msg).then(() => { inFlight--; }).catch(() => { inFlight--; });
+                        }
+                        else {
+                            console.log("PENDING MESSAGES: ", pendingMessages);
+                            pendingMessages.push(msg); // Store the message to be processed later
+                        }
+                        // Check if there are pending messages that can be processed
+                        while (pendingMessages.length && inFlight < this.maxConcurrentMessages) {
+                            console.log("PENDING MESSAGES: ", pendingMessages);
+                            const pendingMessage = pendingMessages.shift();
+                            const parsedMessage = this.parsedMessage(pendingMessage);
+                            inFlight++;
+                            yield this.processMessage(parsedMessage, pendingMessage).then(() => { inFlight--; }).catch(() => { inFlight--; });
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = messages_1.return)) yield _b.call(messages_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                console.error(error.message);
+                // throw new Error("Failed to consume messages");
+            }
+        });
+    }
+    /**
+     * Closes the NATS connection when message processing is finished.
+     *
+     * @protected
+     * @returns {Promise<void>} - A Promise that resolves once the NATS connection is drained and closed.
+   */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.drain();
+        });
+    }
+}
+exports.NatsConsumer = NatsConsumer;

package/build/events/base/base-publisher.d.ts

@@ -0,0 +1,33 @@
+import { PubAck, NatsConnection } from "nats";
+import { Subjects } from "../common/enums";
+import { MainSubjects, ValidateSubjectFormat } from "../common/enums/subjects/main-subjects";
+/**
+ * Interface representing an event to be published to NATS.
+ */
+interface Event {
+    subject: ValidateSubjectFormat<Subjects, MainSubjects>;
+    data: any;
+}
+/**
+ * Abstract class representing a NATS publisher for publishing events to NATS.
+ *
+ * @typeparam {T} - The type of event to be published, extending the Event interface.
+ */
+export declare abstract class NatsPublisher<T extends Event> {
+    private jc;
+    private sc;
+    /**
+     * The subject representing the event type to be published.
+     */
+    abstract subject: T["subject"];
+    /**
+   * Publishes an event to NATS using the provided NATS connection.
+   *
+   * @param {NatsConnection} nc - The NATS connection instance.
+   * @param {T["data"]} data - The data to be published as part of the event.
+   * @returns {Promise<PubAck>} - A Promise that resolves with the PubAck response from NATS.
+   * @throws {Error} - Throws an error if there is an issue while publishing the event.
+   */
+    publish(nc: NatsConnection, data: T["data"]): Promise<PubAck>;
+}
+export {};

package/build/events/base/base-publisher.js

@@ -0,0 +1,45 @@
+"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.NatsPublisher = void 0;
+const nats_1 = require("nats");
+/**
+ * Abstract class representing a NATS publisher for publishing events to NATS.
+ *
+ * @typeparam {T} - The type of event to be published, extending the Event interface.
+ */
+class NatsPublisher {
+    constructor() {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.sc = (0, nats_1.StringCodec)();
+    }
+    /**
+   * Publishes an event to NATS using the provided NATS connection.
+   *
+   * @param {NatsConnection} nc - The NATS connection instance.
+   * @param {T["data"]} data - The data to be published as part of the event.
+   * @returns {Promise<PubAck>} - A Promise that resolves with the PubAck response from NATS.
+   * @throws {Error} - Throws an error if there is an issue while publishing the event.
+   */
+    publish(nc, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const jetStreamClient = nc.jetstream();
+                return yield jetStreamClient.publish(this.subject, typeof data === "string" ? this.sc.encode(data) : this.jc.encode(data));
+            }
+            catch (error) {
+                console.error(error.message);
+                throw new Error(`Failed to publish message. Error: [${error.message}]`);
+            }
+        });
+    }
+}
+exports.NatsPublisher = NatsPublisher;

package/build/events/base/base-stream.d.ts

@@ -0,0 +1,34 @@
+import { NatsConnection } from "nats";
+import { Streams } from "../common/enums";
+import { MainSubjects } from "../common/enums/subjects/main-subjects";
+/**
+ * Interface representing an event to be used with NATS streams.
+ */
+interface Event {
+    subject: MainSubjects;
+    stream: Streams;
+}
+/**
+ * Abstract class representing a NATS stream for handling events in a JetStream stream.
+ *
+ * @typeparam {T} - The type of event to be handled, extending the Event interface.
+ */
+export declare abstract class NatsStream<T extends Event> {
+    /**
+    * The subject representing the event type to be handled.
+    */
+    abstract subject: T["subject"];
+    /**
+     * The name of the JetStream stream to handle events from.
+     */
+    abstract stream: T['stream'];
+    /**
+   * Initializes the NATS stream and adds it to the JetStream server using the provided NATS connection.
+   *
+   * @param {NatsConnection} client - The NATS connection instance.
+   * @returns {Promise<void>} - A Promise that resolves once the stream is successfully added to the JetStream server.
+   * @throws {Error} - Throws an error if there is an issue while adding the stream to the JetStream server.
+   */
+    init(client: NatsConnection): Promise<void>;
+}
+export {};

package/build/events/base/base-stream.js

@@ -0,0 +1,40 @@
+"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.NatsStream = void 0;
+/**
+ * Abstract class representing a NATS stream for handling events in a JetStream stream.
+ *
+ * @typeparam {T} - The type of event to be handled, extending the Event interface.
+ */
+class NatsStream {
+    /**
+   * Initializes the NATS stream and adds it to the JetStream server using the provided NATS connection.
+   *
+   * @param {NatsConnection} client - The NATS connection instance.
+   * @returns {Promise<void>} - A Promise that resolves once the stream is successfully added to the JetStream server.
+   * @throws {Error} - Throws an error if there is an issue while adding the stream to the JetStream server.
+   */
+    init(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const jsm = yield client.jetstreamManager();
+                yield jsm.streams.add({ name: this.stream, subjects: [this.subject] });
+                return;
+            }
+            catch (error) {
+                console.error(error.message);
+                throw new Error("Failed to add stream");
+            }
+        });
+    }
+}
+exports.NatsStream = NatsStream;

package/build/events/common/enums/durable-names/index.d.ts

@@ -0,0 +1,8 @@
+import { PaymentDurableName } from "./payment-dname";
+import { OrderDurableName } from "./order-dname";
+/**
+ * Type alias representing a durable name that can be associated with different event consumers.
+ *
+ * The `DurableName` type can be one of the durable names defined in `OrderDurableName` or `PaymentDurableName`.
+ */
+export type DurableName = OrderDurableName | PaymentDurableName;

package/build/events/common/enums/durable-names/index.js

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

package/build/events/common/enums/durable-names/order-dname.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Enum representing durable names for consumers associated with different order events.
+ */
+export declare enum OrderDurableName {
+    /**
+     * The durable name for the consumer handling order cancelled events.
+     */
+    OrderCancelledDurablename = "order-cancelled-consumer",
+    /**
+     * The durable name for the consumer handling order requested events.
+     */
+    OrderRequestDurablename = "order-requested-consumer",
+    /**
+     * The durable name for the consumer handling order completed events.
+     */
+    OrderCompletedDurablename = "order-completed-consumer"
+}

package/build/events/common/enums/durable-names/order-dname.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderDurableName = void 0;
+/**
+ * Enum representing durable names for consumers associated with different order events.
+ */
+var OrderDurableName;
+(function (OrderDurableName) {
+    /**
+     * The durable name for the consumer handling order cancelled events.
+     */
+    OrderDurableName["OrderCancelledDurablename"] = "order-cancelled-consumer";
+    /**
+     * The durable name for the consumer handling order requested events.
+     */
+    OrderDurableName["OrderRequestDurablename"] = "order-requested-consumer";
+    /**
+     * The durable name for the consumer handling order completed events.
+     */
+    OrderDurableName["OrderCompletedDurablename"] = "order-completed-consumer";
+})(OrderDurableName || (exports.OrderDurableName = OrderDurableName = {}));

package/build/events/common/enums/durable-names/payment-dname.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enum representing durable names for consumers associated with different payment events.
+ */
+export declare enum PaymentDurableName {
+    /**
+     * The durable name for the consumer handling payment failed events.
+     */
+    PaymentFailedDurableName = "payment-failed-consumer",
+    /**
+     * The durable name for the consumer handling payment created events.
+     */
+    PaymentCreatedDurableName = "payment-created-consumer"
+}

package/build/events/common/enums/durable-names/payment-dname.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentDurableName = void 0;
+/**
+ * Enum representing durable names for consumers associated with different payment events.
+ */
+var PaymentDurableName;
+(function (PaymentDurableName) {
+    /**
+     * The durable name for the consumer handling payment failed events.
+     */
+    PaymentDurableName["PaymentFailedDurableName"] = "payment-failed-consumer";
+    /**
+     * The durable name for the consumer handling payment created events.
+     */
+    PaymentDurableName["PaymentCreatedDurableName"] = "payment-created-consumer";
+})(PaymentDurableName || (exports.PaymentDurableName = PaymentDurableName = {}));

package/build/events/common/enums/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Re-exports all the types related to durable names from the "durable-names" file.
+ *
+ * The types include enums and utility types used to define durable names for consumers of different event types.
+ */
+export * from "./durable-names";
+/**
+ * Re-exports the type related to streams from the "streams" file.
+ *
+ * The "Streams" type alias represents a JetStream stream that can handle different event types.
+ */
+export * from "./streams";
+/**
+ * Re-exports the type related to subjects from the "subjects" file.
+ *
+ * The "Subjects" type alias represents the subjects for different event types.
+ */
+export * from "./subjects";

package/build/events/common/enums/index.js

@@ -0,0 +1,35 @@
+"use strict";
+// Import and re-export types from other files for easier access.
+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 });
+/**
+ * Re-exports all the types related to durable names from the "durable-names" file.
+ *
+ * The types include enums and utility types used to define durable names for consumers of different event types.
+ */
+__exportStar(require("./durable-names"), exports);
+/**
+ * Re-exports the type related to streams from the "streams" file.
+ *
+ * The "Streams" type alias represents a JetStream stream that can handle different event types.
+ */
+__exportStar(require("./streams"), exports);
+/**
+ * Re-exports the type related to subjects from the "subjects" file.
+ *
+ * The "Subjects" type alias represents the subjects for different event types.
+ */
+__exportStar(require("./subjects"), exports);

package/build/events/common/enums/streams/index.d.ts

@@ -0,0 +1,8 @@
+import { PaymentStream } from './payment-stream';
+import { OrderStream } from './order-stream';
+/**
+ * Type alias representing a JetStream stream that can handle different event types.
+ *
+ * The `Streams` type can be one of the streams defined in `OrderStream` or `PaymentStream`.
+ */
+export type Streams = OrderStream | PaymentStream;

package/build/events/common/enums/streams/index.js

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

package/build/events/common/enums/streams/order-stream.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Enum representing the name of the JetStream stream used for handling order events.
+ */
+export declare enum OrderStream {
+    /**
+     * The name of the JetStream stream for order events.
+     */
+    Order = "ORDER"
+}

package/build/events/common/enums/streams/order-stream.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderStream = void 0;
+/**
+ * Enum representing the name of the JetStream stream used for handling order events.
+ */
+var OrderStream;
+(function (OrderStream) {
+    /**
+     * The name of the JetStream stream for order events.
+     */
+    OrderStream["Order"] = "ORDER";
+})(OrderStream || (exports.OrderStream = OrderStream = {}));

package/build/events/common/enums/streams/payment-stream.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Enum representing the name of the JetStream stream used for handling payment events.
+ */
+export declare enum PaymentStream {
+    /**
+     * The name of the JetStream stream for payment events.
+     */
+    Payment = "PAYMENT"
+}

package/build/events/common/enums/streams/payment-stream.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentStream = void 0;
+/**
+ * Enum representing the name of the JetStream stream used for handling payment events.
+ */
+var PaymentStream;
+(function (PaymentStream) {
+    /**
+     * The name of the JetStream stream for payment events.
+     */
+    PaymentStream["Payment"] = "PAYMENT";
+})(PaymentStream || (exports.PaymentStream = PaymentStream = {}));

package/build/events/common/enums/subjects/index.d.ts

@@ -0,0 +1,8 @@
+import { PaymentSubjects } from './payment-subjects';
+import { OrderSubjects } from './order-subjects';
+/**
+ * Type alias representing the subjects for different event types.
+ *
+ * The `Subjects` type can be one of the subjects defined in `OrderSubjects` or `PaymentSubjects`.
+ */
+export type Subjects = OrderSubjects | PaymentSubjects;

package/build/events/common/enums/subjects/index.js

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

package/build/events/common/enums/subjects/main-subjects.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Enum representing the main subjects used for NATS subjects.
+ */
+export declare enum MainSubjects {
+    ORDER = "order.*",
+    PAYMENT = "payment.*",
+    ETA = "eta.*"
+}
+/**
+ * Type utility to concatenate two strings into a valid subject format.
+ *
+ * This utility is used to combine a prefix and a postfix with a period (".") in between to form a valid subject format.
+ * The resulting subject format must adhere to the pattern `${T}.${U}`.
+ */
+type SubjectFormat<T extends string, U extends string> = `${T}.${U}`;
+/**
+ * Type utility to extract the string before the first colon (".") in a subject format.
+ *
+ * This utility extracts the substring before the first colon in a subject format of the pattern `${T}.*`.
+ */
+type ExtractStringBeforeColon<T extends string> = T extends `${infer StringBeforeColon}.*` ? StringBeforeColon : never;
+/**
+ * Type utility to validate and enforce subject formats based on main subject patterns.
+ *
+ * The utility ensures that the given subject format adheres to the pattern `${T}.${U}`.
+ * The `T` part of the subject format is validated against the prefix of the main subjects defined in the `MainSubjects` enum.
+ * The `U` part of the subject format can be any string.
+ */
+export type ValidateSubjectFormat<T extends string, U extends string> = U extends MainSubjects ? T extends SubjectFormat<ExtractStringBeforeColon<MainSubjects>, string> ? T : never : never;
+/**
+ * Utility function to spread enum values into an array of strings.
+ *
+ * This utility function takes an object representing an enum and returns an array containing all the string values of the enum.
+ *
+ * @param {T} enumObject - The object representing the enum.
+ * @returns {string[]} - An array containing all the string values of the enum.
+ */
+export declare const spreadEnumValues: <T extends Record<string, string>>(enumObject: T) => string[];
+export {};

package/build/events/common/enums/subjects/main-subjects.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadEnumValues = exports.MainSubjects = void 0;
+/**
+ * Enum representing the main subjects used for NATS subjects.
+ */
+var MainSubjects;
+(function (MainSubjects) {
+    MainSubjects["ORDER"] = "order.*";
+    MainSubjects["PAYMENT"] = "payment.*";
+    MainSubjects["ETA"] = "eta.*";
+})(MainSubjects || (exports.MainSubjects = MainSubjects = {}));
+/**
+ * Utility function to spread enum values into an array of strings.
+ *
+ * This utility function takes an object representing an enum and returns an array containing all the string values of the enum.
+ *
+ * @param {T} enumObject - The object representing the enum.
+ * @returns {string[]} - An array containing all the string values of the enum.
+ */
+const spreadEnumValues = (enumObject) => Object.values(enumObject);
+exports.spreadEnumValues = spreadEnumValues;

package/build/events/common/enums/subjects/order-subjects.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Enum representing the subjects for different order events.
+ */
+export declare enum OrderSubjects {
+    /**
+     * The subject for order cancelled events.
+     */
+    OrderCancelled = "order.cancelled",
+    /**
+     * The subject for order requested events.
+     */
+    OrderRequested = "order.requested",
+    /**
+     * The subject for order completed events.
+     */
+    OrderCompleted = "order.completed"
+}

package/build/events/common/enums/subjects/order-subjects.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSubjects = void 0;
+/**
+ * Enum representing the subjects for different order events.
+ */
+var OrderSubjects;
+(function (OrderSubjects) {
+    /**
+     * The subject for order cancelled events.
+     */
+    OrderSubjects["OrderCancelled"] = "order.cancelled";
+    /**
+     * The subject for order requested events.
+     */
+    OrderSubjects["OrderRequested"] = "order.requested";
+    /**
+     * The subject for order completed events.
+     */
+    OrderSubjects["OrderCompleted"] = "order.completed";
+})(OrderSubjects || (exports.OrderSubjects = OrderSubjects = {}));

package/build/events/common/enums/subjects/payment-subjects.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enum representing the subjects for different payment events.
+ */
+export declare enum PaymentSubjects {
+    /**
+     * The subject for payment created events.
+     */
+    PaymentCreated = "payment.created",
+    /**
+     * The subject for payment failed events.
+     */
+    PaymentFailed = "payment.failed"
+}

package/build/events/common/enums/subjects/payment-subjects.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentSubjects = void 0;
+/**
+ * Enum representing the subjects for different payment events.
+ */
+var PaymentSubjects;
+(function (PaymentSubjects) {
+    /**
+     * The subject for payment created events.
+     */
+    PaymentSubjects["PaymentCreated"] = "payment.created";
+    /**
+     * The subject for payment failed events.
+     */
+    PaymentSubjects["PaymentFailed"] = "payment.failed";
+})(PaymentSubjects || (exports.PaymentSubjects = PaymentSubjects = {}));

package/build/events/common/interfaces/order-events-interfaces/order-cancelled-event.d.ts

@@ -0,0 +1,15 @@
+import { OrderDurableName } from '../../enums/durable-names/order-dname';
+import { OrderStream } from '../../enums/streams/order-stream';
+import { OrderSubjects } from '../../enums/subjects/order-subjects';
+export interface OrderCancelledEvent {
+    subject: OrderSubjects.OrderCancelled;
+    durableName?: OrderDurableName.OrderCancelledDurablename;
+    stream: OrderStream.Order;
+    data: {
+        id: string;
+        version: number;
+        status: string;
+        userid: string;
+        tripid: string;
+    };
+}

package/build/events/common/interfaces/order-events-interfaces/order-cancelled-event.js

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

package/build/events/common/interfaces/order-events-interfaces/order-completed-event.d.ts

@@ -0,0 +1,15 @@
+import { OrderDurableName } from '../../enums/durable-names/order-dname';
+import { OrderStream } from '../../enums/streams/order-stream';
+import { OrderSubjects } from '../../enums/subjects/order-subjects';
+export interface OrderCompletedEvent {
+    subject: OrderSubjects.OrderCompleted;
+    durableName?: OrderDurableName.OrderCompletedDurablename;
+    stream: OrderStream.Order;
+    data: {
+        id: string;
+        version: number;
+        status: string;
+        userid: string;
+        tripid: string;
+    };
+}

package/build/events/common/interfaces/order-events-interfaces/order-completed-event.js

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

package/build/events/common/interfaces/order-events-interfaces/order-requested-event.d.ts

@@ -0,0 +1,15 @@
+import { OrderDurableName } from '../../enums/durable-names/order-dname';
+import { OrderStream } from '../../enums/streams/order-stream';
+import { OrderSubjects } from '../../enums/subjects/order-subjects';
+export interface OrderRequestedEvent {
+    subject: OrderSubjects.OrderRequested;
+    durableName?: OrderDurableName.OrderRequestDurablename;
+    stream: OrderStream.Order;
+    data: {
+        id: string;
+        version: number;
+        status: string;
+        userid: string;
+        tripid: string;
+    };
+}

package/build/events/common/interfaces/order-events-interfaces/order-requested-event.js

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

package/build/events/common/interfaces/payment-event-interfaces/payment-created-event.js

@@ -0,0 +1 @@
+"use strict";

package/build/events/common/interfaces/payment-event-interfaces/payment-failed-event.js

@@ -0,0 +1 @@
+"use strict";

package/build/events/common/interfaces/stream-interfaces/order-stream-interface.d.ts

@@ -0,0 +1,6 @@
+import { OrderStream } from '../../enums/streams/order-stream';
+import { MainSubjects } from '../../enums/subjects/main-subjects';
+export interface OrderStreamEvent {
+    subject: MainSubjects.ORDER;
+    stream: OrderStream.Order;
+}

package/build/events/common/interfaces/stream-interfaces/order-stream-interface.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hastehaul/common",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -27,6 +27,7 @@
     "express": "^4.18.2",
     "ioredis": "^5.3.2",
     "jsonwebtoken": "^9.0.1",
+    "nats": "^2.15.1",
     "socket.io": "^4.7.1"
   }
 }