@bolt.tech/kafka-utils 1.0.8 → 1.0.10

package/build/app.d.ts

@@ -1,4 +1,4 @@
-declare const initialiseNotification: any, sendNotification: any;
+declare const initialiseNotification: any, sendSmsNotifications: any;
 declare const KafkaServer: any;
 declare const notificationMessage: {
     user: {

package/build/app.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { initialiseNotification, sendNotification } = require('./index');
+const { initialiseNotification, sendSmsNotifications } = require('./index');
 const KafkaServer = require('./kafkaServer');
 // Example notification message
 const notificationMessage = {
@@ -49,7 +49,7 @@ const notificationMessage = {
             console.log('🟢 Kafka Notification Utility Initialised.');
             // Step 2: Send a notification
             console.log('🟡 Sending Notification...');
-            yield sendNotification(notificationMessage.user.phoneNumbers[0], notificationMessage);
+            yield sendSmsNotifications(notificationMessage.user, notificationMessage.message, notificationMessage.smsObj);
             console.log('🟢 Notification Sent Successfully.');
             // Clean up (if any shutdown handling or disconnect required)
             const kafkaServerInstance = new KafkaServer();

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,12 +10,19 @@ 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();
@@ -33,26 +40,104 @@ 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) {
+/* initialize schema registry if not initialized */
+function initSchemaRegistry() {
+    return __awaiter(this, void 0, void 0, function* () {
+        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.');
+    });
+}
+/* publish notifications to kafka */
+function sendNotificationToKafka(userId, payload) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
+            yield initSchemaRegistry();
             const instance = notificationSchema_registry_1.NotificationSchema.getInstance();
             if (!instance) {
                 throw new Error("Notification schema is not initialised or Schema Registry is not connected.");
             }
-            if (!registry_util_1.SchemaRegistryS.isConnected()) {
-                yield registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
-            }
             if (!notificationSchema_registry_1.NotificationSchema) {
                 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/kafkaServer.js

@@ -64,11 +64,11 @@ class KafkaServer {
             const kafka = config_kafka_1.KafkaConfig.getConfig(kafkaConnectionDetails, serviceName);
             // Connect to Kafka
             yield producer_kafka_1.KafkaProducer.connect(kafka);
-            // Connect to Schema Registry
-            registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
+            // Connect to Schema Registry and wait for completion
+            console.log('🔵 Connecting to Schema Registry...');
+            yield registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
             this.schemaRegistry = registry_util_1.SchemaRegistryS.getInstance();
-            console.log(`Schema url:- ${process.env.SCHEMA_REGISTRY_URL}`);
-            console.log(this.schemaRegistry = registry_util_1.SchemaRegistryS.getInstance());
+            console.log('✅ Schema Registry connected.');
             // Register Notification schema
             this.notificationSchema = notificationSchema_registry_1.NotificationSchema.getInstance();
             yield this.notificationSchema.register(notificationType);

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,6 +14,8 @@ 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/build/utils/schemaRegistry/notificationSchema.registry.d.ts

@@ -3,10 +3,11 @@ export declare class NotificationSchema {
     private static instance;
     private registry;
     private registeredSchemaId;
+    private notificationType;
     private constructor();
     static getInstance(): NotificationSchema;
     register(notificationType: notificationType): Promise<void>;
-    getSchemaId(): number;
+    getSchemaId(): Promise<number>;
     /**
      * Reads schema from protobuf file and stringifies it. Will throw an error in case proto file has multiple message
      * @returns Stringified schema

package/build/utils/schemaRegistry/notificationSchema.registry.js

@@ -46,7 +46,11 @@ class NotificationSchema {
         });
     }
     getSchemaId() {
-        return this.registeredSchemaId;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.registeredSchemaId)
+                yield this.register(this.notificationType);
+            return this.registeredSchemaId;
+        });
     }
     /**
      * Reads schema from protobuf file and stringifies it. Will throw an error in case proto file has multiple message

package/package.json

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