@bolt.tech/kafka-utils 1.0.9 → 1.0.11

package/build/index.d.ts

@@ -1,3 +1,7 @@
+import { IAttachment, IMessage, IOneSignalPayload, ISmsObj, IUser } from './store/interfaces/notification.interface';
 import { notificationType } from './store/types/notification.type';
 export declare function initialiseNotification(paramStorePath: "dev" | "prod", nodeEnvLocal: "TRUE" | "FALSE", serviceName: string, notificationType: notificationType): Promise<void>;
-export declare function sendNotification(userId: string, message: any): Promise<void>;
+export declare function sendEmailNotifications(user: IUser, message: IMessage, attachment?: IAttachment): Promise<void>;
+export declare function sendSmsNotifications(user: IUser, message: IMessage, smsObj: ISmsObj): Promise<void>;
+export declare function sendPushNotification(user: IUser, message: IMessage, appId: string, oneSignalPayload: IOneSignalPayload): Promise<void>;
+export declare function sendInAppNotification(user: IUser, message: IMessage, appId: string): Promise<void>;

package/build/index.js

@@ -10,16 +10,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initialiseNotification = initialiseNotification;
-exports.sendNotification = sendNotification;
+exports.sendEmailNotifications = sendEmailNotifications;
+exports.sendSmsNotifications = sendSmsNotifications;
+exports.sendPushNotification = sendPushNotification;
+exports.sendInAppNotification = sendInAppNotification;
 const getTopic = require('./utils/kafka/topicMap.kafka');
 let currentNotificationType;
 function initialiseNotification(paramStorePath, nodeEnvLocal, serviceName, notificationType) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
-            console.log('🔵 Connecting to Schema Registry...');
-            registry_util_1.SchemaRegistryS.getInstance();
-            console.log('✅ Schema Registry connected.');
             currentNotificationType = notificationType;
             const KafkaServer = require('./kafkaServer');
             const kafkaInstance = new KafkaServer();
@@ -35,17 +34,11 @@ function initialiseNotification(paramStorePath, nodeEnvLocal, serviceName, notif
     });
 }
 const notificationSchema_registry_1 = require("./utils/schemaRegistry/notificationSchema.registry");
-const registry_util_1 = require("./utils/schemaRegistry/registry.util");
 const publishToKafka = require('./utils/kafka/publisher.kafka');
-function sendNotification(userId, message) {
+/* publish notifications to kafka */
+function sendNotificationToKafka(userId, payload) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            if (!registry_util_1.SchemaRegistryS.isConnected()) {
-                console.log('🔵 Connecting to Schema Registry...');
-                registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
-                registry_util_1.SchemaRegistryS.getInstance();
-                console.log('✅ Schema Registry connected successfully.');
-            }
             const instance = notificationSchema_registry_1.NotificationSchema.getInstance();
             if (!instance) {
                 throw new Error("Notification schema is not initialised or Schema Registry is not connected.");
@@ -54,13 +47,82 @@ function sendNotification(userId, message) {
                 throw new Error("Notification schema is not initialised");
             }
             const topic = getTopic(currentNotificationType);
-            let key = userId;
             const schemaId = yield instance.getSchemaId();
-            yield publishToKafka(topic, schemaId, { key, value: message });
+            yield publishToKafka(topic, schemaId, { key: userId, value: payload });
             console.log(`✅ Notification sent to user: ${userId}`);
         }
-        catch (e) {
-            console.log("🔴 kafka-utils: sendNotification", e);
+        catch (error) {
+            console.log("🔴 kafka-utils: sendNotificationToKafka", error);
+        }
+    });
+}
+/* send emaail notifications to users */
+function sendEmailNotifications(user, message, attachment) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (user.emailIds.length === 0) {
+            console.log("No email addresses provided");
+            return;
+        }
+        const basePayload = {
+            user: Object.assign(Object.assign({}, user), { emailIds: user.emailIds }),
+            message,
+            Attachment: attachment || {}
+        };
+        for (const emailId of user.emailIds) {
+            const payload = Object.assign(Object.assign({}, basePayload), { user: Object.assign(Object.assign({}, basePayload.user), { emailIds: [emailId] }) });
+            yield sendNotificationToKafka(emailId, payload);
+        }
+    });
+}
+/* send sms notifications to users */
+function sendSmsNotifications(user, message, smsObj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (user.phoneNumbers.length === 0) {
+            console.log("No phone numbers provided");
+            return;
+        }
+        const basePayload = {
+            user: Object.assign(Object.assign({}, user), { phoneNumbers: user.phoneNumbers }),
+            message,
+            smsObj,
+        };
+        for (const phoneNumber of user.phoneNumbers) {
+            const payload = Object.assign(Object.assign({}, basePayload), { user: Object.assign(Object.assign({}, basePayload.user), { phoneNumbers: [phoneNumber] }) });
+            yield sendNotificationToKafka(phoneNumber, payload);
+        }
+    });
+}
+/* send push notifications to users */
+function sendPushNotification(user, message, appId, oneSignalPayload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!user.pushNotificationUserId) {
+            console.log("No push notification user ID provided");
+            return;
+        }
+        const payload = {
+            user: Object.assign(Object.assign({}, user), { pushNotificationUserId: user.pushNotificationUserId }),
+            message,
+            appId,
+            smsObj: {},
+            oneSignalPayload,
+        };
+        yield sendNotificationToKafka(user.pushNotificationUserId, payload);
+    });
+}
+/* send in-app notifications to users */
+function sendInAppNotification(user, message, appId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!user.inAppNotificationUserId) {
+            console.log("No in-app notification user ID provided");
+            return;
         }
+        const payload = {
+            user: Object.assign(Object.assign({}, user), { inAppNotificationUserId: user.inAppNotificationUserId }),
+            message,
+            appId,
+            smsObj: {},
+            oneSignalPayload: {},
+        };
+        yield sendNotificationToKafka(user.inAppNotificationUserId, payload);
     });
 }

package/build/store/interfaces/notification.interface.d.ts

@@ -1,35 +1,35 @@
 export interface IUser {
-    inAppNotificationUserId: string;
-    pushNotificationUserId: string;
-    emailIds: string[];
-    phoneNumbers: string[];
+    inAppNotificationUserId?: string;
+    pushNotificationUserId?: string;
+    emailIds?: string[];
+    phoneNumbers?: string[];
 }
 export interface IMessage {
-    body: string;
-    subject: string;
-    priority: number;
-    attachments: Uint8Array[];
-    html: string;
+    body?: string;
+    subject?: string;
+    priority?: number;
+    attachments?: Uint8Array[];
+    html?: string;
 }
 export interface ISmsObj {
-    smsType: string;
-    templateId: string;
+    smsType?: string;
+    templateId?: string;
 }
 export interface IOneSignalPayload {
-    alert: string;
-    sos: boolean;
-    vin: string;
+    alert?: string;
+    sos?: boolean;
+    vin?: string;
 }
 export interface IAttachment {
-    filename: string;
-    filetype: string;
-    content: Uint8Array;
+    filename?: string;
+    filetype?: string;
+    content?: Uint8Array;
 }
 export interface INotification {
-    user: IUser;
-    message: IMessage;
-    appId: string;
-    smsObj: ISmsObj;
-    oneSignalPayload: IOneSignalPayload;
-    Attachment: IAttachment;
+    user?: IUser;
+    message?: IMessage;
+    appId?: string;
+    smsObj?: ISmsObj;
+    oneSignalPayload?: IOneSignalPayload;
+    Attachment?: IAttachment;
 }

package/build/utils/kafka/publisher.kafka.js

@@ -14,8 +14,6 @@ const producer_kafka_1 = require("./producer.kafka");
 function publishToKafka(topic, schemaId, message) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
-            registry_util_1.SchemaRegistryS.getInstance();
             const encodedMessage = yield registry_util_1.SchemaRegistryS.getInstance().encode(schemaId, message.value);
             const payload = { topic, messages: [{ key: message.key, value: encodedMessage }] };
             const producer = yield producer_kafka_1.KafkaProducer.getProducer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolt.tech/kafka-utils",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/build/app.d.ts

@@ -1,14 +0,0 @@
-declare const initialiseNotification: any, sendNotification: any;
-declare const KafkaServer: any;
-declare const notificationMessage: {
-    user: {
-        phoneNumbers: string[];
-    };
-    message: {
-        body: string;
-    };
-    smsObj: {
-        smsType: string;
-        templateId: string;
-    };
-};

package/build/app.js

@@ -1,63 +0,0 @@
-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());
-    });
-};
-const { initialiseNotification, sendNotification } = require('./index');
-const KafkaServer = require('./kafkaServer');
-// Example notification message
-const notificationMessage = {
-    user: {
-        // inAppNotificationUserId: '66222b43527f81ea8e2f0ea3',
-        // pushNotificationUserId: '66222b43527f81ea8e2f0ea3',
-        //emailIds: ["monakundnani113@gmail.com"],
-        phoneNumbers: ["+917850855689"],
-    },
-    message: {
-        body: "Dear Bolt.Earth Host, We have updated our Bank settlement cycle to a Weekly basis. These changes will be effective from September 6th, 2024 and you'll now receive settlements for bookings made on your charger on a weekly basis. Have Questions? Email us at support@bolt.earth"
-        //subject: 'Test',
-        // priority: 1,
-        // attachments: [],
-        // html: '<h1>This is a test message</h1>'
-    },
-    // appId: 'e5feb55e-ac98-4a16-a5d6-3675c3edb591',
-    smsObj: {
-        smsType: 'MKT',
-        templateId: '1307172536061229921'
-    }
-    // oneSignalPayload: {
-    //     alert: 'This is a test message',
-    //     sos: false,
-    //     vin: '123'
-    // },
-    // Attachment: {
-    //     filename: 'test.txt',
-    //     filetype: 'text/plain',
-    //     content: new Uint8Array([1, 2, 3, 4])
-    // }
-};
-(function testKafkaUtils() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            console.log('🟡 Initialising Kafka Notification Utility...');
-            // Step 1: Initialise the notification system
-            yield initialiseNotification("dev", "TRUE", "common", "common");
-            console.log('🟢 Kafka Notification Utility Initialised.');
-            // Step 2: Send a notification
-            console.log('🟡 Sending Notification...');
-            yield sendNotification(notificationMessage.user.phoneNumbers[0], notificationMessage);
-            console.log('🟢 Notification Sent Successfully.');
-            // Clean up (if any shutdown handling or disconnect required)
-            const kafkaServerInstance = new KafkaServer();
-            kafkaServerInstance.handleShutdown();
-            console.log('🟢 Test Completed Successfully.');
-        }
-        catch (error) {
-            console.error('🔴 Test Error:', error);
-        }
-    });
-})();