@uber-clone/common 1.0.3 → 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/subjects.d.ts

@@ -1,3 +1,28 @@
 export declare enum Subjects {
-    UserCreated = "user-created"
+    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

@@ -1,7 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Subjects = void 0;
+// Subjects enum
 var Subjects;
 (function (Subjects) {
-    Subjects["UserCreated"] = "user-created";
+    // 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/index.d.ts

@@ -8,7 +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-listener";
-export * from "./events/kafka-publisher";
+export * from "./events/kafka-client";
+export * from "./events/types";
 export * from "./events/subjects";
-export * from "./events/event-types/user-created-event";

package/build/index.js

@@ -24,7 +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);
-__exportStar(require("./events/kafka-listener"), exports);
-__exportStar(require("./events/kafka-publisher"), 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);
-__exportStar(require("./events/event-types/user-created-event"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uber-clone/common",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [

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

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