@helpio/common 1.0.1

package/build/events/producer.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.publishEvent = exports.publishEventWithMeta = exports.connectProducer = void 0;
+const amqp = __importStar(require("amqplib"));
+const event_utils_1 = require("./event-utils");
+const outbox_1 = require("./outbox");
+let rabbitConnection;
+let channel;
+const DEFAULT_EXCHANGE = process.env.RABBITMQ_EXCHANGE || "rentbase.events";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const publishWithConfirm = (exchange, routingKey, payload, options) => {
+    if (!channel) {
+        return Promise.reject(new Error("RabbitMQ channel not initialized. Call connectProducer() first."));
+    }
+    return new Promise((resolve, reject) => {
+        channel.publish(exchange, routingKey, payload, options, (err) => {
+            if (err)
+                return reject(err);
+            resolve();
+        });
+    });
+};
+const sendToQueueWithConfirm = (queueName, payload, options) => {
+    if (!channel) {
+        return Promise.reject(new Error("RabbitMQ channel not initialized. Call connectProducer() first."));
+    }
+    return new Promise((resolve, reject) => {
+        channel.sendToQueue(queueName, payload, options, (err) => {
+            if (err)
+                return reject(err);
+            resolve();
+        });
+    });
+};
+const connectProducer = (rabbitUrl, retries = 5, delay = 3000) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const connection = yield amqp.connect(rabbitUrl);
+        rabbitConnection = connection;
+        connection.on("error", (err) => {
+            console.error("[RabbitMQ Producer ❌] connection error:", err);
+        });
+        connection.on("close", () => {
+            console.error("[RabbitMQ Producer ❌] connection closed");
+            rabbitConnection = undefined;
+            channel = undefined;
+        });
+        channel = yield connection.createConfirmChannel();
+        yield channel.assertExchange(DEFAULT_EXCHANGE, "topic", { durable: true });
+        if (process.env.RABBITMQ_OUTBOX_AUTO_DISPATCH === "true") {
+            try {
+                (0, outbox_1.startOutboxDispatcher)(rabbitUrl);
+            }
+            catch (err) {
+                console.error("[Outbox] Failed to start dispatcher", (err === null || err === void 0 ? void 0 : err.message) || err);
+            }
+        }
+        console.log("[RabbitMQ Producer ✅] Connected successfully (confirm channel)");
+    }
+    catch (err) {
+        console.error(`[RabbitMQ Producer ❌] Connection failed. Retries left: ${retries}`, (err === null || err === void 0 ? void 0 : err.message) || err);
+        if (retries > 0) {
+            yield sleep(delay);
+            return (0, exports.connectProducer)(rabbitUrl, retries - 1, delay);
+        }
+        console.error("[RabbitMQ Producer 💥] Exhausted all retries. RabbitMQ unavailable.");
+    }
+});
+exports.connectProducer = connectProducer;
+const publishEventWithMeta = (queue, message, meta = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!channel)
+        throw new Error("RabbitMQ channel not initialized. Call connectProducer() first.");
+    // Topic exchange enables pub/sub (each service can bind its own durable queue).
+    yield channel.assertExchange(DEFAULT_EXCHANGE, "topic", { durable: true });
+    const payload = Buffer.from(JSON.stringify(message));
+    const routingKey = String(queue);
+    const eventId = meta.eventId || (0, event_utils_1.generateEventId)();
+    const occurredAt = meta.occurredAt || new Date();
+    const sourceService = meta.sourceService ||
+        process.env.SERVICE_NAME ||
+        process.env.npm_package_name;
+    const headers = Object.assign(Object.assign(Object.assign({}, (meta.headers || {})), { "x-event-id": eventId, "x-occurred-at": occurredAt.toISOString() }), (sourceService ? { "x-source-service": sourceService } : {}));
+    yield publishWithConfirm(DEFAULT_EXCHANGE, routingKey, payload, {
+        persistent: true,
+        contentType: "application/json",
+        messageId: eventId,
+        headers,
+    });
+    // Optional legacy mode for old consumers that still read directly from a shared queue.
+    if (process.env.RABBITMQ_LEGACY_QUEUE === "true") {
+        yield channel.assertQueue(routingKey, { durable: true });
+        yield sendToQueueWithConfirm(routingKey, payload, {
+            persistent: true,
+            contentType: "application/json",
+            messageId: eventId,
+            headers,
+        });
+    }
+    console.log(`[Producer ➡️] Published ${routingKey} on ${DEFAULT_EXCHANGE}:`, message);
+});
+exports.publishEventWithMeta = publishEventWithMeta;
+const publishEvent = (queue, message) => __awaiter(void 0, void 0, void 0, function* () {
+    // Optional Outbox mode: persist first, then let dispatcher publish.
+    if (process.env.RABBITMQ_USE_OUTBOX === "true") {
+        try {
+            const eventId = yield (0, outbox_1.enqueueOutboxEvent)(queue, message);
+            console.log(`[Producer ➕Outbox] Enqueued ${String(queue)} (${eventId})`);
+            return;
+        }
+        catch (err) {
+            console.warn("[Producer ➕Outbox] Enqueue failed; falling back to direct publish:", (err === null || err === void 0 ? void 0 : err.message) || err);
+        }
+    }
+    yield (0, exports.publishEventWithMeta)(queue, message);
+});
+exports.publishEvent = publishEvent;

package/build/events/publishers/user-created-publisher.d.ts

@@ -0,0 +1,6 @@
+import { UserCreatedEvent } from "../types/user-events";
+/**
+ * Publish user.created event
+ * Called when a new user is created
+ */
+export declare const publishUserCreated: (data: UserCreatedEvent) => Promise<void>;

package/build/events/publishers/user-created-publisher.js

@@ -0,0 +1,21 @@
+"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.publishUserCreated = void 0;
+const producer_1 = require("../producer");
+/**
+ * Publish user.created event
+ * Called when a new user is created
+ */
+const publishUserCreated = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, producer_1.publishEvent)("user.created", data);
+});
+exports.publishUserCreated = publishUserCreated;

package/build/events/publishers/user-updated-publisher.d.ts

@@ -0,0 +1,6 @@
+import { UserUpdatedEvent } from "../types/user-events";
+/**
+ * Publish user.updated event
+ * Called when a user's information is updated
+ */
+export declare const publishUserUpdated: (data: UserUpdatedEvent) => Promise<void>;

package/build/events/publishers/user-updated-publisher.js

@@ -0,0 +1,21 @@
+"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.publishUserUpdated = void 0;
+const producer_1 = require("../producer");
+/**
+ * Publish user.updated event
+ * Called when a user's information is updated
+ */
+const publishUserUpdated = (data) => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, producer_1.publishEvent)("user.updated", data);
+});
+exports.publishUserUpdated = publishUserUpdated;

package/build/events/types/index.d.ts

@@ -0,0 +1,6 @@
+import { UserCreatedEvent, UserUpdatedEvent } from "./user-events";
+export interface EventMap {
+    "user.created": UserCreatedEvent;
+    "user.updated": UserUpdatedEvent;
+}
+export * from "./user-events";

package/build/events/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+// Export all event types
+__exportStar(require("./user-events"), exports);

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

@@ -0,0 +1,131 @@
+/**
+ * User Event Types for Property Marketplace
+ * Updated to match auth-service User model schema
+ */
+export declare type UserRole = "tenant" | "landlord" | "property_agent" | "support_agent" | "city_admin" | "super_admin";
+export declare type UserStatus = "active" | "suspended" | "banned" | "deleted";
+export declare type KycStatus = "unverified" | "pending" | "verified" | "needs_info" | "rejected";
+export declare type VerificationLevel = "none" | "basic" | "verified" | "super_verified";
+export declare type UserActiveMode = "tenant" | "landlord" | "admin";
+export interface UserCreatedEvent {
+    id: string;
+    accountNumber: number;
+    firstName: string;
+    lastName: string;
+    email?: string;
+    phoneNumber: string;
+    roles: UserRole[];
+    activeMode: UserActiveMode;
+    address?: string;
+    city?: string;
+    country?: string;
+    countryCode?: string;
+    languagePreference: string;
+    avatarUrl?: string;
+    kycStatus: KycStatus;
+    verificationLevel: VerificationLevel;
+    emailVerifiedAt?: Date;
+    phoneVerifiedAt?: Date;
+    trustScore: number;
+    cancellationCount: number;
+    cancellationStrikes: number;
+    totalPropertiesListed?: number;
+    totalPropertiesRented?: number;
+    landlordRating?: number;
+    tenantRating?: number;
+    landlordRatingCount?: number;
+    tenantRatingCount?: number;
+    oauthProvider?: "google" | "facebook" | "github" | "apple";
+    oauthId?: string;
+    biometricEnabled?: boolean;
+    biometricPublicKey?: string;
+    biometricDeviceId?: string;
+    status: UserStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UserUpdatedEvent {
+    id: string;
+    accountNumber: number;
+    firstName: string;
+    lastName: string;
+    email?: string;
+    phoneNumber: string;
+    roles: UserRole[];
+    activeMode: UserActiveMode;
+    address?: string;
+    city?: string;
+    country?: string;
+    countryCode?: string;
+    languagePreference: string;
+    avatarUrl?: string;
+    kycStatus: KycStatus;
+    verificationLevel: VerificationLevel;
+    emailVerifiedAt?: Date;
+    phoneVerifiedAt?: Date;
+    trustScore: number;
+    cancellationCount: number;
+    cancellationStrikes: number;
+    totalPropertiesListed?: number;
+    totalPropertiesRented?: number;
+    landlordRating?: number;
+    tenantRating?: number;
+    landlordRatingCount?: number;
+    tenantRatingCount?: number;
+    oauthProvider?: "google" | "facebook" | "github" | "apple";
+    oauthId?: string;
+    biometricEnabled?: boolean;
+    biometricPublicKey?: string;
+    biometricDeviceId?: string;
+    status: UserStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UserDeletedEvent {
+    id: string;
+    accountNumber: number;
+    email?: string;
+    phoneNumber: string;
+    deletedAt: Date;
+    reason?: string;
+}
+export interface UserStatusChangedEvent {
+    id: string;
+    accountNumber: number;
+    oldStatus: UserStatus;
+    newStatus: UserStatus;
+    reason?: string;
+    changedBy?: string;
+    changedAt: Date;
+}
+export interface UserRolesUpdatedEvent {
+    id: string;
+    accountNumber: number;
+    oldRoles: UserRole[];
+    newRoles: UserRole[];
+    updatedBy?: string;
+    updatedAt: Date;
+}
+export interface UserModeChangedEvent {
+    id: string;
+    accountNumber: number;
+    oldMode: UserActiveMode;
+    newMode: UserActiveMode;
+    changedAt: Date;
+}
+export interface UserVerifiedEvent {
+    id: string;
+    accountNumber: number;
+    verificationType: "email" | "phone";
+    verifiedAt: Date;
+}
+export interface UserKycUpdatedEvent {
+    id: string;
+    accountNumber: number;
+    oldKycStatus: KycStatus;
+    newKycStatus: KycStatus;
+    oldVerificationLevel: VerificationLevel;
+    newVerificationLevel: VerificationLevel;
+    updatedBy?: string;
+    updatedAt: Date;
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * User Event Types for Property Marketplace
+ * Updated to match auth-service User model schema
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./errors/bad-request-error";
+export * from "./errors/custom-error";
+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 "./types/auth";
+export * from "./middlewares/current-user";
+export * from "./middlewares/error-handler";
+export * from "./middlewares/require-auth";
+export * from "./middlewares/validate-request";
+export * from "./events/consumer";
+export * from "./events/producer";
+export * from "./events/event-utils";
+export * from "./events/outbox";
+export * from "./events/inbox";
+export * from "./events/types/user-events";
+export * from "./events/types";
+export * from "./events/publishers/user-created-publisher";
+export * from "./events/publishers/user-updated-publisher";

package/build/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+// Re-export stuff from errors and middlewares
+__exportStar(require("./errors/bad-request-error"), exports);
+__exportStar(require("./errors/custom-error"), exports);
+__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("./types/auth"), 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/consumer"), exports);
+__exportStar(require("./events/producer"), exports);
+__exportStar(require("./events/event-utils"), exports);
+__exportStar(require("./events/outbox"), exports);
+__exportStar(require("./events/inbox"), exports);
+__exportStar(require("./events/types/user-events"), exports);
+__exportStar(require("./events/types"), exports);
+// User event publishers
+__exportStar(require("./events/publishers/user-created-publisher"), exports);
+__exportStar(require("./events/publishers/user-updated-publisher"), exports);

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

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

package/build/middlewares/current-user.js

@@ -0,0 +1,20 @@
+"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 (err) { }
+    next();
+};
+exports.currentUser = currentUser;

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

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } 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,14 @@
+"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.serializeErrors() });
+    }
+    console.error(err);
+    res.status(400).send({
+        errors: [{ message: 'Something went wrong' }],
+    });
+};
+exports.errorHandler = errorHandler;

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

@@ -0,0 +1,12 @@
+import { Request, Response, NextFunction } from "express";
+/**
+ * Middleware: Require authentication
+ * Verifies JWT access token and attaches user payload to request
+ * Works across all microservices
+ */
+export declare const requireAuth: (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;
+/**
+ * Middleware: Optional authentication
+ * Loads user if token is present, but doesn't require it
+ */
+export declare const optionalAuth: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/require-auth.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalAuth = exports.requireAuth = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const JWT_SECRET = process.env.JWT_SECRET || "your-secret-key-change-in-production";
+/**
+ * Middleware: Require authentication
+ * Verifies JWT access token and attaches user payload to request
+ * Works across all microservices
+ */
+const requireAuth = (req, res, next) => {
+    var _a;
+    try {
+        // Extract token from Authorization header or cookies
+        const authHeader = req.headers.authorization;
+        const token = (authHeader === null || authHeader === void 0 ? void 0 : authHeader.startsWith("Bearer "))
+            ? authHeader.substring(7)
+            : (_a = req.cookies) === null || _a === void 0 ? void 0 : _a.accessToken;
+        // Check if token exists
+        if (!token) {
+            console.log("[requireAuth] No token provided");
+            throw new not_authorized_error_1.NotAuthorizedError();
+        }
+        // Verify token
+        const payload = jsonwebtoken_1.default.verify(token, JWT_SECRET);
+        console.log("[requireAuth] Token verified successfully:", {
+            userId: payload.userId,
+            id: payload.id,
+            email: payload.email,
+            hasAccountNumber: !!payload.accountNumber
+        });
+        // Attach user payload to request
+        req.currentUser = payload;
+        // Support both legacy 'id' and new 'userId' formats
+        req.userId = payload.userId || payload.id;
+        req.sessionId = payload.sessionId;
+        next();
+    }
+    catch (err) {
+        console.error("[requireAuth] Error:", err.message, err.name);
+        if (err.name === "TokenExpiredError") {
+            return res.status(401).json({
+                error: "TOKEN_EXPIRED",
+                message: "Authentication token has expired",
+            });
+        }
+        if (err.name === "JsonWebTokenError") {
+            return res.status(401).json({
+                error: "INVALID_TOKEN",
+                message: "Invalid authentication token",
+            });
+        }
+        // For NotAuthorizedError or other errors
+        return res.status(401).json({
+            error: "UNAUTHORIZED",
+            message: "Authentication required",
+        });
+    }
+};
+exports.requireAuth = requireAuth;
+/**
+ * Middleware: Optional authentication
+ * Loads user if token is present, but doesn't require it
+ */
+const optionalAuth = (req, res, next) => {
+    var _a;
+    try {
+        const authHeader = req.headers.authorization;
+        const token = (authHeader === null || authHeader === void 0 ? void 0 : authHeader.startsWith("Bearer "))
+            ? authHeader.substring(7)
+            : (_a = req.cookies) === null || _a === void 0 ? void 0 : _a.accessToken;
+        if (!token) {
+            return next();
+        }
+        const payload = jsonwebtoken_1.default.verify(token, JWT_SECRET);
+        req.currentUser = payload;
+        // Support both legacy 'id' and new 'userId' formats
+        req.userId = payload.userId || payload.id;
+        req.sessionId = payload.sessionId;
+        next();
+    }
+    catch (error) {
+        // Silently fail for optional auth
+        next();
+    }
+};
+exports.optionalAuth = optionalAuth;

package/build/middlewares/system-logger.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const validateRequest: (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.validateRequest = void 0;
+const express_validator_1 = require("express-validator");
+const request_validation_error_1 = require("../errors/request-validation-error");
+const validateRequest = (req, res, next) => {
+    const errors = (0, express_validator_1.validationResult)(req);
+    if (!errors.isEmpty()) {
+        throw new request_validation_error_1.RequestValidationError(errors.array());
+    }
+    next();
+};
+exports.validateRequest = validateRequest;

package/build/types/auth.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Common types for authentication across all services
+ */
+export interface UserPayload {
+    id?: string;
+    userId?: string;
+    email?: string;
+    phoneNumber?: string;
+    roles?: string[];
+    activeMode?: string;
+    sessionId?: string;
+    [key: string]: any;
+}
+declare global {
+    namespace Express {
+        interface Request {
+            currentUser?: UserPayload;
+            userId?: string;
+            sessionId?: string;
+        }
+    }
+}

package/build/types/auth.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Common types for authentication across all services
+ */
+Object.defineProperty(exports, "__esModule", { value: true });