@bolt.tech/kafka-utils 1.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,5 @@
+import { notificationType } from './store/types/notification.type';
+declare let notificationType: notificationType;
+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 {};

package/build/index.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.initialiseNotification = initialiseNotification;
+exports.sendNotification = sendNotification;
+const getTopic = require('./kafka/topicMap.kafka');
+let notificationType;
+function initialiseNotification(paramStorePath, nodeEnvLocal, serviceName, notificationType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            notificationType = notificationType;
+            const KafkaServer = require('./kafkaServer');
+            const kafkaInstance = new KafkaServer();
+            yield kafkaInstance.setupKafka(paramStorePath, nodeEnvLocal, serviceName, notificationType);
+            this.setupShutdownHandlers();
+            console.log("---------------------------------------------");
+            console.log("Notification utility is ready.");
+            console.log("---------------------------------------------");
+        }
+        catch (e) {
+            console.log("🔴 kafka-utils: initialiseNotification", e);
+        }
+    });
+}
+const NotificationSchema = require('./schemaRegistry/notificationSchema.registry');
+const publishToKafka = require('./kafka/publisher.kafka');
+function sendNotification(userId, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!this.notificationSchema) {
+                throw new Error("Notification schema is not initialised");
+            }
+            const topic = getTopic(notificationType);
+            let key = userId;
+            const instance = NotificationSchema.getInstance();
+            const schemaId = yield instance.getSchemaId();
+            yield publishToKafka(topic, schemaId, { key, value: message });
+        }
+        catch (e) {
+            console.log("🔴 kafka-utils: sendNotification", e);
+        }
+    });
+}

package/build/kafkaServer.d.ts

@@ -0,0 +1 @@
+export {};

package/build/kafkaServer.js

@@ -0,0 +1,78 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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() {
+        // public express: express.Application;
+        this.paramStore = null;
+        this.schemaRegistry = null;
+        this.notificationSchema = null;
+        this.handleShutdown = () => __awaiter(this, void 0, void 0, function* () {
+            console.log('Shutting down Kafka Server...');
+            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
+            registry_util_1.SchemaRegistryS.connect(process.env.SCHEMA_REGISTRY_URL);
+            this.schemaRegistry = registry_util_1.SchemaRegistryS.getInstance();
+            // 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/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 @@
+export {};

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

@@ -0,0 +1,24 @@
+"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 });
+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 = { getKafkaBroker: 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,27 @@
+"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) {
+            this.config = new kafkajs_1.Kafka({
+                clientId: clientId,
+                brokers: config.brokers,
+                sasl: {
+                    mechanism: "plain",
+                    username: config.username,
+                    password: config.password
+                }
+            });
+        }
+        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 @@
+export {};

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

@@ -0,0 +1,28 @@
+"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 });
+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 @@
+export {};

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,15 @@
+import { notificationType } from './../../store/types/notification.type';
+export declare class NotificationSchema {
+    private static instance;
+    private registry;
+    private registeredSchemaId;
+    private constructor();
+    static getInstance(): NotificationSchema;
+    register(notificationType: notificationType): Promise<void>;
+    getSchemaId(): 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,64 @@
+"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 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 @@
+export {};

package/build/utils/schemaRegistry/pickSchema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 'bolt':
+            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,8 @@
+import { SchemaRegistry } from "@kafkajs/confluent-schema-registry";
+export declare class SchemaRegistryS extends SchemaRegistry {
+    private static instance;
+    private constructor();
+    static connect(url: string): void;
+    static getInstance(): SchemaRegistryS;
+    getRegistry(url: string): SchemaRegistryS;
+}

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

@@ -0,0 +1,21 @@
+"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;
+    }
+}
+exports.SchemaRegistryS = SchemaRegistryS;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@bolt.tech/kafka-utils",
+  "version": "1.0.0",
+  "description": "",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": [
+    "build/*"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rm -rf ./build/ && tsc",
+    "pub": "rm -rf build/ && npm run build && npm publish --access=public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://bitbucket.org/i_bansal/kafka-utils/issues"
+  },
+  "homepage": "https://bitbucket.org/i_bansal/kafka-utils#readme",
+  "dependencies": {
+    "@kafkajs/confluent-schema-registry": "^3.3.0",
+    "axios": "^1.7.2",
+    "bolt-paramstore": "^1.0.12",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "kafkajs": "^2.2.4",
+    "protocol-buffers-schema": "^3.6.0",
+    "ts-node": "^10.9.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.5.2"
+  }
+}