@hastehaul/common 1.0.11 → 1.0.13

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

@@ -0,0 +1,8 @@
+import { ConnectionOptions, NatsConnection } from 'nats';
+declare class NatsWrapper {
+    private _client?;
+    get client(): NatsConnection;
+    connect(opts?: ConnectionOptions): Promise<void>;
+}
+export declare const natsWrapper: NatsWrapper;
+export {};

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

@@ -0,0 +1,31 @@
+"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");
+class NatsWrapper {
+    get client() {
+        if (!this._client)
+            throw new Error("Cannot access NATS CLIENT before connecting");
+        return this._client;
+    }
+    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)}`);
+            }
+        });
+    }
+}
+exports.natsWrapper = new NatsWrapper();

package/build/connections-wrappers/redis-connection-wrapper.d.ts

@@ -1,9 +1,26 @@
 import IORedis from "ioredis";
+/**
+ * A wrapper class for the Redis client to manage connections and provide a centralized client instance.
+ */
 export declare class RedisWrapper {
     private _redisClient?;
     private host;
     private port;
+    /**
+     * Get the Redis client instance.
+     *
+     * @throws {Error} - Throws an error if the Redis client is accessed before connecting.
+     * @returns {IORedis} - The Redis client instance.
+     */
     get client(): IORedis;
+    /**
+     * Connect to the Redis server using the specified host and port.
+     *
+     * The client instance will be stored in the `_redisClient` property for later access.
+     */
     connect(): void;
 }
+/**
+ * Singleton instance of the RedisWrapper class to provide a centralized Redis client connection.
+ */
 export declare const redisWrapper: RedisWrapper;

package/build/connections-wrappers/redis-connection-wrapper.js

@@ -5,16 +5,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.redisWrapper = exports.RedisWrapper = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
+/**
+ * A wrapper class for the Redis client to manage connections and provide a centralized client instance.
+ */
 class RedisWrapper {
     constructor() {
         this.host = "customer-redis-srv";
         this.port = 6379;
     }
+    /**
+     * Get the Redis client instance.
+     *
+     * @throws {Error} - Throws an error if the Redis client is accessed before connecting.
+     * @returns {IORedis} - The Redis client instance.
+     */
     get client() {
         if (!this._redisClient)
             throw new Error("Cannot access Redis Client before connecting");
         return this._redisClient;
     }
+    /**
+     * Connect to the Redis server using the specified host and port.
+     *
+     * The client instance will be stored in the `_redisClient` property for later access.
+     */
     connect() {
         this._redisClient = new ioredis_1.default({ host: this.host, port: this.port, maxRetriesPerRequest: null });
         this._redisClient.on("connect", function () {
@@ -26,4 +40,7 @@ class RedisWrapper {
     }
 }
 exports.RedisWrapper = RedisWrapper;
+/**
+ * Singleton instance of the RedisWrapper class to provide a centralized Redis client connection.
+ */
 exports.redisWrapper = new RedisWrapper();

package/build/connections-wrappers/socket-connection-wrapper.d.ts

@@ -1,9 +1,28 @@
 /// <reference types="node" />
 import http from "http";
 import { Server } from 'socket.io';
+/**
+ * A wrapper class for the Socket.IO server to manage connections and provide a centralized server instance.
+ */
 export declare class SocketWrapper {
     protected _io?: Server;
-    get io(): Server<import("socket.io/dist/typed-events").DefaultEventsMap, import("socket.io/dist/typed-events").DefaultEventsMap, import("socket.io/dist/typed-events").DefaultEventsMap, any>;
+    /**
+     * Get the Socket.IO server instance.
+     *
+     * @throws {Error} - Throws an error if the Socket.IO server is accessed before connecting.
+     * @returns {Server} - The Socket.IO server instance.
+     */
+    get io(): Server;
+    /**
+     * Connect to the Socket.IO server using the specified HTTP server.
+     *
+     * The server instance will be stored in the `_io` property for later access.
+     *
+     * @param {http.Server} httpServer - The HTTP server instance to attach Socket.IO to.
+     */
     connect(httpServer: http.Server): void;
 }
+/**
+ * Singleton instance of the SocketWrapper class to provide a centralized Socket.IO server connection.
+ */
 export declare const socketWrapper: SocketWrapper;

package/build/connections-wrappers/socket-connection-wrapper.js

@@ -2,12 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.socketWrapper = exports.SocketWrapper = void 0;
 const socket_io_1 = require("socket.io");
+/**
+ * A wrapper class for the Socket.IO server to manage connections and provide a centralized server instance.
+ */
 class SocketWrapper {
+    /**
+     * Get the Socket.IO server instance.
+     *
+     * @throws {Error} - Throws an error if the Socket.IO server is accessed before connecting.
+     * @returns {Server} - The Socket.IO server instance.
+     */
     get io() {
         if (!this._io)
             throw new Error("Cannot access IO Client before connecting");
         return this._io;
     }
+    /**
+     * Connect to the Socket.IO server using the specified HTTP server.
+     *
+     * The server instance will be stored in the `_io` property for later access.
+     *
+     * @param {http.Server} httpServer - The HTTP server instance to attach Socket.IO to.
+     */
     connect(httpServer) {
         this._io = new socket_io_1.Server(httpServer, {
             path: "/socket/",
@@ -22,4 +38,7 @@ class SocketWrapper {
     }
 }
 exports.SocketWrapper = SocketWrapper;
+/**
+ * Singleton instance of the SocketWrapper class to provide a centralized Socket.IO server connection.
+ */
 exports.socketWrapper = new SocketWrapper();

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

@@ -0,0 +1,26 @@
+import { NatsConnection, ConsumerConfig, JsMsg } from "nats";
+import { DurableName, Subjects, Streams } from "../common/enums";
+import { MainSubjects, ValidateSubjectFormat } from "../common/enums/subjects/main-subjects";
+interface Event {
+    subject: ValidateSubjectFormat<Subjects, MainSubjects>;
+    durableName?: DurableName;
+    stream: Streams;
+    data: any;
+}
+export declare abstract class NatsConsumer<T extends Event> {
+    protected client: NatsConnection;
+    protected jc: import("nats").Codec<T>;
+    protected sc: import("nats").Codec<string>;
+    abstract stream: T["stream"];
+    abstract subject: T["subject"];
+    abstract durableName: T["durableName"];
+    abstract maxConcurrentMessages: number;
+    protected ackWait: number;
+    constructor(client: NatsConnection);
+    get consumerOptions(): Partial<ConsumerConfig>;
+    consume(): Promise<void>;
+    abstract processMessage(data: T["data"], msg: JsMsg): Promise<void>;
+    protected close(): Promise<void>;
+    protected parsedMessage: (msg: JsMsg) => string | T;
+}
+export {};

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

@@ -0,0 +1,96 @@
+"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");
+class NatsConsumer {
+    constructor(client) {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.sc = (0, nats_1.StringCodec)();
+        this.ackWait = (0, nats_1.nanos)(5 * 1000);
+        this.parsedMessage = (msg) => typeof msg.data === "string" ? this.sc.decode(msg.data) : this.jc.decode(msg.data);
+        this.client = client;
+    }
+    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() {
+        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");
+            }
+        });
+    }
+    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,14 @@
+import { PubAck, NatsConnection } from "nats";
+import { Subjects } from "../common/enums";
+import { MainSubjects, ValidateSubjectFormat } from "../common/enums/subjects/main-subjects";
+interface Event {
+    subject: ValidateSubjectFormat<Subjects, MainSubjects>;
+    data: any;
+}
+export declare abstract class NatsPublisher<T extends Event> {
+    private jc;
+    private sc;
+    abstract subject: T["subject"];
+    publish(nc: NatsConnection, data: T["data"]): Promise<PubAck>;
+}
+export {};

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

@@ -0,0 +1,32 @@
+"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");
+class NatsPublisher {
+    constructor() {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.sc = (0, nats_1.StringCodec)();
+    }
+    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,13 @@
+import { NatsConnection } from "nats";
+import { Streams } from "../common/enums";
+import { MainSubjects } from "../common/enums/subjects/main-subjects";
+interface Event {
+    subject: MainSubjects;
+    stream: Streams;
+}
+export declare abstract class NatsStream<T extends Event> {
+    abstract subject: T["subject"];
+    abstract stream: T['stream'];
+    init(client: NatsConnection): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,28 @@
+"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;
+class NatsStream {
+    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,3 @@
+import { PaymentDurableName } from "./payment-dname";
+import { OrderDurableName } from "./order-dname";
+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,5 @@
+export declare enum OrderDurableName {
+    OrderCancelledDurablename = "order-cancelled-consumer",
+    OrderRequestDurablename = "order-requested-consumer",
+    OrderCompletedDurablename = "order-completed-consumer"
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderDurableName = void 0;
+var OrderDurableName;
+(function (OrderDurableName) {
+    OrderDurableName["OrderCancelledDurablename"] = "order-cancelled-consumer";
+    OrderDurableName["OrderRequestDurablename"] = "order-requested-consumer";
+    OrderDurableName["OrderCompletedDurablename"] = "order-completed-consumer";
+})(OrderDurableName || (exports.OrderDurableName = OrderDurableName = {}));

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

@@ -0,0 +1,4 @@
+export declare enum PaymentDurableName {
+    PaymentFailedDurableName = "payment-failed-consumer",
+    PaymentCreatedDurableName = "payment-created-consumer"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentDurableName = void 0;
+var PaymentDurableName;
+(function (PaymentDurableName) {
+    PaymentDurableName["PaymentFailedDurableName"] = "payment-failed-consumer";
+    PaymentDurableName["PaymentCreatedDurableName"] = "payment-created-consumer";
+})(PaymentDurableName || (exports.PaymentDurableName = PaymentDurableName = {}));

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

@@ -0,0 +1,3 @@
+export * from "./durable-names";
+export * from "./streams";
+export * from "./subjects";

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

@@ -0,0 +1,19 @@
+"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("./durable-names"), exports);
+__exportStar(require("./streams"), exports);
+__exportStar(require("./subjects"), exports);

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

@@ -0,0 +1,3 @@
+import { PaymentStream } from './payment-stream';
+import { OrderStream } from './order-stream';
+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,3 @@
+export declare enum OrderStream {
+    Order = "ORDER"
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderStream = void 0;
+var OrderStream;
+(function (OrderStream) {
+    OrderStream["Order"] = "ORDER";
+})(OrderStream || (exports.OrderStream = OrderStream = {}));

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

@@ -0,0 +1,3 @@
+export declare enum PaymentStream {
+    Payment = "PAYMENT"
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentStream = void 0;
+var PaymentStream;
+(function (PaymentStream) {
+    PaymentStream["Payment"] = "PAYMENT";
+})(PaymentStream || (exports.PaymentStream = PaymentStream = {}));

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

@@ -0,0 +1,3 @@
+import { PaymentSubjects } from './payment-subjects';
+import { OrderSubjects } from './order-subjects';
+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,10 @@
+export declare enum MainSubjects {
+    ORDER = "order.*",
+    PAYMENT = "payment.*",
+    ETA = "eta.*"
+}
+type SubjectFormat<T extends string, U extends string> = `${T}.${U}`;
+type ExtractStringBeforeColon<T extends string> = T extends `${infer StringBeforeColon}.*` ? StringBeforeColon : never;
+export type ValidateSubjectFormat<T extends string, U extends string> = U extends MainSubjects ? T extends SubjectFormat<ExtractStringBeforeColon<MainSubjects>, string> ? T : never : never;
+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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadEnumValues = exports.MainSubjects = void 0;
+var MainSubjects;
+(function (MainSubjects) {
+    MainSubjects["ORDER"] = "order.*";
+    MainSubjects["PAYMENT"] = "payment.*";
+    MainSubjects["ETA"] = "eta.*";
+})(MainSubjects || (exports.MainSubjects = MainSubjects = {}));
+const spreadEnumValues = (enumObject) => Object.values(enumObject);
+exports.spreadEnumValues = spreadEnumValues;

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

@@ -0,0 +1,5 @@
+export declare enum OrderSubjects {
+    OrderCancelled = "order.cancelled",
+    OrderRequested = "order.requested",
+    OrderCompleted = "order.completed"
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSubjects = void 0;
+var OrderSubjects;
+(function (OrderSubjects) {
+    OrderSubjects["OrderCancelled"] = "order.cancelled";
+    OrderSubjects["OrderRequested"] = "order.requested";
+    OrderSubjects["OrderCompleted"] = "order.completed";
+})(OrderSubjects || (exports.OrderSubjects = OrderSubjects = {}));

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

@@ -0,0 +1,4 @@
+export declare enum PaymentSubjects {
+    PaymentCreated = "payment.created",
+    PaymentFailed = "payment.failed"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentSubjects = void 0;
+var PaymentSubjects;
+(function (PaymentSubjects) {
+    PaymentSubjects["PaymentCreated"] = "payment.created";
+    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/build/middlewares/current-user.d.ts

@@ -1,2 +1,11 @@
 import { Request, Response, NextFunction } from "express";
+/**
+ * Middleware function to extract the current user from the request's Authorization header.
+ *
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ *
+ * @returns {Promise<void>} - A Promise that resolves once the user extraction is complete, but it is not used directly.
+ */
 export declare const currentUser: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/build/middlewares/current-user.js

@@ -34,26 +34,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.currentUser = void 0;
 const jsonwebtoken_1 = __importStar(require("jsonwebtoken"));
+/**
+ * Middleware function to extract the current user from the request's Authorization header.
+ *
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ *
+ * @returns {Promise<void>} - A Promise that resolves once the user extraction is complete, but it is not used directly.
+ */
 const currentUser = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     let result = null;
     try {
+        // Extract the Bearer token from the Authorization header.
         const bearerToken = req.headers["authorization"];
         if (typeof bearerToken !== "undefined" && bearerToken) {
             const token = bearerToken.split(" ")[1];
             if (token) {
+                // Verify the JWT token and decode the user payload.
                 result = jsonwebtoken_1.default.verify(token, process.env.JWT_KEY.split("-").join(""));
             }
         }
+        // Attach the user payload to the request object for later use in the application.
         req.currentUser = result;
     }
     catch (err) {
+        // Handle errors related to token verification or expiration.
         if (err instanceof jsonwebtoken_1.TokenExpiredError) {
+            // If the token is expired, you may consider refreshing the token or taking appropriate actions.
+            // Uncomment the following line if you want to handle token expiration using the AuthController.
+            // await AuthController.refreshToken(req, res);
             // await AuthController.refreshToken(req, res)
         }
         else {
+            // If any other error occurs during token verification, set currentUser to null.
             req.currentUser = null;
         }
     }
+    // Call the next middleware in the chain.
     next();
 });
 exports.currentUser = currentUser;

package/build/middlewares/error-handler.d.ts

@@ -1,2 +1,10 @@
 import { NextFunction, Request, Response } from "express";
+/**
+ * Express error handling middleware to handle custom errors and provide appropriate responses.
+ *
+ * @param {Error} err - The error object that needs to be handled.
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ */
 export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/build/middlewares/error-handler.js

@@ -3,6 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
 const custom_error_1 = require("../errors/custom-error");
 const enums_1 = require("../utils/enums");
+/**
+ * Express error handling middleware to handle custom errors and provide appropriate responses.
+ *
+ * @param {Error} err - The error object that needs to be handled.
+ * @param {Request} req - The Express Request object.
+ * @param {Response} res - The Express Response object.
+ * @param {NextFunction} next - The next function in the middleware chain.
+ */
 const errorHandler = (err, req, res, next) => {
     if (err instanceof custom_error_1.CustomError) {
         return res.status(err.statusCode).send({ errors: err.serializeErrors() });

package/build/utils/base_classes/jobs/base-producers.d.ts

@@ -1,7 +1,23 @@
 import { Queue } from "bullmq";
+/**
+ * Abstract class representing a Job Queue.
+ */
 export declare abstract class AbstractJobQueue {
     protected que: Queue;
     protected abstract jobName: string;
+    /**
+     * Creates an instance of AbstractJobQueue.
+     *
+     * @param {string} queueName - The name of the job queue.
+     */
     constructor(queueName: string);
+    /**
+   * Abstract method to add jobs to the job queue.
+   *
+   * This method should be implemented by subclasses to add specific jobs to the queue.
+   *
+   * @param {any} data - The data representing the job to be added to the queue.
+   * @returns {Promise<void>} - A Promise that resolves when the job is added to the queue successfully.
+   */
     abstract addJobs(data: any): Promise<void>;
 }

package/build/utils/base_classes/jobs/base-producers.js

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractJobQueue = void 0;
 const bullmq_1 = require("bullmq");
 const connections_wrappers_1 = require("../../../connections-wrappers");
-// Define the abstract class
+/**
+ * Abstract class representing a Job Queue.
+ */
 class AbstractJobQueue {
+    /**
+     * Creates an instance of AbstractJobQueue.
+     *
+     * @param {string} queueName - The name of the job queue.
+     */
     constructor(queueName) {
+        // Initialize the job queue with the provided name and a Redis connection from the redisWrapper.
         this.que = new bullmq_1.Queue(queueName, { connection: connections_wrappers_1.redisWrapper.client });
     }
 }

package/build/utils/base_classes/jobs/base-worker.d.ts

@@ -1,6 +1,22 @@
 import { Job, Worker } from "bullmq";
+/**
+ * Abstract class representing a worker for processing jobs from a Job Queue.
+ */
 export declare abstract class AbstractWorker {
     protected worker: Worker;
+    /**
+     * Creates an instance of AbstractWorker.
+     *
+     * @param {string} queueName - The name of the job queue that this worker will process jobs from.
+     */
     constructor(queueName: string);
+    /**
+     * Abstract method to process jobs retrieved from the job queue.
+     *
+     * This method should be implemented by subclasses to handle specific job processing logic.
+     *
+     * @param {Job} job - The job object representing the job to be processed.
+     * @returns {Promise<void>} - A Promise that resolves when the job processing is completed successfully.
+     */
     protected abstract process(job: Job): Promise<void>;
 }

package/build/utils/base_classes/jobs/base-worker.js

@@ -3,15 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractWorker = void 0;
 const bullmq_1 = require("bullmq");
 const connections_wrappers_1 = require("../../../connections-wrappers");
+/**
+ * Abstract class representing a worker for processing jobs from a Job Queue.
+ */
 class AbstractWorker {
+    /**
+     * Creates an instance of AbstractWorker.
+     *
+     * @param {string} queueName - The name of the job queue that this worker will process jobs from.
+     */
     constructor(queueName) {
+        // Create a worker instance with the provided queueName and bind the 'process' method to this worker.
         this.worker = new bullmq_1.Worker(queueName, this.process.bind(this), {
             connection: connections_wrappers_1.redisWrapper.client,
             autorun: false,
         });
+        // Handle errors that may occur during job processing.
         this.worker.on("error", (err) => {
             console.error(`${queueName} Error: `, err);
         });
+        // Start the worker in non-autorun mode, which means it won't start processing jobs automatically.
         console.log(" --- WORKER STARTED --- ", queueName);
         this.worker.run();
     }

package/build/utils/random-codes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generates random codes as an async function using await.
+ *
+ * @param {string} characters - The set of characters to use for generating codes.
+ * @param {number} numberOfCodes - The total number of codes to generate.
+ * @param {number} codeSize - The size of each individual code (number of characters).
+ * @param {boolean} includeHyphens - Whether to include hyphens between codes.
+ * @param {number} chunkSize - The number of codes to generate in each chunk (iteration).
+ *
+ * @returns {Promise<string>} - A Promise that resolves with the generated codes as a string.
+ */
+declare function generateRandomCodesAsync(characters: string, numberOfCodes: number, codeSize: number, includeHyphens: boolean, chunkSize: number): Promise<string>;

package/build/utils/random-codes.js

@@ -0,0 +1,52 @@
+"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());
+    });
+};
+/**
+ * Generates random codes as an async function using await.
+ *
+ * @param {string} characters - The set of characters to use for generating codes.
+ * @param {number} numberOfCodes - The total number of codes to generate.
+ * @param {number} codeSize - The size of each individual code (number of characters).
+ * @param {boolean} includeHyphens - Whether to include hyphens between codes.
+ * @param {number} chunkSize - The number of codes to generate in each chunk (iteration).
+ *
+ * @returns {Promise<string>} - A Promise that resolves with the generated codes as a string.
+ */
+function generateRandomCodesAsync(characters, numberOfCodes, codeSize, includeHyphens, chunkSize) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let codes = "";
+        let hyphen = includeHyphens ? "-" : "";
+        let chunkStart = 0;
+        let generatedCodes = new Set();
+        function generateChunk() {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (let i = chunkStart; i < chunkStart + chunkSize && i < numberOfCodes; i++) {
+                    let code = "";
+                    for (let j = 0; j < codeSize; j++) {
+                        code += characters.charAt(Math.floor(Math.random() * characters.length));
+                    }
+                    if (!generatedCodes.has(code)) {
+                        generatedCodes.add(code);
+                        codes += code + (i === numberOfCodes - 1 ? "" : hyphen);
+                    }
+                    else {
+                        i--;
+                    }
+                }
+                chunkStart += chunkSize;
+                if (chunkStart < numberOfCodes && generatedCodes.size < numberOfCodes) {
+                    yield generateChunk();
+                }
+            });
+        }
+        yield generateChunk();
+        return codes;
+    });
+}

package/build/utils/read-dir.js

@@ -39,13 +39,3 @@ function readDirectoryRecursive(dirPath, filter) {
     });
 }
 exports.readDirectoryRecursive = readDirectoryRecursive;
-// // Example usage:
-// const directoryPath = '/path/to/your/directory';
-// (async () => {
-//   try {
-//     const filteredFiles = await readDirectoryRecursive(directoryPath, (filePath) => filePath.endsWith('.txt'));
-//     console.log(filteredFiles);
-//   } catch (err) {
-//     console.error('Error occurred:', err);
-//   }
-// })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hastehaul/common",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "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"
   }
 }