@hastehaul/common 1.0.12 → 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/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/package.json

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