@bolt.tech/kafka-utils 1.0.12 → 2.0.0

package/build/dependencies/paramstore/paramstore.d.ts

@@ -0,0 +1,6 @@
+export declare class ParamStore {
+    private PARAMSTORE_PATH;
+    private NODE_ENV_LOCAL;
+    constructor(PARAMSTORE_PATH: string, NODE_ENV_LOCAL: string);
+    getParams(): Promise<void>;
+}

package/build/dependencies/paramstore/paramstore.js

@@ -0,0 +1,27 @@
+"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.ParamStore = void 0;
+const bolt_paramstore_1 = require("bolt-paramstore");
+class ParamStore {
+    constructor(PARAMSTORE_PATH, NODE_ENV_LOCAL) {
+        this.PARAMSTORE_PATH = PARAMSTORE_PATH;
+        this.NODE_ENV_LOCAL = NODE_ENV_LOCAL;
+    }
+    getParams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, bolt_paramstore_1.getParameters)(`/${this.PARAMSTORE_PATH}/common/`);
+            if (this.NODE_ENV_LOCAL === "TRUE")
+                yield (0, bolt_paramstore_1.getParameters)(`/local/${this.PARAMSTORE_PATH}/`);
+        });
+    }
+}
+exports.ParamStore = ParamStore;

package/build/index.d.ts

@@ -0,0 +1,9 @@
+import { notificationType } from './store/types/notification.type';
+import { IUser, IMessage, ISmsObj, IOneSignalPayload, IAttachment } from './store/interfaces/notification.interface';
+import { IWhatsappPayload } from './store/interfaces/whatsappPayload.interface';
+export declare function initialiseNotification(paramStorePath: string, nodeEnvLocal: string, serviceName: string, notificationType: notificationType): 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>;
+export declare function sendWhatsappNotification(whatsappPayload: IWhatsappPayload): Promise<void>;

package/build/index.js

@@ -0,0 +1,144 @@
+"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.initialiseNotification = initialiseNotification;
+exports.sendEmailNotifications = sendEmailNotifications;
+exports.sendSmsNotifications = sendSmsNotifications;
+exports.sendPushNotification = sendPushNotification;
+exports.sendInAppNotification = sendInAppNotification;
+exports.sendWhatsappNotification = sendWhatsappNotification;
+const notificationSchema_registry_1 = require("./utils/schemaRegistry/notificationSchema.registry");
+const getTopic = require('./utils/kafka/topicMap.kafka');
+const publishToKafka = require('./utils/kafka/publisher.kafka');
+let currentNotificationType;
+function initialiseNotification(paramStorePath, nodeEnvLocal, serviceName, notificationType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            currentNotificationType = notificationType;
+            const KafkaServer = require('./kafkaServer');
+            const kafkaInstance = new KafkaServer();
+            yield kafkaInstance.setupKafka(paramStorePath, nodeEnvLocal, serviceName, notificationType);
+            yield kafkaInstance.setupShutdownHandlers();
+            console.log("---------------------------------------------");
+            console.log("Notification utility is ready.");
+            console.log("---------------------------------------------");
+        }
+        catch (e) {
+            console.log("🔴 kafka-utils: initialiseNotification", e);
+        }
+    });
+}
+/* publish notifications to kafka */
+function sendNotificationToKafka(userId, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const instance = notificationSchema_registry_1.NotificationSchema.getInstance();
+            if (!instance) {
+                throw new Error("Notification schema is not initialised or Schema Registry is not connected.");
+            }
+            if (!notificationSchema_registry_1.NotificationSchema) {
+                throw new Error("Notification schema is not initialised");
+            }
+            const topic = getTopic(currentNotificationType);
+            const schemaId = yield instance.getSchemaId();
+            yield publishToKafka(topic, schemaId, { key: userId, value: payload });
+            console.log(`✅ Notification sent to user: ${userId}`);
+        }
+        catch (error) {
+            console.log("🔴 kafka-utils: sendNotificationToKafka", error);
+        }
+    });
+}
+/* send email 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);
+    });
+}
+/* send whatsapp notifications to users */
+function sendWhatsappNotification(whatsappPayload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!((_a = whatsappPayload === null || whatsappPayload === void 0 ? void 0 : whatsappPayload.phone) === null || _a === void 0 ? void 0 : _a.length)) {
+            console.log("No phone number provided");
+            return;
+        }
+        const payload = {
+            user: { phoneNumbers: [whatsappPayload.phone] },
+            whatsappPayload,
+        };
+        yield sendNotificationToKafka(whatsappPayload.phone, payload);
+    });
+}

package/build/kafkaServer.d.ts

@@ -0,0 +1,11 @@
+import { notificationType } from './store/types/notification.type';
+declare class KafkaServer {
+    private paramStore;
+    private schemaRegistry;
+    private notificationSchema;
+    constructor();
+    setupKafka(paramStorePath: string, nodeEnvLocal: string, serviceName: string, notificationType: notificationType): Promise<void>;
+    setupShutdownHandlers(): void;
+    private handleShutdown;
+}
+export = KafkaServer;

package/build/kafkaServer.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 producer_kafka_1 = require("./utils/kafka/producer.kafka");
+const config_kafka_1 = require("./utils/kafka/config.kafka");
+const dotenv = __importStar(require("dotenv"));
+const paramstore_1 = require("./dependencies/paramstore/paramstore");
+const notificationSchema_registry_1 = require("./utils/schemaRegistry/notificationSchema.registry");
+const registry_util_1 = require("./utils/schemaRegistry/registry.util");
+const getKafkaBrokers = require('./utils/kafka/brokers.kafka');
+class KafkaServer {
+    constructor() {
+        this.paramStore = null;
+        this.schemaRegistry = null;
+        this.notificationSchema = null;
+        this.handleShutdown = () => __awaiter(this, void 0, void 0, function* () {
+            console.log('Shutting down Kafka Server...');
+            if (producer_kafka_1.KafkaProducer) {
+                yield producer_kafka_1.KafkaProducer.shutdown();
+            }
+            process.exit(0);
+        });
+        dotenv.config();
+    }
+    setupKafka(paramStorePath, nodeEnvLocal, serviceName, notificationType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Retrieve values from paramstore
+            this.paramStore = new paramstore_1.ParamStore(paramStorePath, nodeEnvLocal);
+            yield this.paramStore.getParams();
+            // Get Kafka brokers
+            const kafkaConnectionDetails = yield getKafkaBrokers();
+            const kafka = config_kafka_1.KafkaConfig.getConfig(kafkaConnectionDetails, serviceName);
+            // Connect to Kafka
+            yield producer_kafka_1.KafkaProducer.connect(kafka);
+            // 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 Registry connected.');
+            // Register Notification schema
+            this.notificationSchema = notificationSchema_registry_1.NotificationSchema.getInstance();
+            yield this.notificationSchema.register(notificationType);
+        });
+    }
+    setupShutdownHandlers() {
+        process.on('SIGINT', this.handleShutdown);
+        process.on('SIGTERM', this.handleShutdown);
+    }
+}
+module.exports = KafkaServer;

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

@@ -0,0 +1,27 @@
+export interface IAssetsTriggerNotification {
+    user?: IUser;
+    message?: IMessage;
+    appId?: string;
+    smsObj?: ISmsObj;
+    oneSignalPayload?: IOneSignalPayload;
+}
+export interface IUser {
+    inAppNotificationUserId?: string;
+    pushNotificationUserId?: string;
+    emailIds?: string[];
+    phoneNumbers?: string[];
+}
+export interface IMessage {
+    body?: string;
+    subject?: string;
+    priority?: number;
+}
+export interface ISmsObj {
+    smsType?: string;
+    templateId?: string;
+}
+export interface IOneSignalPayload {
+    alert?: string;
+    sos?: boolean;
+    vin?: string;
+}

package/build/store/interfaces/assestTriggerNotification.interface.js

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

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

@@ -0,0 +1,11 @@
+export interface IAuthNotificationSchema {
+    user?: IUser;
+    message?: IMessage;
+}
+export interface IUser {
+    emailIds: string[];
+}
+export interface IMessage {
+    body?: string;
+    subject?: string;
+}

package/build/store/interfaces/authEmailNotification.interface.js

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

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

@@ -0,0 +1,20 @@
+export interface IBoltChargerNotificationV2 {
+    user?: IUser;
+    message?: IMessage;
+    appId?: string;
+    smsObj?: ISmsObj;
+}
+export interface IUser {
+    pushNotificationUserId?: string;
+    inAppNotificationUserId?: string;
+    phoneNumbers: string[];
+    emailIds: string[];
+}
+export interface IMessage {
+    body?: string;
+    subject?: string;
+}
+export interface ISmsObj {
+    smsType?: string;
+    templateId?: string;
+}

package/build/store/interfaces/boltChargerNotificationV2.interface.js

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

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

@@ -0,0 +1,5 @@
+export interface IKafkaSecret {
+    username: string;
+    password: string;
+    brokers: string[];
+}

package/build/store/interfaces/kafkaSecret.interface.js

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

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

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

package/build/store/interfaces/notification.interface.js

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

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

@@ -0,0 +1,6 @@
+export interface IWhatsappPayload {
+    name: string;
+    phone: string;
+    template_name: string;
+    template_params: Record<string, string>;
+}

package/build/store/interfaces/whatsappPayload.interface.js

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

package/build/store/schemas/proto/assetTriggersNotification.proto

@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+message Notification {
+    message User {
+        string inAppNotificationUserId = 1;
+        string pushNotificationUserId = 2;
+        repeated string emailIds = 3;
+        repeated string phoneNumbers = 4;
+    }
+    message Message {
+        string body = 1;
+        string subject = 2;
+        int32 priority = 3;
+        repeated bytes attachments = 4;
+        string html = 5;
+    }
+    message SmsObj {
+        string smsType = 1;
+        string templateId = 2;
+    }
+    message OneSignalPayload {
+        string alert = 1;
+        bool sos = 2;
+        string vin = 3;
+    }
+    message Attachment {
+        string filename = 1;
+        string filetype = 2;
+        bytes content = 3;
+    }
+    User user = 1;
+    Message message = 2;
+    string appId = 3;
+    SmsObj smsObj = 4;
+    OneSignalPayload oneSignalPayload = 6;
+}

package/build/store/schemas/proto/boltNotification.proto

@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+message BoltNotification {
+  optional User user = 1;
+  optional Message message = 2;
+  optional string appId = 4;
+  optional SmsObj smsObj = 5;
+
+  message User {
+    optional string pushNotificationUserId = 3;
+    optional string inAppNotificationUserId = 4;
+    repeated string phoneNumbers = 5;
+    repeated string emailIds = 6;
+  }
+  message Message {
+    optional string body = 1;
+    optional string subject = 2;
+  }
+  message SmsObj {
+    optional string smsType = 1;
+    optional string templateId = 2;
+  }
+}

package/build/store/schemas/proto/commonNotification.proto

@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+message AssetsTriggerNotification {
+  optional User user = 1;
+  optional Message message = 2;
+  optional string appId = 3;
+  optional SmsObj smsObj = 4;
+  optional OneSignalPayload oneSignalPayload = 6;
+
+  message User {
+    optional string inAppNotificationUserId = 1;
+    optional string pushNotificationUserId = 2;
+    repeated string emailIds = 3;
+    repeated string phoneNumbers = 4;
+  }
+  message Message {
+    optional string body = 1;
+    optional string subject = 2;
+    optional int32 priority = 3;
+  }
+  message SmsObj {
+    optional string smsType = 1;
+    optional string templateId = 2;
+  }
+  message OneSignalPayload {
+    optional string alert = 1;
+    optional bool sos = 2;
+    optional string vin = 3;
+  }
+  message WhatsappPayload {
+    optional string name = 1;
+    optional string phone = 2;
+    optional string template_name = 3;
+    map<string, string> template_params = 4;
+  }
+}

package/build/store/types/notification.type.d.ts

@@ -0,0 +1,2 @@
+/** For three different topics and corresponding schemas */
+export type notificationType = "bolt" | "asset-triggers" | "common";

package/build/store/types/notification.type.js

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

package/build/utils/kafka/brokers.kafka.d.ts

@@ -0,0 +1,3 @@
+import { IKafkaSecret } from '../../store/interfaces/kafkaSecret.interface';
+declare function getKafkaBrokers(): Promise<IKafkaSecret>;
+export = getKafkaBrokers;

package/build/utils/kafka/brokers.kafka.js

@@ -0,0 +1,23 @@
+"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());
+    });
+};
+const bolt_paramstore_1 = require("bolt-paramstore");
+function getKafkaBrokers() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const slug = process.env.NODE_ENV_LOCAL === "TRUE" ? "KAFKA_CREDENTIALS_EXTERNAL" : "KAFKA_CREDENTIALS";
+        const config = yield (0, bolt_paramstore_1.getSecret)(`${process.env.PARAMSTORE_PATH}/common/${slug}`);
+        if (!config.brokers) {
+            throw new Error('Kafka brokers configuration not found.');
+        }
+        config.brokers = JSON.parse(config.brokers);
+        return config;
+    });
+}
+module.exports = getKafkaBrokers;

package/build/utils/kafka/config.kafka.d.ts

@@ -0,0 +1,7 @@
+import { Kafka } from 'kafkajs';
+import { IKafkaSecret } from '../../store/interfaces/kafkaSecret.interface';
+export declare class KafkaConfig {
+    private static config;
+    private constructor();
+    static getConfig(config: IKafkaSecret, clientId: string): Kafka;
+}

package/build/utils/kafka/config.kafka.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConfig = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const kafkajs_1 = require("kafkajs");
+dotenv_1.default.config();
+class KafkaConfig {
+    constructor() { }
+    static getConfig(config, clientId) {
+        if (!this.config) {
+            const isExternal = process.env.NODE_ENV_LOCAL === "TRUE"; // ← Add this line
+            this.config = new kafkajs_1.Kafka({
+                clientId: clientId,
+                brokers: config.brokers,
+                sasl: {
+                    mechanism: "scram-sha-512",
+                    username: config.username,
+                    password: config.password
+                },
+                ssl: isExternal ? { rejectUnauthorized: false } : false
+            });
+        }
+        return this.config;
+    }
+}
+exports.KafkaConfig = KafkaConfig;

package/build/utils/kafka/producer.kafka.d.ts

@@ -0,0 +1,8 @@
+import { Kafka, Producer } from 'kafkajs';
+export declare class KafkaProducer {
+    private static producer;
+    private constructor();
+    static connect(kafka: Kafka): Promise<void>;
+    static getProducer(): Promise<Producer>;
+    static shutdown(): Promise<void>;
+}

package/build/utils/kafka/producer.kafka.js

@@ -0,0 +1,52 @@
+"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.KafkaProducer = void 0;
+class KafkaProducer {
+    constructor() { }
+    static connect(kafka) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.producer)
+                    return;
+                this.producer = kafka.producer();
+                yield this.producer.connect();
+            }
+            catch (error) {
+                console.log(error);
+            }
+        });
+    }
+    static getProducer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.producer)
+                    throw new Error("Producer not connected");
+                return this.producer;
+            }
+            catch (error) {
+                console.log('KafkaProducer: error while connecting', error);
+                throw error;
+            }
+        });
+    }
+    static shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.producer.disconnect();
+            }
+            catch (error) {
+                console.log('KafkaProducer: error while disconnecting', error);
+            }
+        });
+    }
+}
+exports.KafkaProducer = KafkaProducer;

package/build/utils/kafka/publisher.kafka.d.ts

@@ -0,0 +1,6 @@
+interface KafkaMessage {
+    key: string;
+    value: any;
+}
+declare function publishToKafka(topic: string, schemaId: number, message: KafkaMessage): Promise<void>;
+export = publishToKafka;

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

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+const registry_util_1 = require("./../schemaRegistry/registry.util");
+const producer_kafka_1 = require("./producer.kafka");
+function publishToKafka(topic, schemaId, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            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();
+            yield producer.send(payload);
+            console.log(`✅ Published to kafka for key: ${message.key}`);
+        }
+        catch (e) {
+            console.log(`🔴 publishToKafka Error: ${message}`, e);
+        }
+    });
+}
+module.exports = publishToKafka;

package/build/utils/kafka/topicMap.kafka.d.ts

@@ -0,0 +1,3 @@
+import { notificationType } from '../../store/types/notification.type';
+declare function getTopic(type: notificationType): string;
+export = getTopic;

package/build/utils/kafka/topicMap.kafka.js

@@ -0,0 +1,10 @@
+"use strict";
+const typeTopicMap = {
+    "common": "COMMON_NOTIFICATIONS",
+    "asset-triggers": "ASSET_TRIGGER_NOTIFICATIONS",
+    "bolt": "BOLT_CHARGERS_NOTIFICATIONS"
+};
+function getTopic(type) {
+    return typeTopicMap[type];
+}
+module.exports = getTopic;

package/build/utils/schemaRegistry/notificationSchema.registry.d.ts

@@ -0,0 +1,16 @@
+import { notificationType } from '../../store/types/notification.type';
+export declare class NotificationSchema {
+    private static instance;
+    private registry;
+    private registeredSchemaId;
+    private notificationType;
+    private constructor();
+    static getInstance(): NotificationSchema;
+    register(notificationType: notificationType): Promise<void>;
+    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
+     */
+    private getSchema;
+}

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

@@ -0,0 +1,68 @@
+"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.NotificationSchema = void 0;
+const confluent_schema_registry_1 = require("@kafkajs/confluent-schema-registry");
+const registry_util_1 = require("./registry.util");
+const fs = require('fs');
+const protoSchemaBuffer = require('protocol-buffers-schema');
+const pickSchema = require('./pickSchema');
+class NotificationSchema {
+    constructor() {
+        this.registry = registry_util_1.SchemaRegistryS.getInstance();
+    }
+    static getInstance() {
+        if (!this.instance)
+            this.instance = new NotificationSchema();
+        return this.instance;
+    }
+    register(notificationType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { path, subject } = pickSchema(notificationType);
+                if (!path) {
+                    throw new Error(`Schema ${path} not found`);
+                }
+                const schema = this.getSchema(path);
+                const protoSchema = {
+                    schema,
+                    type: confluent_schema_registry_1.SchemaType.PROTOBUF
+                };
+                const { id } = yield this.registry.register(protoSchema, { subject, compatibility: confluent_schema_registry_1.COMPATIBILITY.FULL });
+                this.registeredSchemaId = id;
+            }
+            catch (e) {
+                console.log(e);
+                throw e;
+            }
+        });
+    }
+    getSchemaId() {
+        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
+     * @returns Stringified schema
+     */
+    getSchema(path) {
+        var _a;
+        const dataRead = fs.readFileSync(path);
+        const notificationMessage = protoSchemaBuffer.parse(dataRead);
+        if (((_a = notificationMessage === null || notificationMessage === void 0 ? void 0 : notificationMessage.messages) === null || _a === void 0 ? void 0 : _a.length) > 1)
+            throw new Error(`One schema file cannot have multiple schemas`);
+        return protoSchemaBuffer.stringify(notificationMessage);
+    }
+}
+exports.NotificationSchema = NotificationSchema;

package/build/utils/schemaRegistry/pickSchema.d.ts

@@ -0,0 +1,7 @@
+import { notificationType } from '../../store/types/notification.type';
+interface SchemaInfo {
+    path: string;
+    subject: string;
+}
+declare function pickSchema(notificationType: notificationType): SchemaInfo;
+export = pickSchema;

package/build/utils/schemaRegistry/pickSchema.js

@@ -0,0 +1,37 @@
+"use strict";
+const path = require('path');
+const schemaMap = {
+    'common': {
+        path: path.join(__dirname, '..', '..', 'store', 'schemas', 'proto', 'commonNotification.proto'),
+        subject: "common_notification"
+    },
+    'asset-triggers': {
+        path: path.join(__dirname, '..', '..', 'store', 'schemas', 'proto', 'assetTriggersNotification.proto'),
+        subject: "asset_trigger_notification_details"
+    },
+    'bolt': {
+        path: path.join(__dirname, '..', '..', 'store', 'schemas', 'proto', 'boltNotification.proto'),
+        subject: "bolt_charger_notification_v2"
+    }
+};
+function pickSchema(notificationType) {
+    let schemaPath;
+    switch (notificationType) {
+        case 'common':
+            schemaPath = schemaMap["common"];
+            break;
+        case 'asset-triggers':
+            schemaPath = schemaMap["asset-triggers"];
+            break;
+        case 'bolt':
+            schemaPath = schemaMap["bolt"];
+            break;
+        default:
+            throw new Error(`Schema ${notificationType} not found`);
+    }
+    if (!schemaPath) {
+        throw new Error(`Schema ${notificationType} not saved`);
+    }
+    return schemaPath;
+}
+module.exports = pickSchema;

package/build/utils/schemaRegistry/registry.util.d.ts

@@ -0,0 +1,9 @@
+import { SchemaRegistry } from '@kafkajs/confluent-schema-registry';
+export declare class SchemaRegistryS extends SchemaRegistry {
+    private static instance;
+    constructor(url: string);
+    static connect(url: string): void;
+    static getInstance(): SchemaRegistryS;
+    getRegistry(url: string): SchemaRegistryS;
+    static isConnected(): boolean;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaRegistryS = void 0;
+const confluent_schema_registry_1 = require("@kafkajs/confluent-schema-registry");
+class SchemaRegistryS extends confluent_schema_registry_1.SchemaRegistry {
+    constructor(url) {
+        super({ host: `${url}` });
+    }
+    static connect(url) {
+        this.instance = new SchemaRegistryS(url);
+    }
+    static getInstance() {
+        if (!this.instance)
+            throw new Error('Schema Registry is not connected yet. First connect to schema registry');
+        return this.instance;
+    }
+    getRegistry(url) {
+        return SchemaRegistryS.instance;
+    }
+    static isConnected() {
+        return !!this.instance;
+    }
+}
+exports.SchemaRegistryS = SchemaRegistryS;

package/package.json

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