@konplit-services/common 1.0.408 → 1.2.0

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

@@ -1,53 +0,0 @@
-/**
- * Publisher Module
- *
- * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
- * It ensures that the required stream exists before publishing events.
- *
- * @module Publisher
- */
-import { NatsConnection } from "nats";
-/**
- * Event Interface
- *
- * Represents an event that will be published to a NATS stream.
- *
- * @interface
- */
-interface Event {
-    subject: string;
-    data: any;
-}
-/**
- * Publisher Abstract Class
- *
- * Abstract class for publishing events to a NATS JetStream.
- * Subclasses should implement the specific subject, streamEvents, and stream properties.
- *
- * @abstract
- * @template T - The type of event to be published
- */
-export declare abstract class ResponsePublisher<T extends Event> {
-    private nc;
-    protected jc: import("nats").Codec<unknown>;
-    /**
-     * The subject associated with the event.
-     * @abstract
-     */
-    abstract subject: T["subject"];
-    /**
-     * Constructor for the Publisher class.
-     *
-     * @param {JetStreamClient} client - The NATS JetStream client
-     */
-    constructor(nc: NatsConnection);
-    /**
-     * Sends a request to another service and waits for a reply.
-     *
-     * @param {T["data"]} data - The data to be sent in the request
-     * @param {number} timeout - The timeout duration to wait for a response
-     * @returns {Promise<any>} - Resolves with the reply data from the responding service
-     */
-    request(data: T["data"], timeout?: number): Promise<any>;
-}
-export {};

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

@@ -1,68 +0,0 @@
-"use strict";
-/**
- * Publisher Module
- *
- * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
- * It ensures that the required stream exists before publishing events.
- *
- * @module Publisher
- */
-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.ResponsePublisher = void 0;
-const nats_1 = require("nats");
-/**
- * Publisher Abstract Class
- *
- * Abstract class for publishing events to a NATS JetStream.
- * Subclasses should implement the specific subject, streamEvents, and stream properties.
- *
- * @abstract
- * @template T - The type of event to be published
- */
-class ResponsePublisher {
-    /**
-     * Constructor for the Publisher class.
-     *
-     * @param {JetStreamClient} client - The NATS JetStream client
-     */
-    constructor(nc) {
-        this.jc = (0, nats_1.JSONCodec)();
-        this.nc = nc;
-    }
-    /**
-     * Sends a request to another service and waits for a reply.
-     *
-     * @param {T["data"]} data - The data to be sent in the request
-     * @param {number} timeout - The timeout duration to wait for a response
-     * @returns {Promise<any>} - Resolves with the reply data from the responding service
-     */
-    request(data, timeout = 1000 * 60 * 5) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Send request and wait for the response
-                const response = yield this.nc.request(this.subject, this.jc.encode(data), { timeout } // Timeout for the response
-                );
-                if (!response) {
-                    throw new Error("Failed to get Response");
-                }
-                const replyData = this.jc.decode(response.data);
-                console.log("Received Reply:", replyData);
-                return replyData;
-            }
-            catch (err) {
-                console.error("Error sending request:", err);
-                throw err;
-            }
-        });
-    }
-}
-exports.ResponsePublisher = ResponsePublisher;

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

@@ -1,112 +0,0 @@
-/**
- * Listener Module
- *
- * This module defines an abstract `Listener` class for listening to events from a NATS JetStream.
- * It ensures that the required stream and consumer exist before consuming events.
- *
- * @module Listener
- */
-import { JetStreamClient, JsMsg, NatsConnection, Msg } from "nats";
-import { StreamEvent, StreamName } from "../subjects";
-/**
- * Event Interface
- *
- * Represents an event that will be consumed from a NATS stream.
- *
- * @interface
- */
-interface Event {
-    subject: string;
-    streamEvents: StreamEvent;
-    streamName: StreamName;
-    data: any;
-}
-/**
- * Listener Abstract Class
- *
- * Abstract class for consuming events from a NATS JetStream.
- * Subclasses should implement the specific subject, streamEvents, stream, and durableName properties.
- *
- * @abstract
- * @template T - The type of event to be consumed
- */
-export declare abstract class Listener<T extends Event> {
-    private client;
-    private nc?;
-    private jc;
-    /**
-     * The subject associated with the event.
-     * @abstract
-     */
-    abstract subject: T["subject"];
-    /**
-     * The stream events associated with the event.
-     * @abstract
-     */
-    abstract streamEvents: T["streamEvents"];
-    /**
-     * The stream name associated with the event.
-     * @abstract
-     */
-    abstract stream: T["streamName"];
-    /**
-     * The durable name for the consumer.
-     * @abstract
-     */
-    abstract durableName: string;
-    /**
-     * Acknowledgment wait time of 5 seconds before retrying.
-     * @protected
-     */
-    protected ackWait: number;
-    /**
-     * Handles the incoming message.
-     * @abstract
-     * @param {T["data"]} data - The decoded data from the message
-     * @param {JsMsg} msg - The raw NATS message
-     */
-    abstract onMessage(data: T["data"], msg: JsMsg): void;
-    /**
-     * Handles the incoming message.
-     * @abstract
-     * @param {T["data"]} data - The decoded data from the message
-     * @param {JsMsg} msg - The raw NATS message
-     */
-    abstract onMessageResponse(data: T["data"], msg: Msg): any;
-    /**
-     * Constructor for the Listener class.
-     *
-     * @param {JetStreamClient} client - The NATS JetStream client
-     */
-    constructor(client: JetStreamClient, nc?: NatsConnection);
-    /**
-     * Sets up the listener by ensuring the stream and consumer exist,
-     * then starts consuming messages.
-     *
-     * @returns {Promise<void>} - Resolves when the listener is set up and consuming messages
-     */
-    listen(): Promise<void>;
-    listenForRequests(): Promise<void>;
-    /**
-     * Ensures the stream exists in the NATS JetStream.
-     * Creates the stream if it does not exist.
-     *
-     * @private
-     * @param {StreamName} streamName - The name of the stream
-     * @param {string[]} subjects - The subjects associated with the stream
-     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
-     */
-    private ensureStream;
-    /**
-     * Ensures the consumer exists in the NATS JetStream.
-     * Creates the consumer if it does not exist.
-     *
-     * @private
-     * @param {StreamName} streamName - The name of the stream
-     * @param {string} durableName - The durable name of the consumer
-     * @param {string} subject - The subject to filter for the consumer
-     * @returns {Promise<void>} - Resolves when the consumer is ensured to exist
-     */
-    private ensureConsumer;
-}
-export {};

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

@@ -1,207 +0,0 @@
-"use strict";
-/**
- * Listener Module
- *
- * This module defines an abstract `Listener` class for listening to events from a NATS JetStream.
- * It ensures that the required stream and consumer exist before consuming events.
- *
- * @module Listener
- */
-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.Listener = void 0;
-const nats_1 = require("nats");
-const nat_error_codes_1 = require("../../util/lib/nats/nat-error-codes");
-/**
- * Listener Abstract Class
- *
- * Abstract class for consuming events from a NATS JetStream.
- * Subclasses should implement the specific subject, streamEvents, stream, and durableName properties.
- *
- * @abstract
- * @template T - The type of event to be consumed
- */
-class Listener {
-    /**
-     * Constructor for the Listener class.
-     *
-     * @param {JetStreamClient} client - The NATS JetStream client
-     */
-    constructor(client, nc) {
-        this.jc = (0, nats_1.JSONCodec)();
-        /**
-         * Acknowledgment wait time of 5 seconds before retrying.
-         * @protected
-         */
-        this.ackWait = (0, nats_1.nanos)(5 * 60 * 1000); // acknowledge time of  5 minutes before retry
-        this.client = client;
-        this.nc = nc;
-    }
-    /**
-     * Sets up the listener by ensuring the stream and consumer exist,
-     * then starts consuming messages.
-     *
-     * @returns {Promise<void>} - Resolves when the listener is set up and consuming messages
-     */
-    listen() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Ensure the stream exists
-                yield this.ensureStream(this.stream, [this.streamEvents]);
-                // Ensure the consumer exists
-                yield this.ensureConsumer(this.stream, this.durableName, this.subject);
-                const consumer = yield this.client.consumers.get(this.stream, this.durableName);
-                yield consumer.consume({
-                    max_messages: 1,
-                    callback: (message) => {
-                        console.log("sequence number", message.seq);
-                        const data = this.jc.decode(message.data);
-                        this.onMessage(data, message);
-                    },
-                });
-            }
-            catch (err) {
-                console.error("Error setting up listener:", err);
-            }
-        });
-    }
-    listenForRequests() {
-        var _a, e_1, _b, _c;
-        var _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const subscription = (_d = this.nc) === null || _d === void 0 ? void 0 : _d.subscribe(this.subject);
-            try {
-                for (var _e = true, subscription_1 = __asyncValues(subscription), subscription_1_1; subscription_1_1 = yield subscription_1.next(), _a = subscription_1_1.done, !_a;) {
-                    _c = subscription_1_1.value;
-                    _e = false;
-                    try {
-                        const msg = _c;
-                        // Decode the request data
-                        const decodedRequest = this.jc.decode(msg.data);
-                        console.log("Received Request:", decodedRequest);
-                        const response = yield this.onMessageResponse(decodedRequest, msg);
-                        // Send a reply back
-                        msg.respond(this.jc.encode({ data: response }));
-                    }
-                    finally {
-                        _e = true;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_e && !_a && (_b = subscription_1.return)) yield _b.call(subscription_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        });
-    }
-    /**
-     * Ensures the stream exists in the NATS JetStream.
-     * Creates the stream if it does not exist.
-     *
-     * @private
-     * @param {StreamName} streamName - The name of the stream
-     * @param {string[]} subjects - The subjects associated with the stream
-     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
-     */
-    ensureStream(streamName, subjects) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const jsm = yield this.client.jetstreamManager();
-                yield jsm.streams.info(streamName);
-                console.log(`Stream '${streamName}' already exists`);
-            }
-            catch (err) {
-                console.log("Stream info retrieval error:", err.api_error);
-                if (((_a = err === null || err === void 0 ? void 0 : err.api_error) === null || _a === void 0 ? void 0 : _a.code) === 404 &&
-                    ((_b = err === null || err === void 0 ? void 0 : err.api_error) === null || _b === void 0 ? void 0 : _b.err_code) === nat_error_codes_1.NATS_ERROR.STREAM_NOT_FOUND) {
-                    try {
-                        const jsm = yield this.client.jetstreamManager();
-                        const streamConfig = {
-                            name: streamName,
-                            subjects,
-                            storage: nats_1.StorageType.File,
-                            max_consumers: -1,
-                            retention: nats_1.RetentionPolicy.Limits,
-                            max_msgs: 10000,
-                            max_bytes: 1 * 1024 * 1024 * 1024,
-                            max_age: (0, nats_1.nanos)(14 * 24 * 3600 * 1000), //2 weeks in milliseconds
-                        };
-                        yield jsm.streams.add(streamConfig);
-                        console.log(`Stream '${streamName}' created`);
-                    }
-                    catch (addErr) {
-                        console.error("Error creating stream:");
-                        throw addErr;
-                    }
-                }
-                else {
-                    throw err;
-                }
-            }
-        });
-    }
-    /**
-     * Ensures the consumer exists in the NATS JetStream.
-     * Creates the consumer if it does not exist.
-     *
-     * @private
-     * @param {StreamName} streamName - The name of the stream
-     * @param {string} durableName - The durable name of the consumer
-     * @param {string} subject - The subject to filter for the consumer
-     * @returns {Promise<void>} - Resolves when the consumer is ensured to exist
-     */
-    ensureConsumer(streamName, durableName, subject) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const jsm = yield this.client.jetstreamManager();
-            try {
-                yield jsm.consumers.info(streamName, durableName);
-                console.log(`Consumer '${durableName}' already exists`);
-            }
-            catch (err) {
-                if (((_a = err === null || err === void 0 ? void 0 : err.api_error) === null || _a === void 0 ? void 0 : _a.code) === 404 &&
-                    ((_b = err === null || err === void 0 ? void 0 : err.api_error) === null || _b === void 0 ? void 0 : _b.err_code) === nat_error_codes_1.NATS_ERROR.CONSUMER_NOT_FOUND) {
-                    try {
-                        const consumerConfig = {
-                            durable_name: durableName,
-                            ack_policy: nats_1.AckPolicy.Explicit,
-                            filter_subject: subject,
-                            deliver_policy: nats_1.DeliverPolicy.All,
-                            ack_wait: this.ackWait,
-                            max_deliver: 576, //5 minutes * 576 equals two days assuming the systme
-                        };
-                        yield jsm.consumers.add(streamName, consumerConfig);
-                        console.log(`Consumer '${durableName}' created`);
-                    }
-                    catch (addConsumerError) {
-                        console.error("Error creating stream:", addConsumerError);
-                        throw addConsumerError;
-                    }
-                }
-                else {
-                    throw err;
-                }
-            }
-        });
-    }
-}
-exports.Listener = Listener;

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

@@ -1,84 +0,0 @@
-/**
- * Publisher Module
- *
- * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
- * It ensures that the required stream exists before publishing events.
- *
- * @module Publisher
- */
-import { JetStreamClient, NatsConnection } from "nats";
-import { StreamEvent, StreamName } from "../subjects";
-/**
- * Event Interface
- *
- * Represents an event that will be published to a NATS stream.
- *
- * @interface
- */
-interface Event {
-    subject: string;
-    streamEvents: StreamEvent;
-    streamName: StreamName;
-    data: any;
-}
-/**
- * Publisher Abstract Class
- *
- * Abstract class for publishing events to a NATS JetStream.
- * Subclasses should implement the specific subject, streamEvents, and stream properties.
- *
- * @abstract
- * @template T - The type of event to be published
- */
-export declare abstract class Publisher<T extends Event> {
-    private client;
-    private nc?;
-    private jc;
-    /**
-     * The subject associated with the event.
-     * @abstract
-     */
-    abstract subject: T["subject"];
-    /**
-     * The stream events associated with the event.
-     * @abstract
-     */
-    abstract streamEvents: T["streamEvents"];
-    /**
-     * The stream name associated with the event.
-     * @abstract
-     */
-    abstract stream: T["streamName"];
-    /**
-     * Constructor for the Publisher class.
-     *
-     * @param {JetStreamClient} client - The NATS JetStream client
-     */
-    constructor(client: JetStreamClient, nc?: NatsConnection);
-    /**
-     * Publishes data to the NATS JetStream.
-     *
-     * @param {T["data"]} data - The data to be published
-     * @returns {Promise<void>} - Resolves when the data is published successfully
-     */
-    publish(data: T["data"]): Promise<void>;
-    /**
-     * Sends a request to another service and waits for a reply.
-     *
-     * @param {T["data"]} data - The data to be sent in the request
-     * @param {number} timeout - The timeout duration to wait for a response
-     * @returns {Promise<any>} - Resolves with the reply data from the responding service
-     */
-    request(data: T["data"], timeout?: number): Promise<any>;
-    /**
-     * Ensures the stream exists in the NATS JetStream.
-     * Creates the stream if it does not exist.
-     *
-     * @private
-     * @param {StreamName} streamName - The name of the stream
-     * @param {string[]} subjects - The subjects associated with the stream
-     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
-     */
-    private ensureStream;
-}
-export {};

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

@@ -1,141 +0,0 @@
-"use strict";
-/**
- * Publisher Module
- *
- * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
- * It ensures that the required stream exists before publishing events.
- *
- * @module Publisher
- */
-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.Publisher = void 0;
-const nats_1 = require("nats");
-const nat_error_codes_1 = require("../../util/lib/nats/nat-error-codes");
-/**
- * Publisher Abstract Class
- *
- * Abstract class for publishing events to a NATS JetStream.
- * Subclasses should implement the specific subject, streamEvents, and stream properties.
- *
- * @abstract
- * @template T - The type of event to be published
- */
-class Publisher {
-    /**
-     * Constructor for the Publisher class.
-     *
-     * @param {JetStreamClient} client - The NATS JetStream client
-     */
-    constructor(client, nc) {
-        this.jc = (0, nats_1.JSONCodec)();
-        this.client = client;
-        this.nc = nc;
-    }
-    /**
-     * Publishes data to the NATS JetStream.
-     *
-     * @param {T["data"]} data - The data to be published
-     * @returns {Promise<void>} - Resolves when the data is published successfully
-     */
-    publish(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    // Ensure the stream exists
-                    yield this.ensureStream(this.stream, [this.streamEvents]);
-                    yield this.client.publish(this.subject, this.jc.encode(data));
-                    console.log("Event Published");
-                    resolve();
-                }
-                catch (err) {
-                    console.error("Error publishing event:", err);
-                    reject(err);
-                }
-            }));
-        });
-    }
-    /**
-     * Sends a request to another service and waits for a reply.
-     *
-     * @param {T["data"]} data - The data to be sent in the request
-     * @param {number} timeout - The timeout duration to wait for a response
-     * @returns {Promise<any>} - Resolves with the reply data from the responding service
-     */
-    request(data, timeout = 5000) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Send request and wait for the response
-                const response = yield ((_a = this.nc) === null || _a === void 0 ? void 0 : _a.request(this.subject, this.jc.encode(data), { timeout } // Timeout for the response
-                ));
-                if (!response) {
-                    throw new Error("Failed to get Response");
-                }
-                const replyData = this.jc.decode(response.data);
-                console.log("Received Reply:", replyData);
-                return replyData;
-            }
-            catch (err) {
-                console.error("Error sending request:", err);
-                throw err;
-            }
-        });
-    }
-    /**
-     * Ensures the stream exists in the NATS JetStream.
-     * Creates the stream if it does not exist.
-     *
-     * @private
-     * @param {StreamName} streamName - The name of the stream
-     * @param {string[]} subjects - The subjects associated with the stream
-     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
-     */
-    ensureStream(streamName, subjects) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const jsm = yield this.client.jetstreamManager();
-                yield jsm.streams.info(streamName);
-                console.log(`Stream '${streamName}' already exists`);
-            }
-            catch (err) {
-                console.log("Stream info retrieval error:", err.api_error);
-                if (((_a = err === null || err === void 0 ? void 0 : err.api_error) === null || _a === void 0 ? void 0 : _a.code) === 404 &&
-                    ((_b = err === null || err === void 0 ? void 0 : err.api_error) === null || _b === void 0 ? void 0 : _b.err_code) === nat_error_codes_1.NATS_ERROR.STREAM_NOT_FOUND) {
-                    try {
-                        const jsm = yield this.client.jetstreamManager();
-                        const streamConfig = {
-                            name: streamName,
-                            subjects,
-                            storage: nats_1.StorageType.File,
-                            retention: nats_1.RetentionPolicy.Limits,
-                            max_consumers: -1,
-                            max_msgs: 10000,
-                            max_bytes: 5 * 1024 * 1024 * 1024,
-                            max_age: (0, nats_1.nanos)(14 * 24 * 3600 * 1000), //2 weeks in milliseconds
-                        };
-                        yield jsm.streams.add(streamConfig);
-                        console.log(`Stream '${streamName}' created`);
-                    }
-                    catch (addErr) {
-                        console.error("Error creating stream:");
-                        throw addErr;
-                    }
-                }
-                else {
-                    throw err;
-                }
-            }
-        });
-    }
-}
-exports.Publisher = Publisher;

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

@@ -1,8 +0,0 @@
-export declare enum EventResponseStatus {
-    Failed = "Failed",
-    Success = "Success"
-}
-export interface EventResponseData {
-    status: EventResponseStatus;
-    data: any;
-}

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

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventResponseStatus = void 0;
-var EventResponseStatus;
-(function (EventResponseStatus) {
-    EventResponseStatus["Failed"] = "Failed";
-    EventResponseStatus["Success"] = "Success";
-})(EventResponseStatus = exports.EventResponseStatus || (exports.EventResponseStatus = {}));