@konplit-services/common 1.0.1

package/build/errors/notAuthorized.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class NotAuthorizedError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 401;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    error_code: this.error_data.error_code,
+                    code: this.error_data.code,
+                },
+            ],
+        };
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/request-validation-error.d.ts

@@ -0,0 +1,17 @@
+import { ValidationError } from "express-validator";
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+export declare class RequestValidationError extends CustomError {
+    private errors;
+    readonly statusCode = 400;
+    constructor(errors: ValidationError[]);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: any;
+            error_code: any;
+            field: string;
+            code: any;
+        }[];
+    };
+}

package/build/errors/request-validation-error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidationError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class RequestValidationError extends custom_error_1.CustomError {
+    constructor(errors) {
+        super("validation error");
+        this.errors = errors;
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestValidationError.prototype);
+    }
+    sequalizeErrors() {
+        const errors = this.errors.map((error) => {
+            return {
+                message: error.msg.message,
+                error_code: error.msg.error_code,
+                field: error.param,
+                code: error.msg.error_code,
+            };
+        });
+        return {
+            status: status_1.Status.Failed,
+            errors,
+        };
+    }
+}
+exports.RequestValidationError = RequestValidationError;

package/build/errors/service-not-available.d.ts

@@ -0,0 +1,17 @@
+import { Status } from "../helper/status";
+import { CustomError } from "./custom-error";
+import { ErrorReturn } from "./error.interface";
+export declare class ServiceNotAvailableError extends CustomError {
+    message: string;
+    private error_data;
+    readonly statusCode = 503;
+    constructor(message: string, error_data: ErrorReturn);
+    sequalizeErrors(): {
+        status: Status;
+        errors: {
+            message: string;
+            code: number;
+            error_code: string;
+        }[];
+    };
+}

package/build/errors/service-not-available.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNotAvailableError = void 0;
+const status_1 = require("../helper/status");
+const custom_error_1 = require("./custom-error");
+class ServiceNotAvailableError extends custom_error_1.CustomError {
+    constructor(message, error_data) {
+        super(message);
+        this.message = message;
+        this.error_data = error_data;
+        this.statusCode = 503;
+        this.error_data = error_data;
+        Object.setPrototypeOf(this, ServiceNotAvailableError.prototype);
+    }
+    sequalizeErrors() {
+        return {
+            status: status_1.Status.Failed,
+            errors: [
+                {
+                    message: this.message,
+                    code: this.error_data.code,
+                    error_code: this.error_data.error_code,
+                },
+            ],
+        };
+    }
+}
+exports.ServiceNotAvailableError = ServiceNotAvailableError;

package/build/events/accounts-events/interfaces/account-created.interface.d.ts

@@ -0,0 +1,11 @@
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface AccountCreatedEvent {
+    subject: Subjects.AccountCreated;
+    streamName: StreamName.name;
+    streamEvents: StreamEvent.Event;
+    data: {
+        title: string;
+        id: string;
+        price: number;
+    };
+}

package/build/events/accounts-events/interfaces/account-created.interface.js

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

package/build/events/accounts-events/interfaces/account-updated.interface.js

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

package/build/events/accounts-events/interfaces/permission-created.interface.d.ts

@@ -0,0 +1,12 @@
+import { Roles } from "../../../helper/roles";
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface PermissionCreatedEvent {
+    subject: Subjects.PermissionCreated;
+    streamName: StreamName.name;
+    streamEvents: StreamEvent.Event;
+    data: {
+        role: Roles;
+        id: string;
+        permission: string;
+    };
+}

package/build/events/accounts-events/interfaces/permission-created.interface.js

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

package/build/events/accounts-events/interfaces/permission-removed.interface.d.ts

@@ -0,0 +1,12 @@
+import { Roles } from "../../../helper/roles";
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface PermissionRemovedEvent {
+    subject: Subjects.PermissionRemoved;
+    streamName: StreamName.name;
+    streamEvents: StreamEvent.Event;
+    data: {
+        role: Roles;
+        id: string;
+        permission: string;
+    };
+}

package/build/events/accounts-events/interfaces/permission-removed.interface.js

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

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

@@ -0,0 +1,103 @@
+/**
+ * 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 } 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 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;
+    /**
+     * Constructor for the Listener class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(client: JetStreamClient);
+    /**
+     * 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>;
+    /**
+     * 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

@@ -0,0 +1,164 @@
+"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());
+    });
+};
+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) {
+        this.jc = (0, nats_1.JSONCodec)();
+        /**
+         * Acknowledgment wait time of 5 seconds before retrying.
+         * @protected
+         */
+        this.ackWait = (0, nats_1.nanos)(5 * 1000); // acknowledge time of  5 seconds before retry
+        this.client = client;
+    }
+    /**
+     * 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);
+            }
+        });
+    }
+    /**
+     * 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.Workqueue,
+                        };
+                        yield jsm.streams.add(streamConfig);
+                        console.log(`Stream '${streamName}' created`);
+                    }
+                    catch (addErr) {
+                        console.error("Error creating stream:", addErr);
+                        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: 20,
+                        };
+                        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

@@ -0,0 +1,75 @@
+/**
+ * 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 } 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 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);
+    /**
+     * 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>;
+    /**
+     * 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

@@ -0,0 +1,110 @@
+"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) {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.client = client;
+    }
+    /**
+     * 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);
+                }
+            }));
+        });
+    }
+    /**
+     * 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.Workqueue,
+                            max_consumers: -1,
+                        };
+                        yield jsm.streams.add(streamConfig);
+                        console.log(`Stream '${streamName}' created`);
+                    }
+                    catch (addErr) {
+                        console.error("Error creating stream:", addErr);
+                        throw addErr;
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+}
+exports.Publisher = Publisher;

package/build/events/logs-events/interfaces/admins-logs.created.interface.d.ts

@@ -0,0 +1,15 @@
+import { LOGACTIONS } from "../../../log-activities/actions";
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface AdminLogsCreatedEvent {
+    subject: Subjects.AdminLogCreated;
+    streamName: StreamName.logName;
+    streamEvents: StreamEvent.LOG;
+    data: {
+        id?: string;
+        role?: string;
+        email?: string;
+        action: LOGACTIONS;
+        data: any;
+        accountId?: string;
+    };
+}

package/build/events/logs-events/interfaces/admins-logs.created.interface.js

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

package/build/events/logs-events/interfaces/merchants-logs-created.interface.d.ts

@@ -0,0 +1,15 @@
+import { LOGACTIONS } from "../../../log-activities/actions";
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface MerchantLogsCreatedEvent {
+    subject: Subjects.MerchantLogCreated;
+    streamName: StreamName.logName;
+    streamEvents: StreamEvent.LOG;
+    data: {
+        id?: string;
+        email?: string;
+        role?: string;
+        action: LOGACTIONS;
+        data: any;
+        accountId?: string;
+    };
+}

package/build/events/logs-events/interfaces/merchants-logs-created.interface.js

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