@car-parts/common 1.0.1 → 1.0.3

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

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

package/build/errors/forbidden-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForbiddenError = void 0;
+const custom_error_1 = require("./custom-error");
+class ForbiddenError extends custom_error_1.CustomError {
+    constructor(message = 'You do not have permission to perform this action') {
+        super(message);
+        this.statusCode = 403;
+        Object.setPrototypeOf(this, ForbiddenError.prototype);
+    }
+    serializeErrors() {
+        return [
+            {
+                message: this.message,
+            },
+        ];
+    }
+}
+exports.ForbiddenError = ForbiddenError;

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

@@ -4,7 +4,7 @@ exports.NotAuthorizedError = void 0;
 const custom_error_1 = require("./custom-error");
 class NotAuthorizedError extends custom_error_1.CustomError {
     constructor() {
-        super('Not authorized');
+        super('You are not logged in');
         this.statusCode = 401;
         // Only because we are extending a built-in class
         Object.setPrototypeOf(this, NotAuthorizedError.prototype);

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

@@ -0,0 +1,21 @@
+import { Consumer, Kafka, ConsumerConfig, KafkaMessage, TopicPartitionOffsetAndMetadata } from 'kafkajs';
+import { Subjects } from './subjects';
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class KafkaListener<T extends Event> {
+    abstract subject: T['subject'];
+    abstract groupId: string;
+    abstract onMessage(data: T['data'], message: KafkaMessage): Promise<void>;
+    protected kafka: Kafka;
+    protected consumer: Consumer;
+    protected sessionTimeout: number;
+    protected consumerConfig?: Partial<ConsumerConfig>;
+    constructor(kafka: Kafka, consumerConfig?: Partial<ConsumerConfig>);
+    listen(): Promise<void>;
+    parseMessage(message: KafkaMessage): any;
+    disconnect(): Promise<void>;
+    commitOffsets(offsets: Array<TopicPartitionOffsetAndMetadata>): Promise<void>;
+}
+export {};

package/build/events/base-listener.js

@@ -0,0 +1,78 @@
+"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;
+class KafkaListener {
+    constructor(kafka, consumerConfig) {
+        this.sessionTimeout = 30000; // 30 seconds
+        this.kafka = kafka;
+        this.consumerConfig = consumerConfig;
+    }
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize consumer here where groupId is available
+            this.consumer = this.kafka.consumer(Object.assign({ groupId: this.groupId, sessionTimeout: this.sessionTimeout }, this.consumerConfig));
+            yield this.consumer.connect();
+            console.log(`Kafka consumer connected: ${this.groupId}`);
+            yield this.consumer.subscribe({
+                topic: this.subject,
+                fromBeginning: true, // Similar to setDeliverAllAvailable in NATS
+            });
+            yield this.consumer.run({
+                eachMessage: (_a) => __awaiter(this, [_a], void 0, function* ({ topic, partition, message, }) {
+                    console.log(`Message received: ${topic} / ${this.groupId} / Partition: ${partition}`);
+                    try {
+                        const parsedData = this.parseMessage(message);
+                        yield this.onMessage(parsedData, message);
+                        // Kafka automatically commits offsets by default (autoCommit: true)
+                        // If you want manual commit, set autoCommit to false in run() options
+                    }
+                    catch (err) {
+                        console.error('Error processing message:', err);
+                        // Implement your error handling strategy here
+                        // You might want to:
+                        // 1. Skip the message and continue
+                        // 2. Send to dead letter queue
+                        // 3. Retry with backoff
+                        throw err; // This will pause the consumer
+                    }
+                }),
+            });
+            // Handle errors
+            this.consumer.on('consumer.crash', (event) => {
+                console.error('Consumer crashed:', event.payload.error);
+            });
+            this.consumer.on('consumer.disconnect', () => {
+                console.log('Consumer disconnected');
+            });
+        });
+    }
+    parseMessage(message) {
+        if (!message.value) {
+            throw new Error('Message value is null');
+        }
+        const data = message.value.toString('utf8');
+        return JSON.parse(data);
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.consumer.disconnect();
+            console.log('Kafka consumer disconnected');
+        });
+    }
+    // Manual commit if needed (set autoCommit: false in consumer.run())
+    commitOffsets(offsets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.consumer.commitOffsets(offsets);
+        });
+    }
+}
+exports.KafkaListener = KafkaListener;

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

@@ -0,0 +1,16 @@
+import { Producer, RecordMetadata } from 'kafkajs';
+import { Subjects } from './subjects';
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class KafkaPublisher<T extends Event> {
+    abstract subject: T['subject'];
+    protected producer: Producer;
+    constructor(producer: Producer);
+    publish(data: T['data']): Promise<RecordMetadata[]>;
+    publishBatch(dataArray: T['data'][]): Promise<RecordMetadata[]>;
+    publishWithKey(data: T['data'], key: string): Promise<RecordMetadata[]>;
+    disconnect(): Promise<void>;
+}
+export {};

package/build/events/base-publisher.js

@@ -0,0 +1,91 @@
+"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;
+class KafkaPublisher {
+    constructor(producer) {
+        this.producer = producer;
+    }
+    publish(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.producer.send({
+                    topic: this.subject,
+                    messages: [
+                        {
+                            value: JSON.stringify(data),
+                            // Optional: add key for partitioning
+                            // key: data.id,
+                            // Optional: add headers
+                            // headers: {
+                            //   'correlation-id': 'some-id',
+                            // },
+                        },
+                    ],
+                });
+                console.log('Event published to topic:', this.subject);
+                return result;
+            }
+            catch (err) {
+                console.error('Error publishing event:', err);
+                throw err;
+            }
+        });
+    }
+    // Publish multiple messages at once (batch)
+    publishBatch(dataArray) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.producer.send({
+                    topic: this.subject,
+                    messages: dataArray.map((data) => ({
+                        value: JSON.stringify(data),
+                    })),
+                });
+                console.log(`${dataArray.length} events published to topic:`, this.subject);
+                return result;
+            }
+            catch (err) {
+                console.error('Error publishing batch events:', err);
+                throw err;
+            }
+        });
+    }
+    // Publish with custom partition key
+    publishWithKey(data, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.producer.send({
+                    topic: this.subject,
+                    messages: [
+                        {
+                            key: key,
+                            value: JSON.stringify(data),
+                        },
+                    ],
+                });
+                console.log('Event published to topic:', this.subject, 'with key:', key);
+                return result;
+            }
+            catch (err) {
+                console.error('Error publishing event:', err);
+                throw err;
+            }
+        });
+    }
+    disconnect() {
+        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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subjects = void 0;
+var Subjects;
+(function (Subjects) {
+    Subjects["UserCreated"] = "user:created";
+})(Subjects || (exports.Subjects = Subjects = {}));
+// interface to make sure event names are consistent

package/build/events/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: string;
+    };
+}

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

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

package/build/index.d.ts

@@ -4,7 +4,9 @@ export * from './errors/database-connection-error';
 export * from './errors/not-authorized-error';
 export * from './errors/not-found-error';
 export * from './errors/request-validation-error';
+export * from './errors/forbidden-error';
 export * from './middlewares/current-user';
 export * from './middlewares/error-handler';
 export * from './middlewares/require-auth';
 export * from './middlewares/validate-request';
+export * from './middlewares/restrinct-to';

package/build/index.js

@@ -20,7 +20,9 @@ __exportStar(require("./errors/database-connection-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("./errors/forbidden-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("./middlewares/restrinct-to"), exports);

package/build/middlewares/current-user.d.ts

@@ -2,6 +2,7 @@ import { Request, Response, NextFunction } from 'express';
 interface UserPayload {
     id: string;
     email: string;
+    role: string;
 }
 declare global {
     namespace Express {

package/build/middlewares/restrinct-to.d.ts

@@ -0,0 +1 @@
+export {};

package/build/middlewares/restrinct-to.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const forbidden_error_1 = require("../errors/forbidden-error");
+const restrictTo = (...roles) => (req, res, next) => {
+    // roles is an array ['admin']
+    if (!roles.includes(req.currentUser.role)) {
+        throw new forbidden_error_1.ForbiddenError(); // forbidden
+    }
+    next();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@car-parts/common",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
@@ -16,6 +16,7 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
+    "@types/node": "^24.10.1",
     "del-cli": "^6.0.0",
     "typescript": "^5.8.3"
   },
@@ -27,6 +28,7 @@
     "express": "^5.1.0",
     "express-validator": "^7.2.1",
     "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
     "node-nats-streaming": "^0.3.2"
   }
 }