@itdigitalwing/aladdin-common 1.0.281 → 1.0.282

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerTest = void 0;
+const eventTracking_1 = require("../services/eventTracking");
+class ListenerTest {
+    constructor(client) {
+        this.ackWait = 5 * 1000;
+        this.client = client;
+    }
+    subscriptionOptions() {
+        return this.client
+            .subscriptionOptions()
+            .setDeliverAllAvailable()
+            .setManualAckMode(true)
+            .setAckWait(this.ackWait)
+            .setDurableName(this.queueGroupName);
+    }
+    listen() {
+        const subscription = this.client.subscribe(this.subject, this.queueGroupName, this.subscriptionOptions());
+        subscription.on("message", (msg) => {
+            var _a;
+            console.log(`Message received: ${this.subject} / ${this.queueGroupName}`);
+            const CURRENT_SERVICE = process.env.CURRENT_SERVICE;
+            if (!CURRENT_SERVICE) {
+                console.log("🚨🚨 CURRENT_SERVICE name is note added to the env.");
+            }
+            const { data, eventDetails } = this.parseMessage(msg);
+            if ((_a = eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.dependencyServicesArray) === null || _a === void 0 ? void 0 : _a.includes(CURRENT_SERVICE)) {
+                (0, eventTracking_1.updateEventListenArray)({
+                    id: eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.id,
+                    listenedService: CURRENT_SERVICE,
+                })
+                    .then((result) => {
+                    var _a;
+                    console.log(JSON.stringify({ data, eventDetails, CURRENT_SERVICE, result }, null, 2));
+                    if ((_a = eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.dependencyServicesArray) === null || _a === void 0 ? void 0 : _a.includes(CURRENT_SERVICE)) {
+                        this.onMessage(data, msg);
+                    }
+                })
+                    .catch((error) => {
+                    console.log(error);
+                });
+            }
+            else {
+                msg.ack();
+            }
+        });
+    }
+    parseMessage(msg) {
+        const data = msg.getData();
+        return typeof data === "string"
+            ? JSON.parse(data)
+            : JSON.parse(data.toString("utf8"));
+    }
+}
+exports.ListenerTest = ListenerTest;

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

@@ -0,0 +1,21 @@
+import { Kafka, Consumer, EachMessagePayload } from "kafkajs";
+import { Subjects } from "./subjects";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class ListenerV2<T extends Event> {
+    abstract subject: T["subject"];
+    abstract queueGroupName: string;
+    abstract onMessage(data: T["data"], msg: EachMessagePayload, consumer: Consumer): void;
+    private consumer;
+    protected ackWait: number;
+    private client;
+    private CURRENT_SERVICE;
+    constructor(client: Kafka);
+    private setupConsumer;
+    listen(): void;
+    parseMessage(message: EachMessagePayload["message"]): any;
+    ack(consumer: Consumer, msg: EachMessagePayload): void;
+}
+export {};

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

@@ -0,0 +1,121 @@
+"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.ListenerV2 = void 0;
+const eventTracking_1 = require("../services/eventTracking");
+class ListenerV2 {
+    constructor(client) {
+        this.ackWait = 5 * 1000;
+        this.CURRENT_SERVICE = process.env.CURRENT_SERVICE;
+        this.client = client; // Save the Kafka client
+    }
+    // Method to initialize the consumer with the correct groupId and connect it
+    setupConsumer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Initialize the consumer with the queueGroupName
+                this.consumer = this.client.consumer({
+                    groupId: this.queueGroupName,
+                    retry: {
+                        retries: 10,
+                        initialRetryTime: 300,
+                        maxRetryTime: 5000,
+                    },
+                });
+                // Connect and subscribe the consumer
+                yield this.consumer.connect();
+                yield this.consumer.subscribe({
+                    topic: this.subject.replace(":", "-"),
+                    fromBeginning: true,
+                });
+            }
+            catch (error) {
+                // this.listen();
+                throw error;
+            }
+        });
+    }
+    // Listen method adapted for Kafka
+    listen() {
+        this.setupConsumer()
+            .then(() => {
+            if (!this.consumer) {
+                throw new Error("Consumer is not initialized");
+            }
+            this.consumer.run({
+                autoCommit: false,
+                eachMessage: (payload) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    try {
+                        const { topic } = payload;
+                        console.log(`Message received: ${topic} / ${this.queueGroupName}`);
+                        const { data, eventDetails } = this.parseMessage(payload.message);
+                        // event tracker
+                        if ((_a = eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.dependencyServicesArray) === null || _a === void 0 ? void 0 : _a.includes(this.CURRENT_SERVICE)) {
+                            yield (0, eventTracking_1.updateEventListenArray)({
+                                id: eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.id,
+                                listenedService: this.CURRENT_SERVICE,
+                            });
+                        }
+                        if (!this.consumer) {
+                            //
+                            throw new Error("Consumer is not initialized");
+                        }
+                        // call onMessage function if service exist in dependencyServicesArray
+                        if ((_b = eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.dependencyServicesArray) === null || _b === void 0 ? void 0 : _b.includes(this.CURRENT_SERVICE))
+                            this.onMessage(data, payload, this.consumer);
+                        else {
+                            this.consumer.commitOffsets([
+                                {
+                                    topic: payload.topic,
+                                    offset: (parseInt(payload.message.offset) + 1).toString(),
+                                    partition: payload.partition,
+                                },
+                            ]);
+                        }
+                    }
+                    catch (error) {
+                        console.log("eachMessage ===>", error);
+                    }
+                }),
+            });
+        })
+            .catch((err) => console.error("Error during listener setup:", err));
+    }
+    // Parse the Kafka message
+    parseMessage(message) {
+        var _a;
+        const data = (_a = message.value) === null || _a === void 0 ? void 0 : _a.toString();
+        try {
+            return data ? JSON.parse(data) : {};
+        }
+        catch (error) {
+            console.error("Error parsing message:", error);
+            return {}; // Return an empty object or handle accordingly
+        }
+    }
+    ack(consumer, msg) {
+        try {
+            consumer.commitOffsets([
+                {
+                    topic: msg.topic,
+                    offset: (parseInt(msg.message.offset) + 1).toString(),
+                    partition: msg.partition,
+                },
+            ]);
+            console.log(`✅ Message acknowledged for topic ${msg.topic}, partition ${msg.partition}, offset ${msg.message.offset}`);
+        }
+        catch (err) {
+            console.error("Error committing offsets:", err);
+        }
+    }
+}
+exports.ListenerV2 = ListenerV2;

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

@@ -0,0 +1,18 @@
+import { Message, Stan } from "node-nats-streaming";
+import { Subjects } from "./subjects";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Listener<T extends Event> {
+    abstract subject: T["subject"];
+    abstract queueGroupName: string;
+    abstract onMessage(data: T["data"], msg: Message): void;
+    private client;
+    protected ackWait: number;
+    constructor(client: Stan);
+    subscriptionOptions(): import("node-nats-streaming").SubscriptionOptions;
+    listen(): void;
+    parseMessage(msg: Message): any;
+}
+export {};

package/build/events/base-listener.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+const eventTracking_1 = require("../services/eventTracking");
+class Listener {
+    constructor(client) {
+        this.ackWait = 5 * 1000;
+        this.client = client;
+    }
+    subscriptionOptions() {
+        return this.client
+            .subscriptionOptions()
+            .setDeliverAllAvailable()
+            .setManualAckMode(true)
+            .setAckWait(this.ackWait)
+            .setDurableName(this.queueGroupName);
+    }
+    listen() {
+        const subscription = this.client.subscribe(this.subject, this.queueGroupName, this.subscriptionOptions());
+        subscription.on("message", (msg) => {
+            var _a;
+            console.log(`Message received: ${this.subject} / ${this.queueGroupName}`);
+            const CURRENT_SERVICE = process.env.CURRENT_SERVICE;
+            if (!CURRENT_SERVICE) {
+                console.log("🚨🚨 CURRENT_SERVICE name is note added to the env.");
+            }
+            const { data, eventDetails } = this.parseMessage(msg);
+            if ((_a = eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.dependencyServicesArray) === null || _a === void 0 ? void 0 : _a.includes(CURRENT_SERVICE)) {
+                (0, eventTracking_1.updateEventListenArray)({
+                    id: eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.id,
+                    listenedService: CURRENT_SERVICE,
+                })
+                    .then((result) => {
+                    // console.log(
+                    //   JSON.stringify(
+                    //     { data, eventDetails, CURRENT_SERVICE, result },
+                    //     null,
+                    //     2
+                    //   )
+                    // );
+                    var _a;
+                    if ((_a = eventDetails === null || eventDetails === void 0 ? void 0 : eventDetails.dependencyServicesArray) === null || _a === void 0 ? void 0 : _a.includes(CURRENT_SERVICE)) {
+                        this.onMessage(data, msg);
+                    }
+                })
+                    .catch((error) => {
+                    console.log(error);
+                });
+            }
+            else {
+                msg.ack();
+            }
+        });
+    }
+    parseMessage(msg) {
+        const data = msg.getData();
+        return typeof data === "string"
+            ? JSON.parse(data)
+            : JSON.parse(data.toString("utf8"));
+    }
+}
+exports.Listener = Listener;
+// previous without event management
+// import { Message, Stan } from "node-nats-streaming";
+// import { Subjects } from "./subjects";
+// interface Event {
+//   subject: Subjects;
+//   data: any;
+// }
+// export abstract class Listener<T extends Event> {
+//   abstract subject: T["subject"];
+//   abstract queueGroupName: string;
+//   abstract onMessage(data: T["data"], msg: Message): void;
+//   private client: Stan;
+//   protected ackWait = 5 * 1000;
+//   constructor(client: Stan) {
+//     this.client = client;
+//   }
+//   subscriptionOptions() {
+//     return this.client
+//       .subscriptionOptions()
+//       .setDeliverAllAvailable()
+//       .setManualAckMode(true)
+//       .setAckWait(this.ackWait)
+//       .setDurableName(this.queueGroupName);
+//   }
+//   listen() {
+//     const subscription = this.client.subscribe(
+//       this.subject,
+//       this.queueGroupName,
+//       this.subscriptionOptions()
+//     );
+//     subscription.on("message", (msg: Message) => {
+//       console.log(`Message received: ${this.subject} / ${this.queueGroupName}`);
+//       const parsedData = this.parseMessage(msg);
+//       this.onMessage(parsedData, msg);
+//     });
+//   }
+//   parseMessage(msg: Message) {
+//     const data = msg.getData();
+//     return typeof data === "string"
+//       ? JSON.parse(data)
+//       : JSON.parse(data.toString("utf8"));
+//   }
+// }

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

@@ -0,0 +1,16 @@
+import { Stan } from "node-nats-streaming";
+import { Subjects } from "./subjects";
+import { PUBLISHER_SERVICE_TYPE } from "./eventTypes";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class PublisherTest<T extends Event> {
+    abstract subject: T["subject"];
+    abstract dependencyServicesArray: PUBLISHER_SERVICE_TYPE[];
+    private client;
+    private CURRENT_SERVICE;
+    constructor(client: Stan);
+    publish(data: T["data"]): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublisherTest = void 0;
+const eventTracking_1 = require("../services/eventTracking");
+class PublisherTest {
+    constructor(client) {
+        this.CURRENT_SERVICE = process.env.CURRENT_SERVICE;
+        this.client = client;
+    }
+    publish(data) {
+        return new Promise((resolve, reject) => {
+            (0, eventTracking_1.insertEventToCollection)({
+                data,
+                subject: this.subject,
+                dependencyServicesArray: this.dependencyServicesArray,
+                publisherService: process.env.CURRENT_SERVICE,
+            })
+                .then(({ insertedId }) => {
+                this.client.publish(this.subject, JSON.stringify({
+                    data,
+                    eventDetails: {
+                        dependencyServicesArray: this.dependencyServicesArray.filter((item) => item !== this.CURRENT_SERVICE),
+                        id: insertedId,
+                    },
+                }), (err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    console.log("Event published to subject", this.subject);
+                    resolve();
+                });
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+}
+exports.PublisherTest = PublisherTest;

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

@@ -0,0 +1,15 @@
+import { Producer } from "kafkajs";
+import { Subjects } from "./subjects";
+import { PUBLISHER_SERVICE_TYPE } from "./eventTypes";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class PublisherV2<T extends Event> {
+    abstract subject: T["subject"];
+    abstract dependencyServicesArray: PUBLISHER_SERVICE_TYPE[];
+    private producer;
+    constructor(producer: Producer);
+    publish(data: T["data"]): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,51 @@
+"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.PublisherV2 = void 0;
+const eventTracking_1 = require("../services/eventTracking");
+class PublisherV2 {
+    // Inject the producer
+    constructor(producer) {
+        this.producer = producer;
+    }
+    // Publish method adapted for Kafka
+    publish(data) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { insertedId } = yield (0, eventTracking_1.insertEventToCollection)({
+                    data,
+                    subject: this.subject,
+                    dependencyServicesArray: this.dependencyServicesArray,
+                    publisherService: process.env.CURRENT_SERVICE,
+                });
+                const dataToPublish = JSON.stringify({
+                    data,
+                    eventDetails: {
+                        dependencyServicesArray: this.dependencyServicesArray,
+                        id: insertedId,
+                    },
+                });
+                yield this.producer.send({
+                    topic: this.subject.replace(":", "-"),
+                    messages: [{ value: dataToPublish }],
+                    acks: -1,
+                });
+                console.log("Event published to subject", this.subject);
+                resolve();
+            }
+            catch (err) {
+                console.error("Error publishing event:", err);
+                reject(err);
+            }
+        }));
+    }
+}
+exports.PublisherV2 = PublisherV2;

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

@@ -0,0 +1,15 @@
+import { Stan } from "node-nats-streaming";
+import { Subjects } from "./subjects";
+import { PUBLISHER_SERVICE_TYPE } from "./eventTypes";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Publisher<T extends Event> {
+    abstract subject: T["subject"];
+    abstract dependencyServicesArray: PUBLISHER_SERVICE_TYPE[];
+    private client;
+    constructor(client: Stan);
+    publish(data: T["data"]): Promise<void>;
+}
+export {};

package/build/events/base-publisher.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publisher = void 0;
+const eventTracking_1 = require("../services/eventTracking");
+class Publisher {
+    constructor(client) {
+        this.client = client;
+    }
+    publish(data) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            (0, eventTracking_1.insertEventToCollection)({
+                data,
+                subject: this.subject,
+                dependencyServicesArray: (_a = this.dependencyServicesArray) === null || _a === void 0 ? void 0 : _a.filter((dependency) => dependency !== process.env.CURRENT_SERVICE),
+                publisherService: process.env.CURRENT_SERVICE,
+            })
+                .then(({ insertedId }) => {
+                this.client.publish(this.subject, JSON.stringify({
+                    data,
+                    eventDetails: {
+                        dependencyServicesArray: this.dependencyServicesArray,
+                        id: insertedId,
+                    },
+                }), (err) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    console.log("Event published to subject", this.subject);
+                    resolve();
+                });
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+}
+exports.Publisher = Publisher;
+// previous publisher without event tracking
+// import { Stan } from "node-nats-streaming";
+// import { Subjects } from "./subjects";
+// import { PUBLISHER_SERVICE_TYPE } from "./eventTypes";
+// interface Event {
+//   subject: Subjects;
+//   data: any;
+// }
+// export abstract class Publisher<T extends Event> {
+//   abstract subject: T["subject"];
+//   private client: Stan;
+//   abstract dependencyServicesArray: PUBLISHER_SERVICE_TYPE[];
+//   constructor(client: Stan) {
+//     this.client = client;
+//   }
+//   publish(data: T["data"]): Promise<void> {
+//     return new Promise((resolve, reject) => {
+//       this.client.publish(this.subject, JSON.stringify(data), (err) => {
+//         if (err) {
+//           return reject(err);
+//         }
+//         console.log("Event published to subject", this.subject);
+//         resolve();
+//       });
+//     });
+//   }
+// }

package/build/events/bulkUser-deleted-event.d.ts

@@ -0,0 +1,7 @@
+import { Subjects } from './subjects';
+export interface BulkUserDeletedEvent {
+    subject: Subjects.userBulkDelete;
+    data: {
+        users: any[];
+    };
+}

package/build/events/bulkUser-deleted-event.js

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

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

@@ -0,0 +1,4 @@
+export interface AllEvent {
+    subject: any;
+    data: any;
+}

package/build/events/common-event.js

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

package/build/events/companies-migrate-event.d.ts

@@ -0,0 +1,15 @@
+import { Subjects } from './subjects';
+export interface MigrateCompany {
+    name?: string;
+    url_name?: string;
+    id?: number;
+    logo?: string;
+    verified?: string;
+    tagline?: string;
+}
+export interface MigrateCompanies {
+    subject: Subjects.companyDataMigration;
+    data: {
+        data: MigrateCompany[];
+    };
+}

package/build/events/companies-migrate-event.js

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

package/build/events/company-admin-created-event.d.ts

@@ -0,0 +1,9 @@
+import { Subjects } from "./subjects";
+export interface CompanyAdminCreatedEvent {
+    subject: Subjects.companyAdminCreated;
+    data: {
+        companyId: number;
+        userId: number;
+        roleId: number;
+    };
+}

package/build/events/company-admin-created-event.js

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

package/build/events/company-admin-removed-event.d.ts

@@ -0,0 +1,8 @@
+import { Subjects } from "./subjects";
+export interface CompanyAdminRemovedEvent {
+    subject: Subjects.companyAdminRemoved;
+    data: {
+        companyId: number;
+        userId: number;
+    };
+}

package/build/events/company-admin-removed-event.js

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

package/build/events/company-created-event.d.ts

@@ -0,0 +1,13 @@
+import { Subjects } from './subjects';
+export interface CompanyCreatedEvent {
+    subject: Subjects.companyCreated;
+    data: {
+        id: number;
+        name?: string;
+        image?: string;
+        userId: number;
+        verified: boolean;
+        url_name?: string;
+        type?: string;
+    };
+}

package/build/events/company-created-event.js

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

package/build/events/company-data-created-event.d.ts

@@ -0,0 +1,9 @@
+import { Subjects } from './subjects';
+export interface CompanyDataCreatedEvent {
+    subject: Subjects.companyDataCreated;
+    data: {
+        company: string;
+        createdBy: string | number;
+        approved: boolean;
+    };
+}

package/build/events/company-data-created-event.js

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

package/build/events/company-deleted-event.d.ts

@@ -0,0 +1,7 @@
+import { Subjects } from "./subjects";
+export interface CompanyDeletedEvent {
+    subject: Subjects.companyDeleted;
+    data: {
+        id: number;
+    };
+}

package/build/events/company-deleted-event.js

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

package/build/events/company-employee-joined-event.d.ts

@@ -0,0 +1,8 @@
+import { Subjects } from './subjects';
+export interface CompanyEmployeeJoinedEvent {
+    subject: Subjects.companyEmployeeJoined;
+    data: {
+        companyId: number;
+        userId: number;
+    };
+}

package/build/events/company-employee-joined-event.js

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