@uber-clone/common 1.0.2 → 1.0.4

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

@@ -0,0 +1,20 @@
+export declare class KafkaClient {
+    private kafka;
+    private producer;
+    private consumer;
+    private admin;
+    private isConnected;
+    private config;
+    constructor();
+    private getKafkaConfig;
+    connect(): Promise<void>;
+    private ensureTopics;
+    publish(topic: string, event: any): Promise<void>;
+    subscribe(topic: string, handler: (event: any) => Promise<void>, options?: {
+        fromBeginning?: boolean;
+    }): Promise<void>;
+    private ensureConnection;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<boolean>;
+    getConnectionStatus(): boolean;
+}

package/build/events/kafka-client.js

@@ -0,0 +1,231 @@
+"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.KafkaClient = void 0;
+const kafkajs_1 = require("kafkajs");
+class KafkaClient {
+    constructor() {
+        this.isConnected = false;
+        this.config = this.getKafkaConfig();
+        this.kafka = new kafkajs_1.Kafka({
+            clientId: this.config.clientId,
+            brokers: this.config.brokers,
+            logLevel: kafkajs_1.logLevel.ERROR,
+            retry: {
+                initialRetryTime: this.config.initialRetryTime,
+                retries: this.config.retries,
+            },
+            connectionTimeout: 30000,
+            requestTimeout: 30000,
+        });
+        this.producer = this.kafka.producer({
+            allowAutoTopicCreation: this.config.enableAutoTopicCreation,
+            transactionTimeout: this.config.transactionTimeout,
+            maxInFlightRequests: 1,
+            idempotent: true,
+        });
+        this.consumer = this.kafka.consumer({
+            groupId: this.config.consumerGroup,
+            sessionTimeout: this.config.sessionTimeout,
+            heartbeatInterval: this.config.heartbeatInterval,
+            allowAutoTopicCreation: this.config.enableAutoTopicCreation,
+        });
+        this.admin = this.kafka.admin();
+    }
+    getKafkaConfig() {
+        return {
+            clientId: process.env.KAFKA_CLIENT_ID || "uber-service",
+            brokers: (process.env.KAFKA_BROKERS || "localhost:9092")
+                .split(",")
+                .map((b) => b.trim()),
+            consumerGroup: process.env.KAFKA_CONSUMER_GROUP || "uber-group",
+            enableAutoTopicCreation: process.env.KAFKA_AUTO_TOPIC_CREATION === "true",
+            sessionTimeout: parseInt(process.env.KAFKA_SESSION_TIMEOUT || "30000"),
+            heartbeatInterval: parseInt(process.env.KAFKA_HEARTBEAT_INTERVAL || "10000"),
+            transactionTimeout: parseInt(process.env.KAFKA_TRANSACTION_TIMEOUT || "30000"),
+            retries: parseInt(process.env.KAFKA_RETRIES || "8"),
+            initialRetryTime: parseInt(process.env.KAFKA_INITIAL_RETRY_TIME || "100"),
+        };
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected)
+                return;
+            console.log(`Connecting to Kafka with brokers: ${this.config.brokers.join(", ")}`);
+            try {
+                yield this.producer.connect();
+                yield this.consumer.connect();
+                yield this.admin.connect();
+                this.isConnected = true;
+                console.log("Successfully connected to Kafka");
+            }
+            catch (error) {
+                console.error("Failed to connect to Kafka:", error);
+                throw new Error(`Kafka connection failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+            yield this.ensureTopics();
+        });
+    }
+    ensureTopics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const topics = [
+                { topic: "user-events", partitions: 3, replicationFactor: 1 },
+                { topic: "auth-events", partitions: 3, replicationFactor: 1 },
+                { topic: "ride-requests", partitions: 6, replicationFactor: 1 },
+                { topic: "driver-assignments", partitions: 6, replicationFactor: 1 },
+                { topic: "location-updates", partitions: 12, replicationFactor: 1 },
+                { topic: "payment-events", partitions: 4, replicationFactor: 1 },
+                { topic: "notification-events", partitions: 4, replicationFactor: 1 },
+                { topic: "ticket-events", partitions: 3, replicationFactor: 1 },
+                { topic: "order-events", partitions: 6, replicationFactor: 1 },
+            ];
+            try {
+                const existingTopics = yield this.admin.listTopics();
+                const topicsToCreate = topics.filter((t) => !existingTopics.includes(t.topic));
+                if (topicsToCreate.length > 0) {
+                    console.log(`Creating Kafka topics: ${topicsToCreate
+                        .map((t) => t.topic)
+                        .join(", ")}`);
+                    yield this.admin.createTopics({
+                        topics: topicsToCreate,
+                        waitForLeaders: true,
+                    });
+                    console.log(`Successfully created topics: ${topicsToCreate
+                        .map((t) => t.topic)
+                        .join(", ")}`);
+                }
+                else {
+                    console.log("All required Kafka topics already exist");
+                }
+            }
+            catch (error) {
+                console.error("Error creating topics:", error);
+                throw new Error(`Failed to create Kafka topics: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        });
+    }
+    publish(topic, event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureConnection();
+            if (!event || typeof event !== "object") {
+                throw new Error("Event must be a valid object");
+            }
+            try {
+                const message = {
+                    topic,
+                    messages: [
+                        {
+                            key: event.correlationId || event.eventId || event.id || "default-key",
+                            value: JSON.stringify(event),
+                            headers: {
+                                "event-type": event.type || "unknown",
+                                source: event.source || "unknown-service",
+                                timestamp: event.timestamp
+                                    ? event.timestamp.toISOString()
+                                    : new Date().toISOString(),
+                                version: event.version ? event.version.toString() : "1.0",
+                            },
+                        },
+                    ],
+                };
+                const result = yield this.producer.send(message);
+                console.log(`Published event to topic ${topic}:`, {
+                    partition: result[0].partition,
+                    offset: result[0].baseOffset,
+                    eventType: event.type,
+                });
+            }
+            catch (error) {
+                console.error(`Failed to publish event to ${topic}:`, error);
+                throw new Error(`Failed to publish event to ${topic}: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        });
+    }
+    subscribe(topic, handler, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureConnection();
+            try {
+                yield this.consumer.subscribe({
+                    topic,
+                    fromBeginning: (options === null || options === void 0 ? void 0 : options.fromBeginning) || false,
+                });
+                console.log(`Subscribed to topic: ${topic}`);
+                yield this.consumer.run({
+                    eachMessage: (_a) => __awaiter(this, [_a], void 0, function* ({ topic, partition, message }) {
+                        try {
+                            if (!message.value) {
+                                console.warn(`Received message with no value from ${topic}:${partition}`);
+                                return;
+                            }
+                            const event = JSON.parse(message.value.toString());
+                            console.log(`Received event from ${topic}:${partition}`, {
+                                offset: message.offset,
+                                eventType: event.type || "unknown",
+                            });
+                            yield handler(event);
+                        }
+                        catch (error) {
+                            console.error(`Error processing message from ${topic}:${partition}:`, error);
+                            // In production, you might want to implement dead letter queue or retry logic here
+                        }
+                    }),
+                });
+            }
+            catch (error) {
+                console.error(`Failed to subscribe to topic ${topic}:`, error);
+                throw new Error(`Failed to subscribe to topic ${topic}: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        });
+    }
+    ensureConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected) {
+                yield this.connect();
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.isConnected) {
+                    yield Promise.allSettled([
+                        this.producer.disconnect(),
+                        this.consumer.disconnect(),
+                        this.admin.disconnect(),
+                    ]);
+                    this.isConnected = false;
+                    console.log("Disconnected from Kafka");
+                }
+            }
+            catch (error) {
+                console.error("Error disconnecting from Kafka:", error);
+            }
+        });
+    }
+    // Health check method
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.admin.describeCluster();
+                return this.isConnected;
+            }
+            catch (error) {
+                console.error("Kafka health check failed:", error);
+                return false;
+            }
+        });
+    }
+    // Get connection status
+    getConnectionStatus() {
+        return this.isConnected;
+    }
+}
+exports.KafkaClient = KafkaClient;

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,28 @@
+export declare enum Subjects {
+    UserCreated = "user.created",
+    UserUpdated = "user.updated",
+    UserDeleted = "user.deleted",
+    UserProfileUpdated = "user.profile-updated",
+    UserSignedIn = "user.signed-in",
+    UserSignedOut = "user.signed-out",
+    UserPasswordChanged = "user.password-changed",
+    UserAccountLocked = "user.account-locked",
+    RideRequested = "ride.requested",
+    RideAccepted = "ride.accepted",
+    RideStarted = "ride.started",
+    RideCompleted = "ride.completed",
+    RideCancelled = "ride.cancelled",
+    DriverOnline = "driver.online",
+    DriverOffline = "driver.offline",
+    DriverLocationUpdated = "driver.location-updated",
+    DriverRideAccepted = "driver.ride-accepted",
+    DriverRideCompleted = "driver.ride-completed",
+    PaymentInitiated = "payment.initiated",
+    PaymentCompleted = "payment.completed",
+    PaymentFailed = "payment.failed",
+    PaymentRefunded = "payment.refunded",
+    NotificationEmail = "notification.email",
+    NotificationSMS = "notification.sms",
+    NotificationPush = "notification.push",
+    NotificationInApp = "notification.in-app"
+}

package/build/events/subjects.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subjects = void 0;
+// Subjects enum
+var Subjects;
+(function (Subjects) {
+    // User events
+    Subjects["UserCreated"] = "user.created";
+    Subjects["UserUpdated"] = "user.updated";
+    Subjects["UserDeleted"] = "user.deleted";
+    Subjects["UserProfileUpdated"] = "user.profile-updated";
+    // Auth events
+    Subjects["UserSignedIn"] = "user.signed-in";
+    Subjects["UserSignedOut"] = "user.signed-out";
+    Subjects["UserPasswordChanged"] = "user.password-changed";
+    Subjects["UserAccountLocked"] = "user.account-locked";
+    // Ride events
+    Subjects["RideRequested"] = "ride.requested";
+    Subjects["RideAccepted"] = "ride.accepted";
+    Subjects["RideStarted"] = "ride.started";
+    Subjects["RideCompleted"] = "ride.completed";
+    Subjects["RideCancelled"] = "ride.cancelled";
+    // Driver events
+    Subjects["DriverOnline"] = "driver.online";
+    Subjects["DriverOffline"] = "driver.offline";
+    Subjects["DriverLocationUpdated"] = "driver.location-updated";
+    Subjects["DriverRideAccepted"] = "driver.ride-accepted";
+    Subjects["DriverRideCompleted"] = "driver.ride-completed";
+    // Payment events
+    Subjects["PaymentInitiated"] = "payment.initiated";
+    Subjects["PaymentCompleted"] = "payment.completed";
+    Subjects["PaymentFailed"] = "payment.failed";
+    Subjects["PaymentRefunded"] = "payment.refunded";
+    // Notification events
+    Subjects["NotificationEmail"] = "notification.email";
+    Subjects["NotificationSMS"] = "notification.sms";
+    Subjects["NotificationPush"] = "notification.push";
+    Subjects["NotificationInApp"] = "notification.in-app";
+})(Subjects || (exports.Subjects = Subjects = {}));

package/build/events/types.d.ts

@@ -0,0 +1,88 @@
+import { Subjects } from "./subjects";
+export interface BaseEvent {
+    type: Subjects;
+    source: string;
+    timestamp: Date;
+    version: string;
+    data: any;
+    correlationId?: string;
+    eventId?: string;
+    id?: string;
+}
+export interface UserEvent extends BaseEvent {
+    type: Subjects.UserCreated | Subjects.UserUpdated | Subjects.UserDeleted | Subjects.UserProfileUpdated;
+    data: {
+        userId: string;
+        email: string;
+        name?: string;
+        phone?: string;
+        [key: string]: any;
+    };
+}
+export interface AuthEvent extends BaseEvent {
+    type: Subjects.UserSignedIn | Subjects.UserSignedOut | Subjects.UserPasswordChanged | Subjects.UserAccountLocked;
+    data: {
+        userId: string;
+        email: string;
+        ipAddress?: string;
+        userAgent?: string;
+        [key: string]: any;
+    };
+}
+export interface RideEvent extends BaseEvent {
+    type: Subjects.RideRequested | Subjects.RideAccepted | Subjects.RideStarted | Subjects.RideCompleted | Subjects.RideCancelled;
+    data: {
+        rideId: string;
+        passengerId: string;
+        driverId?: string;
+        pickupLocation: {
+            lat: number;
+            lng: number;
+            address?: string;
+        };
+        destinationLocation: {
+            lat: number;
+            lng: number;
+            address?: string;
+        };
+        estimatedFare?: number;
+        [key: string]: any;
+    };
+}
+export interface DriverEvent extends BaseEvent {
+    type: Subjects.DriverOnline | Subjects.DriverOffline | Subjects.DriverLocationUpdated | Subjects.DriverRideAccepted | Subjects.DriverRideCompleted;
+    data: {
+        driverId: string;
+        location?: {
+            lat: number;
+            lng: number;
+        };
+        rideId?: string;
+        [key: string]: any;
+    };
+}
+export interface PaymentEvent extends BaseEvent {
+    type: Subjects.PaymentInitiated | Subjects.PaymentCompleted | Subjects.PaymentFailed | Subjects.PaymentRefunded;
+    data: {
+        paymentId: string;
+        userId: string;
+        rideId?: string;
+        amount: number;
+        currency: string;
+        paymentMethod: string;
+        status: string;
+        [key: string]: any;
+    };
+}
+export interface NotificationEvent extends BaseEvent {
+    type: Subjects.NotificationEmail | Subjects.NotificationSMS | Subjects.NotificationPush | Subjects.NotificationInApp;
+    data: {
+        userId: string;
+        notificationType: string;
+        title: string;
+        message: string;
+        metadata?: any;
+        [key: string]: any;
+    };
+}
+export type UberEvent = UserEvent | AuthEvent | RideEvent | DriverEvent | PaymentEvent | NotificationEvent;

package/build/events/types.js

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

package/build/index.d.ts

@@ -8,3 +8,6 @@ export * from "./middlewares/current-user";
 export * from "./middlewares/error-handler";
 export * from "./middlewares/require-auth";
 export * from "./middlewares/validate-request";
+export * from "./events/kafka-client";
+export * from "./events/types";
+export * from "./events/subjects";

package/build/index.js

@@ -24,3 +24,8 @@ __exportStar(require("./middlewares/current-user"), exports);
 __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/validate-request"), exports);
+// export * from "./events/kafka-listener";
+// export * from "./events/kafka-publisher";
+__exportStar(require("./events/kafka-client"), exports);
+__exportStar(require("./events/types"), exports);
+__exportStar(require("./events/subjects"), 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.4",
   "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"
   }
 }