@uber-clone/common 1.0.0 → 1.0.3

package/build/errors/bad-request-error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from "./custom-error";
+export declare class BadRequestError extends CustomError {
+    message: string;
+    statusCode: number;
+    constructor(message: string);
+    serializedError(): {
+        message: string;
+    }[];
+}

package/build/errors/bad-request-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = void 0;
+const custom_error_1 = require("./custom-error");
+class BadRequestError extends custom_error_1.CustomError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, BadRequestError.prototype);
+    }
+    serializedError() {
+        return [
+            {
+                message: this.message,
+            },
+        ];
+    }
+}
+exports.BadRequestError = BadRequestError;

package/build/errors/custom-error.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class CustomError extends Error {
+    abstract statusCode: number;
+    constructor(message: string);
+    abstract serializedError(): {
+        message: string;
+        field?: string;
+    }[];
+}

package/build/errors/custom-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}
+exports.CustomError = CustomError;

package/build/errors/database-conection-error.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from "./custom-error";
+export declare class DatabaseConnectionError extends CustomError {
+    statusCode: number;
+    reason: string;
+    constructor();
+    serializedError(): {
+        message: string;
+    }[];
+}

package/build/errors/database-conection-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConnectionError = void 0;
+const custom_error_1 = require("./custom-error");
+class DatabaseConnectionError extends custom_error_1.CustomError {
+    constructor() {
+        super("Error while connection to database");
+        this.statusCode = 500;
+        this.reason = "Error while connection to database";
+        Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+    }
+    serializedError() {
+        return [
+            {
+                message: this.reason,
+            },
+        ];
+    }
+}
+exports.DatabaseConnectionError = DatabaseConnectionError;

package/build/errors/not-authorized-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotAuthorizedError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializedError(): {
+        message: string;
+    }[];
+}

package/build/errors/not-authorized-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotAuthorizedError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not Authorized");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    serializedError() {
+        return [
+            {
+                message: "Not Authorized",
+            },
+        ];
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializedError(): {
+        message: string;
+    }[];
+}

package/build/errors/not-found-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Route not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    serializedError() {
+        return [
+            {
+                message: "Route not found",
+            },
+        ];
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/errors/request-validation-error.d.ts

@@ -0,0 +1,11 @@
+import { ValidationError } from "express-validator";
+import { CustomError } from "./custom-error";
+export declare class RequestValidationError extends CustomError {
+    errors: ValidationError[];
+    statusCode: number;
+    constructor(errors: ValidationError[]);
+    serializedError(): {
+        message: any;
+        field: string;
+    }[];
+}

package/build/errors/request-validation-error.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidationError = void 0;
+const custom_error_1 = require("./custom-error");
+class RequestValidationError extends custom_error_1.CustomError {
+    constructor(errors) {
+        super("Invalid request param");
+        this.errors = errors;
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, RequestValidationError.prototype);
+    }
+    serializedError() {
+        return this.errors.map((err) => {
+            if (err.type === "field") {
+                return {
+                    message: err.msg,
+                    field: err.path,
+                };
+            }
+            else {
+                return {
+                    message: err.msg,
+                    field: "unknown",
+                };
+            }
+        });
+    }
+}
+exports.RequestValidationError = RequestValidationError;

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

@@ -0,0 +1,14 @@
+export * from "./errors/bad-request-error";
+export * from "./errors/custom-error";
+export * from "./errors/database-conection-error";
+export * from "./errors/not-authorized-error";
+export * from "./errors/not-found-error";
+export * from "./errors/request-validation-error";
+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

@@ -0,0 +1,30 @@
+"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 });
+__exportStar(require("./errors/bad-request-error"), exports);
+__exportStar(require("./errors/custom-error"), exports);
+__exportStar(require("./errors/database-conection-error"), exports);
+__exportStar(require("./errors/not-authorized-error"), exports);
+__exportStar(require("./errors/not-found-error"), exports);
+__exportStar(require("./errors/request-validation-error"), exports);
+__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.d.ts

@@ -0,0 +1,14 @@
+import { NextFunction, Request, Response } from "express";
+interface UserPayload {
+    id: string;
+    email: string;
+}
+declare global {
+    namespace Express {
+        interface Request {
+            currentUser?: UserPayload;
+        }
+    }
+}
+export declare const currentUser: (req: Request, res: Response, next: NextFunction) => void;
+export {};

package/build/middlewares/current-user.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentUser = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const currentUser = (req, res, next) => {
+    var _a;
+    if (!((_a = req.session) === null || _a === void 0 ? void 0 : _a.jwt)) {
+        return next();
+    }
+    try {
+        const payload = jsonwebtoken_1.default.verify(req.session.jwt, process.env.JWT_KEY);
+        req.currentUser = payload;
+    }
+    catch (error) {
+    }
+    finally {
+        next();
+    }
+};
+exports.currentUser = currentUser;

package/build/middlewares/error-handler.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/build/middlewares/error-handler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const custom_error_1 = require("../errors/custom-error");
+const errorHandler = (err, req, res, next) => {
+    if (err instanceof custom_error_1.CustomError) {
+        return res.status(err.statusCode).send({ errors: err.serializedError() });
+    }
+    res.status(400).send({
+        errors: [
+            {
+                message: "Something went wrong",
+            },
+        ],
+    });
+};
+exports.errorHandler = errorHandler;

package/build/middlewares/require-auth.d.ts

@@ -0,0 +1,14 @@
+import { NextFunction, Request, Response } from "express";
+interface UserPayload {
+    id: string;
+    email: string;
+}
+declare global {
+    namespace Express {
+        interface Request {
+            currentUser?: UserPayload;
+        }
+    }
+}
+export declare const requireAuth: (req: Request, res: Response, next: NextFunction) => void;
+export {};

package/build/middlewares/require-auth.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuth = void 0;
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const requireAuth = (req, res, next) => {
+    if (!req.currentUser) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    next();
+};
+exports.requireAuth = requireAuth;

package/build/middlewares/validate-request.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const ValidationRequest: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/validate-request.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationRequest = void 0;
+const express_validator_1 = require("express-validator");
+const request_validation_error_1 = require("../errors/request-validation-error");
+const ValidationRequest = (req, res, next) => {
+    const err = (0, express_validator_1.validationResult)(req);
+    if (!err.isEmpty()) {
+        throw new request_validation_error_1.RequestValidationError(err.array());
+    }
+    next();
+};
+exports.ValidationRequest = ValidationRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uber-clone/common",
-  "version": "1.0.0",
+  "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"
   }
-}
+}