@taphealth/kafka 1.1.2 → 1.1.3

package/dist/consumer.d.ts

@@ -0,0 +1,16 @@
+import { Kafka, Message } from "kafkajs";
+interface Event {
+    topic: string;
+    data: any;
+}
+export declare abstract class KafkaConsumer<T extends Event> {
+    abstract topic: T["topic"];
+    abstract groupId: string;
+    abstract onMessage(data: T["data"], msg: Message): void;
+    protected client: Kafka;
+    constructor(client: Kafka);
+    consume(): Promise<void>;
+    parseMessage(msg: Message): any;
+    disconnect(): Promise<void>;
+}
+export {};

package/dist/consumer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumer = void 0;
+class KafkaConsumer {
+    constructor(client) {
+        this.client = client;
+    }
+    async consume() {
+        const consumer = this.client.consumer({
+            groupId: this.groupId,
+        });
+        await consumer.connect();
+        await consumer.subscribe({ topic: this.topic });
+        await consumer.run({
+            eachMessage: async ({ message }) => {
+                console.log("Received message on topic", this.topic);
+                const data = this.parseMessage(message);
+                this.onMessage(data, message);
+            },
+        });
+    }
+    parseMessage(msg) {
+        var _a;
+        const data = JSON.parse(((_a = msg.value) === null || _a === void 0 ? void 0 : _a.toString()) || "");
+        return data;
+    }
+    async disconnect() {
+        await this.client.consumer({ groupId: this.groupId }).disconnect();
+    }
+}
+exports.KafkaConsumer = KafkaConsumer;

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-declare function init(): Promise<void>;
-export { init };
+export * from "./topics";
+export * from "./kafka";
+export * from "./producer";
+export * from "./consumer";

package/dist/index.js

@@ -1,21 +1,20 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = void 0;
-const client_1 = require("./client");
-async function init() {
-    const admin = client_1.kafka.admin();
-    await admin.connect();
-    console.log("Connected to Kafka as an admin");
-    await admin.createTopics({
-        topics: [
-            {
-                topic: "payment-captured",
-                numPartitions: 2,
-                replicationFactor: 2,
-            },
-        ],
-    });
-    console.log("Created topics");
-    await admin.disconnect();
-}
-exports.init = init;
+__exportStar(require("./topics"), exports);
+__exportStar(require("./kafka"), exports);
+__exportStar(require("./producer"), exports);
+__exportStar(require("./consumer"), exports);

package/dist/kafka.d.ts

@@ -0,0 +1,9 @@
+import { Admin } from "kafkajs";
+export declare class KafkaClient {
+    private _client?;
+    private _admin?;
+    get admin(): Admin;
+    connect(brokers: string[]): Promise<void>;
+    createTopics(topics: string[]): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/kafka.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaClient = void 0;
+const kafkajs_1 = require("kafkajs");
+const topics_1 = require("./topics");
+class KafkaClient {
+    get admin() {
+        if (!this._admin) {
+            throw new Error("Cannot access admin before connecting");
+        }
+        return this._admin;
+    }
+    async connect(brokers) {
+        try {
+            this._client = new kafkajs_1.Kafka({
+                clientId: "taphealth",
+                brokers,
+            });
+            this._admin = this._client.admin();
+            const topics = Object.values(topics_1.Topics);
+            await this.createTopics(topics);
+        }
+        catch (err) {
+            console.log("Error in connecting to Kafka", err);
+            throw err;
+        }
+    }
+    async createTopics(topics) {
+        const admin = this.admin;
+        await admin.connect();
+        try {
+            await admin.createTopics({
+                topics: [
+                    ...topics.map((topic) => ({
+                        topic,
+                        numPartitions: 2,
+                        replicationFactor: 2,
+                    })),
+                ],
+            });
+            await admin.disconnect();
+        }
+        catch (err) {
+            console.log("Error in creating topics", err);
+        }
+    }
+    async disconnect() {
+        if (this._client) {
+            await this._client.admin().disconnect();
+            await this._client.producer().disconnect();
+        }
+    }
+}
+exports.KafkaClient = KafkaClient;

package/dist/producer.d.ts

@@ -0,0 +1,13 @@
+import { Kafka } from "kafkajs";
+import { Topics } from "./topics";
+interface Event {
+    topic: Topics;
+    data: any;
+}
+export declare abstract class KafkaProducer<T extends Event> {
+    abstract topic: T["topic"];
+    protected client: Kafka;
+    constructor(client: Kafka);
+    send(data: T["data"]): Promise<void>;
+}
+export {};

package/dist/producer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaProducer = void 0;
+class KafkaProducer {
+    constructor(client) {
+        this.client = client;
+    }
+    async send(data) {
+        const producer = this.client.producer();
+        await producer.send({
+            topic: this.topic,
+            messages: [{ value: JSON.stringify(data) }],
+        });
+    }
+}
+exports.KafkaProducer = KafkaProducer;

package/dist/topics.d.ts

@@ -0,0 +1,12 @@
+export declare enum Topics {
+    AppointmentCreated = "appointment:created",
+    AppointmentUpdated = "appointment:updated",
+    OfflineAppointmentCreated = "offline-appointment:created",
+    OfflineAppointmentUpdated = "offline-appointment:updated",
+    OrderCreated = "order:created",
+    OrderCancelled = "order:cancelled",
+    OrderConfirmed = "order:confirmed",
+    PaymentCaptured = "payment:captured",
+    PaymentFailed = "payment:failed",
+    ExpirationComplete = "expiration:complete"
+}

package/dist/topics.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topics = void 0;
+var Topics;
+(function (Topics) {
+    Topics["AppointmentCreated"] = "appointment:created";
+    Topics["AppointmentUpdated"] = "appointment:updated";
+    Topics["OfflineAppointmentCreated"] = "offline-appointment:created";
+    Topics["OfflineAppointmentUpdated"] = "offline-appointment:updated";
+    Topics["OrderCreated"] = "order:created";
+    Topics["OrderCancelled"] = "order:cancelled";
+    Topics["OrderConfirmed"] = "order:confirmed";
+    Topics["PaymentCaptured"] = "payment:captured";
+    Topics["PaymentFailed"] = "payment:failed";
+    Topics["ExpirationComplete"] = "expiration:complete";
+})(Topics || (exports.Topics = Topics = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taphealth/kafka",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/client.d.ts

@@ -1,3 +0,0 @@
-import { Kafka } from "kafkajs";
-declare const kafka: Kafka;
-export { kafka };

package/dist/client.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.kafka = void 0;
-const kafkajs_1 = require("kafkajs");
-const kafka = new kafkajs_1.Kafka({
-    clientId: "taphealth",
-    brokers: ["dev-cluster-kafka-bootstrap.kafka.svc.cluster.local:9092"],
-});
-exports.kafka = kafka;