@uber-clone/common 1.0.2 → 1.0.3

package/build/events/event-types/user-created-event.d.ts

@@ -0,0 +1,9 @@
+import { Subjects } from "../subjects";
+export interface UserCreatedEvent {
+    subject: Subjects.UserCreated;
+    data: {
+        id: string;
+        name: string;
+        email: number;
+    };
+}

package/build/events/event-types/user-created-event.js

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

package/build/events/kafka-listener.d.ts

@@ -0,0 +1,34 @@
+import { Kafka, EachMessagePayload } from "kafkajs";
+import { Subjects } from "./subjects";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+/**
+ * Abstract class for a Kafka Consumer (Listener).
+ * It abstracts away Kafka connection, topic subscription, and message parsing.
+ * The equivalent of NATS 'queueGroupName' is the Kafka 'groupId'.
+ */
+export declare abstract class KafkaListener<T extends Event> {
+    abstract subject: T["subject"];
+    abstract groupId: string;
+    abstract onMessage(data: T["data"], messagePayload: EachMessagePayload): void;
+    private kafka;
+    private consumer;
+    constructor(kafka: Kafka);
+    /**
+     * Connects the consumer and subscribes to the topic.
+     * FIX: The consumer is now initialized here, where 'this.groupId' is guaranteed to be set
+     * by the subclass constructor before the 'listen()' method is called.
+     */
+    listen(): Promise<void>;
+    /**
+     * Converts the message value (Buffer) into a parsed JSON object.
+     */
+    private parseMessage;
+    /**
+     * Graceful shutdown function.
+     */
+    close(): Promise<void>;
+}
+export {};

package/build/events/kafka-listener.js

@@ -0,0 +1,89 @@
+"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.KafkaListener = void 0;
+/**
+ * Abstract class for a Kafka Consumer (Listener).
+ * It abstracts away Kafka connection, topic subscription, and message parsing.
+ * The equivalent of NATS 'queueGroupName' is the Kafka 'groupId'.
+ */
+class KafkaListener {
+    // No changes needed here, as it only stores the Kafka client instance.
+    constructor(kafka) {
+        this.kafka = kafka;
+    }
+    /**
+     * Connects the consumer and subscribes to the topic.
+     * FIX: The consumer is now initialized here, where 'this.groupId' is guaranteed to be set
+     * by the subclass constructor before the 'listen()' method is called.
+     */
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Initialize the consumer instance using the abstract 'groupId'
+                this.consumer = this.kafka.consumer({ groupId: this.groupId });
+                yield this.consumer.connect();
+                // Subscribe to the defined topic
+                yield this.consumer.subscribe({
+                    topic: this.subject,
+                    fromBeginning: true, // Similar to NATS setDeliverAllAvailable
+                });
+                console.log(`Kafka Consumer connected and listening to topic: ${this.subject} with group: ${this.groupId}`);
+                // Run the consumer to process messages
+                yield this.consumer.run({
+                    eachMessage: (payload) => __awaiter(this, void 0, void 0, function* () {
+                        const { topic, partition, message } = payload;
+                        console.log(`Message received: ${topic} / partition ${partition}`);
+                        // Kafka data is always a Buffer or null, so we must parse it.
+                        const parsedData = this.parseMessage(message.value);
+                        // Pass the parsed data and the full payload to the implementation
+                        this.onMessage(parsedData, payload);
+                        // Note: Offset is automatically committed by kafkajs
+                        // after onMessage completes successfully.
+                    }),
+                });
+            }
+            catch (err) {
+                console.error("Kafka Listener Error:", err);
+                // Exit or retry connection logic would go here
+            }
+        });
+    }
+    /**
+     * Converts the message value (Buffer) into a parsed JSON object.
+     */
+    parseMessage(value) {
+        if (!value) {
+            console.warn("Received null message value. Returning empty object.");
+            return {};
+        }
+        try {
+            return JSON.parse(value.toString("utf8"));
+        }
+        catch (e) {
+            console.error("Failed to parse Kafka message value.", e);
+            throw new Error("Invalid message format received from Kafka.");
+        }
+    }
+    /**
+     * Graceful shutdown function.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Only try to disconnect if the consumer was actually initialized
+            if (this.consumer) {
+                yield this.consumer.disconnect();
+                console.log(`Kafka Consumer for group ${this.groupId} disconnected.`);
+            }
+        });
+    }
+}
+exports.KafkaListener = KafkaListener;

package/build/events/kafka-publisher.d.ts

@@ -0,0 +1,28 @@
+import { Kafka } from "kafkajs";
+import { Subjects } from "./subjects";
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+/**
+ * Abstract class for a Kafka Producer (Publisher).
+ * It abstracts away Kafka connection and message serialization.
+ */
+export declare abstract class KafkaPublisher<T extends Event> {
+    abstract subject: T["subject"];
+    private producer;
+    constructor(kafka: Kafka);
+    /**
+     * Connects the producer to the Kafka broker. Call this before publishing.
+     */
+    connect(): Promise<void>;
+    /**
+     * Publishes the event data to the defined topic.
+     */
+    publish(data: T["data"]): Promise<void>;
+    /**
+     * Graceful shutdown function.
+     */
+    close(): Promise<void>;
+}
+export {};

package/build/events/kafka-publisher.js

@@ -0,0 +1,67 @@
+"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.KafkaPublisher = void 0;
+/**
+ * Abstract class for a Kafka Producer (Publisher).
+ * It abstracts away Kafka connection and message serialization.
+ */
+class KafkaPublisher {
+    constructor(kafka) {
+        // Create a producer instance
+        this.producer = kafka.producer();
+    }
+    /**
+     * Connects the producer to the Kafka broker. Call this before publishing.
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.producer.connect();
+            console.log("Kafka Producer connected.");
+        });
+    }
+    /**
+     * Publishes the event data to the defined topic.
+     */
+    publish(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Ensure the producer is connected before sending
+            // In a real app, you'd manage connection state better.
+            // Assuming connect() was called before this method.
+            try {
+                const response = yield this.producer.send({
+                    topic: this.subject,
+                    messages: [
+                        {
+                            value: JSON.stringify(data), // Kafka requires data to be a Buffer or string
+                            // key: 'some-key-for-partitioning' // Use a key for ordered processing (e.g., ticket ID)
+                        },
+                    ],
+                });
+                console.log("Event published to subject", this.subject, "Response:", response);
+            }
+            catch (err) {
+                console.error("Kafka Publisher Error:", err);
+                throw err;
+            }
+        });
+    }
+    /**
+     * Graceful shutdown function.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.producer.disconnect();
+            console.log("Kafka Producer disconnected.");
+        });
+    }
+}
+exports.KafkaPublisher = KafkaPublisher;

package/build/events/subjects.d.ts

@@ -0,0 +1,3 @@
+export declare enum Subjects {
+    UserCreated = "user-created"
+}

package/build/events/subjects.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subjects = void 0;
+var Subjects;
+(function (Subjects) {
+    Subjects["UserCreated"] = "user-created";
+})(Subjects || (exports.Subjects = Subjects = {}));

package/build/index.d.ts

@@ -8,3 +8,7 @@ export * from "./middlewares/current-user";
 export * from "./middlewares/error-handler";
 export * from "./middlewares/require-auth";
 export * from "./middlewares/validate-request";
+export * from "./events/kafka-listener";
+export * from "./events/kafka-publisher";
+export * from "./events/subjects";
+export * from "./events/event-types/user-created-event";

package/build/index.js

@@ -24,3 +24,7 @@ __exportStar(require("./middlewares/current-user"), exports);
 __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/validate-request"), exports);
+__exportStar(require("./events/kafka-listener"), exports);
+__exportStar(require("./events/kafka-publisher"), exports);
+__exportStar(require("./events/subjects"), exports);
+__exportStar(require("./events/event-types/user-created-event"), exports);

package/build/middlewares/current-user.js

@@ -12,7 +12,6 @@ const currentUser = (req, res, next) => {
     }
     try {
         const payload = jsonwebtoken_1.default.verify(req.session.jwt, process.env.JWT_KEY);
-        console.log("[payload]", payload);
         req.currentUser = payload;
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uber-clone/common",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
@@ -27,6 +27,7 @@
     "express": "^5.1.0",
     "express-validator": "^7.2.1",
     "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
     "node-nats-streaming": "^0.3.2"
   }
 }