vr-commons 1.0.22 → 1.0.23

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./middlewares";
+export * from "./validations";
+export * from "./utils";
+export { validate } from "./validations/validate.validations";

package/dist/index.js

@@ -0,0 +1,23 @@
+"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 });
+exports.validate = void 0;
+// Core Functionality
+__exportStar(require("./middlewares"), exports);
+__exportStar(require("./validations"), exports);
+__exportStar(require("./utils"), exports);
+var validate_validations_1 = require("./validations/validate.validations");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return validate_validations_1.validate; } });

package/dist/middlewares/auth.middlewares.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response, NextFunction } from "express";
+import { UserRole } from "vr-models";
+export declare const checkUserAuthentication: (allowedRoles: UserRole[]) => (req: Request, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;

package/dist/middlewares/auth.middlewares.js

@@ -0,0 +1,57 @@
+"use strict";
+// src/middlewares/auth/checkUserAuthentication.middleware.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUserAuthentication = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const vr_models_1 = require("vr-models");
+const checkUserAuthentication = (allowedRoles) => async (req, res, next) => {
+    try {
+        const authHeader = req.headers.authorization;
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            return res.status(401).json({ message: "Missing or invalid token" });
+        }
+        const token = authHeader.split(" ")[1];
+        let payload;
+        try {
+            payload = jsonwebtoken_1.default.verify(token, process.env.JWT_SECRET);
+        }
+        catch {
+            return res.status(401).json({ message: "Token expired or invalid" });
+        }
+        const user = await vr_models_1.User.findOne({
+            where: { id: payload.userId },
+            include: [
+                {
+                    model: vr_models_1.SecurityClearance,
+                    as: "securityClearance"
+                }
+            ]
+        });
+        if (!user || !user.securityClearance) {
+            return res.status(401).json({ message: "User not found" });
+        }
+        // 🔐 Token versioning (logout all devices)
+        if (user.tokenVersion !== payload.tokenVersion) {
+            return res.status(401).json({ message: "Session expired" });
+        }
+        // 🧱 Role enforcement
+        if (!allowedRoles.includes(user.securityClearance.role)) {
+            return res.status(403).json({ message: "Access denied" });
+        }
+        // ✅ Extend req
+        req.userId = user.id;
+        req.firstName = user.firstName;
+        req.lastName = user.lastName;
+        req.scRole = user.securityClearance.role;
+        req.scLevel = user.securityClearance.level;
+        req.tokenVersion = user.tokenVersion;
+        next();
+    }
+    catch (error) {
+        next(error);
+    }
+};
+exports.checkUserAuthentication = checkUserAuthentication;

package/dist/middlewares/index.d.ts

@@ -0,0 +1 @@
+export { checkUserAuthentication } from "./auth.middlewares";

package/dist/middlewares/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUserAuthentication = void 0;
+var auth_middlewares_1 = require("./auth.middlewares");
+Object.defineProperty(exports, "checkUserAuthentication", { enumerable: true, get: function () { return auth_middlewares_1.checkUserAuthentication; } });

package/dist/utils/account.utils.d.ts

@@ -0,0 +1,9 @@
+import { Transaction } from "sequelize";
+export declare const checkAccountDependencies: (userId: string, transaction?: any) => Promise<{
+    hasDependencies: boolean;
+    activeDevicePlans: number;
+    pendingPayments: number;
+    activeSubscriptions: number;
+    messages: string[];
+}>;
+export declare const hasActiveDependencies: (userId: string, transaction?: Transaction) => Promise<boolean>;

package/dist/utils/account.utils.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasActiveDependencies = exports.checkAccountDependencies = void 0;
+const vr_models_1 = require("vr-models");
+// Import other models as needed
+const checkAccountDependencies = async (userId, transaction) => {
+    const messages = [];
+    // 1. Check for active device payment plans
+    const activeDevicePlans = await vr_models_1.DevicePaymentPlan.count({
+        where: {
+            userId,
+            status: "ACTIVE", // Adjust based on your status enum
+        },
+        transaction,
+    });
+    if (activeDevicePlans > 0) {
+        messages.push(`You have ${activeDevicePlans} active device payment plan(s)`);
+    }
+    // 2. Check for pending payments
+    const pendingPayments = await vr_models_1.Transaction.count({
+        where: {
+            userId,
+            status: "PENDING", // Adjust based on your status enum
+        },
+        transaction,
+    });
+    if (pendingPayments > 0) {
+        messages.push(`You have ${pendingPayments} pending payment(s)`);
+    }
+    // 3. Add more checks as needed (subscriptions, etc.)
+    const hasDependencies = activeDevicePlans > 0 || pendingPayments > 0;
+    return {
+        hasDependencies,
+        activeDevicePlans,
+        pendingPayments,
+        activeSubscriptions: 0, // Implement if needed
+        messages,
+    };
+};
+exports.checkAccountDependencies = checkAccountDependencies;
+// Then update the hasActiveDependencies function in passengerUser.utils.ts:
+const hasActiveDependencies = async (userId, transaction) => {
+    const result = await (0, exports.checkAccountDependencies)(userId, transaction);
+    return result.hasDependencies;
+};
+exports.hasActiveDependencies = hasActiveDependencies;

package/dist/utils/authTokens.utils.d.ts

@@ -0,0 +1,11 @@
+import { UserRole } from "vr-models";
+export interface JWTPayload {
+    userId: string;
+    role: UserRole;
+    level: number;
+    tokenVersion: number;
+}
+export declare const generateAdminToken: (userId: string, role: UserRole, level: number, tokenVersion: number, expiresIn: number) => string;
+export declare const generatePassengerToken: (userId: string, role: UserRole, level: number, tokenVersion: number, expiresIn: number) => string;
+export declare const generateRiderToken: (userId: string, role: UserRole, level: number, tokenVersion: number, expiresIn: number) => string;
+export declare const verifyToken: (token: string) => Promise<JWTPayload>;

package/dist/utils/authTokens.utils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyToken = exports.generateRiderToken = exports.generatePassengerToken = exports.generateAdminToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const generateAdminToken = (userId, role, level, tokenVersion, expiresIn) => {
+    const payload = { userId, role, level, tokenVersion };
+    return jsonwebtoken_1.default.sign(payload, process.env.JWT_SECRET, {
+        expiresIn: expiresIn || Number(process.env.ADMIN_TOKEN_LIFE_SPAN)
+    });
+};
+exports.generateAdminToken = generateAdminToken;
+const generatePassengerToken = (userId, role, level, tokenVersion, expiresIn) => {
+    const payload = { userId, role, level, tokenVersion };
+    return jsonwebtoken_1.default.sign(payload, process.env.JWT_SECRET, {
+        expiresIn: expiresIn || Number(process.env.PASSENGER_TOKEN_LIFE_SPAN)
+    });
+};
+exports.generatePassengerToken = generatePassengerToken;
+const generateRiderToken = (userId, role, level, tokenVersion, expiresIn) => {
+    const payload = { userId, role, level, tokenVersion };
+    return jsonwebtoken_1.default.sign(payload, process.env.JWT_SECRET, {
+        expiresIn: expiresIn || Number(process.env.RIDER_TOKEN_LIFE_SPAN)
+    });
+};
+exports.generateRiderToken = generateRiderToken;
+const verifyToken = async (token) => {
+    return jsonwebtoken_1.default.verify(token, process.env.JWT_SECRET);
+};
+exports.verifyToken = verifyToken;

package/dist/utils/eventLog.utils.d.ts

@@ -0,0 +1,13 @@
+import { EventAction, EventActorType } from "vr-models";
+interface LogEventInput {
+    actorId?: string | null;
+    actorType?: EventActorType;
+    action: EventAction;
+    entity: string;
+    entityId?: string | null;
+    metadata?: Record<string, any>;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+}
+export declare const logEvent: ({ actorId, actorType, action, entity, entityId, metadata, ipAddress, userAgent }: LogEventInput) => Promise<void>;
+export {};

package/dist/utils/eventLog.utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEvent = void 0;
+const vr_models_1 = require("vr-models");
+const logEvent = async ({ actorId = null, actorType = "SYSTEM", action, entity, entityId = null, metadata = {}, ipAddress = null, userAgent = null }) => {
+    try {
+        await vr_models_1.EventLog.create({
+            actorId,
+            actorType,
+            action,
+            entity,
+            entityId,
+            metadata,
+            ipAddress,
+            userAgent
+        });
+    }
+    catch (err) {
+        console.log("Error Logging event ::::::", err);
+    }
+};
+exports.logEvent = logEvent;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { checkAccountDependencies, hasActiveDependencies, } from "./account.utils";
+export { generateAdminToken, generatePassengerToken, generateRiderToken, verifyToken, } from "./authTokens.utils";
+export { logEvent } from "./eventLog.utils";
+export { sendSuccessResponse, sendErrorResponse } from "./response.utils";
+export { formatUserForAdmin, formatAdminProfile, isUserAdmin, isUserAdminOrSuperAdmin, isUserSuperAdmin, getAdminWithClearance, getUserById, findSecurityClearanceByRole, hashPassword, validateUniqueFields, canAdminModifyUser, generateSearchConditions, } from "./profiles.utils";

package/dist/utils/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSearchConditions = exports.canAdminModifyUser = exports.validateUniqueFields = exports.hashPassword = exports.findSecurityClearanceByRole = exports.getUserById = exports.getAdminWithClearance = exports.isUserSuperAdmin = exports.isUserAdminOrSuperAdmin = exports.isUserAdmin = exports.formatAdminProfile = exports.formatUserForAdmin = exports.sendErrorResponse = exports.sendSuccessResponse = exports.logEvent = exports.verifyToken = exports.generateRiderToken = exports.generatePassengerToken = exports.generateAdminToken = exports.hasActiveDependencies = exports.checkAccountDependencies = void 0;
+var account_utils_1 = require("./account.utils");
+Object.defineProperty(exports, "checkAccountDependencies", { enumerable: true, get: function () { return account_utils_1.checkAccountDependencies; } });
+Object.defineProperty(exports, "hasActiveDependencies", { enumerable: true, get: function () { return account_utils_1.hasActiveDependencies; } });
+var authTokens_utils_1 = require("./authTokens.utils");
+Object.defineProperty(exports, "generateAdminToken", { enumerable: true, get: function () { return authTokens_utils_1.generateAdminToken; } });
+Object.defineProperty(exports, "generatePassengerToken", { enumerable: true, get: function () { return authTokens_utils_1.generatePassengerToken; } });
+Object.defineProperty(exports, "generateRiderToken", { enumerable: true, get: function () { return authTokens_utils_1.generateRiderToken; } });
+Object.defineProperty(exports, "verifyToken", { enumerable: true, get: function () { return authTokens_utils_1.verifyToken; } });
+var eventLog_utils_1 = require("./eventLog.utils");
+Object.defineProperty(exports, "logEvent", { enumerable: true, get: function () { return eventLog_utils_1.logEvent; } });
+var response_utils_1 = require("./response.utils");
+Object.defineProperty(exports, "sendSuccessResponse", { enumerable: true, get: function () { return response_utils_1.sendSuccessResponse; } });
+Object.defineProperty(exports, "sendErrorResponse", { enumerable: true, get: function () { return response_utils_1.sendErrorResponse; } });
+var profiles_utils_1 = require("./profiles.utils");
+Object.defineProperty(exports, "formatUserForAdmin", { enumerable: true, get: function () { return profiles_utils_1.formatUserForAdmin; } });
+Object.defineProperty(exports, "formatAdminProfile", { enumerable: true, get: function () { return profiles_utils_1.formatAdminProfile; } });
+Object.defineProperty(exports, "isUserAdmin", { enumerable: true, get: function () { return profiles_utils_1.isUserAdmin; } });
+Object.defineProperty(exports, "isUserAdminOrSuperAdmin", { enumerable: true, get: function () { return profiles_utils_1.isUserAdminOrSuperAdmin; } });
+Object.defineProperty(exports, "isUserSuperAdmin", { enumerable: true, get: function () { return profiles_utils_1.isUserSuperAdmin; } });
+Object.defineProperty(exports, "getAdminWithClearance", { enumerable: true, get: function () { return profiles_utils_1.getAdminWithClearance; } });
+Object.defineProperty(exports, "getUserById", { enumerable: true, get: function () { return profiles_utils_1.getUserById; } });
+Object.defineProperty(exports, "findSecurityClearanceByRole", { enumerable: true, get: function () { return profiles_utils_1.findSecurityClearanceByRole; } });
+Object.defineProperty(exports, "hashPassword", { enumerable: true, get: function () { return profiles_utils_1.hashPassword; } });
+Object.defineProperty(exports, "validateUniqueFields", { enumerable: true, get: function () { return profiles_utils_1.validateUniqueFields; } });
+Object.defineProperty(exports, "canAdminModifyUser", { enumerable: true, get: function () { return profiles_utils_1.canAdminModifyUser; } });
+Object.defineProperty(exports, "generateSearchConditions", { enumerable: true, get: function () { return profiles_utils_1.generateSearchConditions; } });

package/dist/utils/profiles.utils.d.ts

@@ -0,0 +1,52 @@
+import { User, SecurityClearance, UserRole } from "vr-models";
+export interface AdminUserDetailResponse {
+    id: string;
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+    email: string | null;
+    nationalId: string;
+    jacketId: string;
+    plateNumber: string | null;
+    isActive: boolean;
+    isSuspended: boolean;
+    isDeactivated: boolean;
+    deactivatedAt: Date | null;
+    lastLoginAt: Date | null;
+    createdAt: Date;
+    role?: string;
+    level?: number;
+    permissions: string[];
+}
+export interface AdminProfileResponse {
+    id: string;
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+    email: string | null;
+    nationalId: string;
+    isActive: boolean;
+    lastLoginAt: Date | null;
+    createdAt: Date;
+    role?: string;
+    level?: number;
+    permissions: string[];
+}
+export declare const formatUserForAdmin: (user: User) => AdminUserDetailResponse;
+export declare const formatAdminProfile: (user: User) => AdminProfileResponse;
+export declare const isUserAdmin: (user: User) => boolean;
+export declare const isUserSuperAdmin: (user: User) => boolean;
+export declare const isUserAdminOrSuperAdmin: (user: User) => boolean;
+export declare const getAdminWithClearance: (userId: string) => Promise<User | null>;
+export declare const getUserById: (userId: string) => Promise<User | null>;
+export declare const findSecurityClearanceByRole: (role: UserRole) => Promise<SecurityClearance | null>;
+export declare const hashPassword: (password: string) => Promise<string>;
+export declare const validateUniqueFields: (phoneNumber: string, nationalId: string, email?: string | null) => Promise<{
+    field: string;
+    message: string;
+}[]>;
+export declare const canAdminModifyUser: (admin: User, targetUser: User) => {
+    canModify: boolean;
+    reason?: string;
+};
+export declare const generateSearchConditions: (role?: UserRole, isActive?: boolean, search?: string) => any;

package/dist/utils/profiles.utils.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSearchConditions = exports.canAdminModifyUser = exports.validateUniqueFields = exports.hashPassword = exports.findSecurityClearanceByRole = exports.getUserById = exports.getAdminWithClearance = exports.isUserAdminOrSuperAdmin = exports.isUserSuperAdmin = exports.isUserAdmin = exports.formatAdminProfile = exports.formatUserForAdmin = void 0;
+const vr_models_1 = require("vr-models");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+const sequelize_1 = require("sequelize");
+const formatUserForAdmin = (user) => {
+    return {
+        id: user.id,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        phoneNumber: user.phoneNumber,
+        email: user.email,
+        nationalId: user.nationalId,
+        jacketId: user.jacketId,
+        plateNumber: user.plateNumber,
+        isActive: user.isActive,
+        isSuspended: user.isSuspended,
+        isDeactivated: user.isDeactivated,
+        deactivatedAt: user.deactivatedAt,
+        lastLoginAt: user.lastLoginAt,
+        createdAt: user.createdAt,
+        role: user.securityClearance?.role,
+        level: user.securityClearance?.level,
+        permissions: user.securityClearance?.permissions || [],
+    };
+};
+exports.formatUserForAdmin = formatUserForAdmin;
+// Format admin profile
+const formatAdminProfile = (user) => {
+    return {
+        id: user.id,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        phoneNumber: user.phoneNumber,
+        email: user.email,
+        nationalId: user.nationalId,
+        isActive: user.isActive,
+        lastLoginAt: user.lastLoginAt,
+        createdAt: user.createdAt,
+        role: user.securityClearance?.role,
+        level: user.securityClearance?.level,
+        permissions: user.securityClearance?.permissions || [],
+    };
+};
+exports.formatAdminProfile = formatAdminProfile;
+// Check if user is an admin
+const isUserAdmin = (user) => {
+    return user.securityClearance?.role === "ADMIN";
+};
+exports.isUserAdmin = isUserAdmin;
+// Check if user is a super admin
+const isUserSuperAdmin = (user) => {
+    return user.securityClearance?.role === "SUPER_ADMIN";
+};
+exports.isUserSuperAdmin = isUserSuperAdmin;
+// Check if user is an admin or super admin
+const isUserAdminOrSuperAdmin = (user) => {
+    const role = user.securityClearance?.role;
+    return role === "ADMIN" || role === "SUPER_ADMIN";
+};
+exports.isUserAdminOrSuperAdmin = isUserAdminOrSuperAdmin;
+// Get admin with security clearance
+const getAdminWithClearance = async (userId) => {
+    return await vr_models_1.User.findOne({
+        where: { id: userId },
+        include: [
+            {
+                model: vr_models_1.SecurityClearance,
+                as: "securityClearance",
+                attributes: ["role", "level", "permissions"],
+            },
+        ],
+        attributes: {
+            exclude: [
+                "password",
+                "otp",
+                "otpExpiresAt",
+                "tokenVersion",
+                "forgotPassword",
+            ],
+        },
+    });
+};
+exports.getAdminWithClearance = getAdminWithClearance;
+// Get user by ID with security clearance
+const getUserById = async (userId) => {
+    return await vr_models_1.User.findOne({
+        where: { id: userId },
+        include: [
+            {
+                model: vr_models_1.SecurityClearance,
+                as: "securityClearance",
+                attributes: ["role", "level", "permissions"],
+            },
+        ],
+        attributes: {
+            exclude: [
+                "password",
+                "otp",
+                "otpExpiresAt",
+                "tokenVersion",
+                "forgotPassword",
+            ],
+        },
+    });
+};
+exports.getUserById = getUserById;
+// Find security clearance by role
+const findSecurityClearanceByRole = async (role) => {
+    return await vr_models_1.SecurityClearance.findOne({
+        where: { role, isDefault: true },
+    });
+};
+exports.findSecurityClearanceByRole = findSecurityClearanceByRole;
+// Hash password
+const hashPassword = async (password) => {
+    return await bcryptjs_1.default.hash(password, 10);
+};
+exports.hashPassword = hashPassword;
+// Validate unique fields
+const validateUniqueFields = async (phoneNumber, nationalId, email) => {
+    const errors = [];
+    // Check phone number
+    const existingPhone = await vr_models_1.User.findOne({ where: { phoneNumber } });
+    if (existingPhone) {
+        errors.push({
+            field: "phoneNumber",
+            message: "Phone number already registered",
+        });
+    }
+    // Check national ID
+    const existingNationalId = await vr_models_1.User.findOne({ where: { nationalId } });
+    if (existingNationalId) {
+        errors.push({
+            field: "nationalId",
+            message: "National ID already registered",
+        });
+    }
+    // Check email if provided
+    if (email) {
+        const existingEmail = await vr_models_1.User.findOne({ where: { email } });
+        if (existingEmail) {
+            errors.push({ field: "email", message: "Email already registered" });
+        }
+    }
+    return errors;
+};
+exports.validateUniqueFields = validateUniqueFields;
+// Check if admin can modify target user
+const canAdminModifyUser = (admin, targetUser) => {
+    const adminRole = admin.securityClearance?.role;
+    const targetRole = targetUser.securityClearance?.role;
+    // Admins cannot modify super admins
+    if (targetRole === "SUPER_ADMIN") {
+        return { canModify: false, reason: "Cannot modify super admin accounts" };
+    }
+    // Admins cannot modify other admins (only super admins can)
+    if (targetRole === "ADMIN" && adminRole !== "SUPER_ADMIN") {
+        return {
+            canModify: false,
+            reason: "Admins cannot modify other admin accounts",
+        };
+    }
+    // Cannot modify self through this route
+    if (admin.id === targetUser.id) {
+        return {
+            canModify: false,
+            reason: "Use profile update route for self-updates",
+        };
+    }
+    return { canModify: true };
+};
+exports.canAdminModifyUser = canAdminModifyUser;
+// Generate search conditions
+const generateSearchConditions = (role, isActive, search) => {
+    const where = {};
+    if (role) {
+        where["$securityClearance.role$"] = role;
+    }
+    if (isActive !== undefined) {
+        where.isActive = isActive;
+    }
+    if (search) {
+        where[sequelize_1.Op.or] = [
+            { firstName: { [sequelize_1.Op.iLike]: `%${search}%` } },
+            { lastName: { [sequelize_1.Op.iLike]: `%${search}%` } },
+            { phoneNumber: { [sequelize_1.Op.iLike]: `%${search}%` } },
+            { email: { [sequelize_1.Op.iLike]: `%${search}%` } },
+            { nationalId: { [sequelize_1.Op.iLike]: `%${search}%` } },
+        ];
+    }
+    return where;
+};
+exports.generateSearchConditions = generateSearchConditions;

package/dist/utils/response.utils.d.ts

@@ -0,0 +1,3 @@
+import { Response } from "express";
+export declare const sendSuccessResponse: (res: Response, message: string, data?: any, statusCode?: number) => void;
+export declare const sendErrorResponse: (res: Response, message: string, statusCode?: number, error?: any) => void;

package/dist/utils/response.utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendErrorResponse = exports.sendSuccessResponse = void 0;
+// Success response
+const sendSuccessResponse = (res, message, data = null, statusCode = 200) => {
+    res.status(statusCode).json({
+        success: true,
+        message,
+        data
+    });
+};
+exports.sendSuccessResponse = sendSuccessResponse;
+// Error response
+const sendErrorResponse = (res, message, statusCode = 400, error = null) => {
+    console.error("Error sent to client::::::", error);
+    res.status(statusCode).json({
+        success: false,
+        message,
+        error: error?.message || error
+    });
+};
+exports.sendErrorResponse = sendErrorResponse;

package/dist/validations/auth.validations.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const userLoginSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        phoneNumber: z.ZodString;
+        nationalId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        phoneNumber: string;
+        nationalId: string;
+    }, {
+        phoneNumber: string;
+        nationalId: string;
+    }>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    params: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    headers: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+}, "strip", z.ZodTypeAny, {
+    body: {
+        phoneNumber: string;
+        nationalId: string;
+    };
+    query?: {} | undefined;
+    params?: {} | undefined;
+    headers?: {} | undefined;
+}, {
+    body: {
+        phoneNumber: string;
+        nationalId: string;
+    };
+    query?: {} | undefined;
+    params?: {} | undefined;
+    headers?: {} | undefined;
+}>;

package/dist/validations/auth.validations.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userLoginSchema = void 0;
+const zod_1 = require("zod");
+exports.userLoginSchema = zod_1.z.object({
+    body: zod_1.z.object({
+        phoneNumber: zod_1.z
+            .string()
+            .trim()
+            .min(10, "Phone number must be at least 10 digits")
+            .max(15, "Phone number must be at most 15 digits"),
+        nationalId: zod_1.z.string().min(16, "National ID must be atleast 16 digits")
+    }),
+    query: zod_1.z.object({}).optional(),
+    params: zod_1.z.object({}).optional(),
+    headers: zod_1.z.object({}).optional()
+});

package/dist/validations/index.d.ts

@@ -0,0 +1,2 @@
+export { validate } from "./validate.validations";
+export { userLoginSchema } from "./auth.validations";

package/dist/validations/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userLoginSchema = exports.validate = void 0;
+var validate_validations_1 = require("./validate.validations");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return validate_validations_1.validate; } });
+var auth_validations_1 = require("./auth.validations");
+Object.defineProperty(exports, "userLoginSchema", { enumerable: true, get: function () { return auth_validations_1.userLoginSchema; } });

package/dist/validations/profiles.validations.d.ts

@@ -0,0 +1,287 @@
+import { z } from "zod";
+export declare const createUserSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        phoneNumber: z.ZodString;
+        nationalId: z.ZodString;
+        email: z.ZodUnion<[z.ZodNullable<z.ZodOptional<z.ZodString>>, z.ZodLiteral<"">]>;
+        password: z.ZodString;
+        role: z.ZodEnum<["AGENT", "RIDER"]>;
+        plateNumber: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        firstName: string;
+        lastName: string;
+        phoneNumber: string;
+        password: string;
+        nationalId: string;
+        role: "RIDER" | "AGENT";
+        email?: string | null | undefined;
+        plateNumber?: string | null | undefined;
+    }, {
+        firstName: string;
+        lastName: string;
+        phoneNumber: string;
+        password: string;
+        nationalId: string;
+        role: "RIDER" | "AGENT";
+        email?: string | null | undefined;
+        plateNumber?: string | null | undefined;
+    }>;
+    params: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    headers: z.ZodObject<{
+        authorization: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        authorization: string;
+    }, {
+        authorization: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    body: {
+        firstName: string;
+        lastName: string;
+        phoneNumber: string;
+        password: string;
+        nationalId: string;
+        role: "RIDER" | "AGENT";
+        email?: string | null | undefined;
+        plateNumber?: string | null | undefined;
+    };
+    headers: {
+        authorization: string;
+    };
+    query?: {} | undefined;
+    params?: {} | undefined;
+}, {
+    body: {
+        firstName: string;
+        lastName: string;
+        phoneNumber: string;
+        password: string;
+        nationalId: string;
+        role: "RIDER" | "AGENT";
+        email?: string | null | undefined;
+        plateNumber?: string | null | undefined;
+    };
+    headers: {
+        authorization: string;
+    };
+    query?: {} | undefined;
+    params?: {} | undefined;
+}>;
+export declare const getUserByIdSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+    }, {
+        userId: string;
+    }>;
+    body: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    headers: z.ZodObject<{
+        authorization: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        authorization: string;
+    }, {
+        authorization: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+    };
+    headers: {
+        authorization: string;
+    };
+    body?: {} | undefined;
+    query?: {} | undefined;
+}, {
+    params: {
+        userId: string;
+    };
+    headers: {
+        authorization: string;
+    };
+    body?: {} | undefined;
+    query?: {} | undefined;
+}>;
+export declare const getAdminProfileSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    body: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    headers: z.ZodObject<{
+        authorization: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        authorization: string;
+    }, {
+        authorization: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    headers: {
+        authorization: string;
+    };
+    body?: {} | undefined;
+    query?: {} | undefined;
+    params?: {} | undefined;
+}, {
+    headers: {
+        authorization: string;
+    };
+    body?: {} | undefined;
+    query?: {} | undefined;
+    params?: {} | undefined;
+}>;
+export declare const updateUserProfileSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+    }, {
+        userId: string;
+    }>;
+    body: z.ZodEffects<z.ZodObject<{
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        email: z.ZodUnion<[z.ZodNullable<z.ZodOptional<z.ZodString>>, z.ZodLiteral<"">]>;
+        plateNumber: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        isSuspended: z.ZodOptional<z.ZodBoolean>;
+        password: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        email?: string | null | undefined;
+        password?: string | undefined;
+        plateNumber?: string | null | undefined;
+        isActive?: boolean | undefined;
+        isSuspended?: boolean | undefined;
+    }, {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        email?: string | null | undefined;
+        password?: string | undefined;
+        plateNumber?: string | null | undefined;
+        isActive?: boolean | undefined;
+        isSuspended?: boolean | undefined;
+    }>, {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        email?: string | null | undefined;
+        password?: string | undefined;
+        plateNumber?: string | null | undefined;
+        isActive?: boolean | undefined;
+        isSuspended?: boolean | undefined;
+    }, {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        email?: string | null | undefined;
+        password?: string | undefined;
+        plateNumber?: string | null | undefined;
+        isActive?: boolean | undefined;
+        isSuspended?: boolean | undefined;
+    }>;
+    query: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    headers: z.ZodObject<{
+        authorization: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        authorization: string;
+    }, {
+        authorization: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    body: {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        email?: string | null | undefined;
+        password?: string | undefined;
+        plateNumber?: string | null | undefined;
+        isActive?: boolean | undefined;
+        isSuspended?: boolean | undefined;
+    };
+    params: {
+        userId: string;
+    };
+    headers: {
+        authorization: string;
+    };
+    query?: {} | undefined;
+}, {
+    body: {
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        email?: string | null | undefined;
+        password?: string | undefined;
+        plateNumber?: string | null | undefined;
+        isActive?: boolean | undefined;
+        isSuspended?: boolean | undefined;
+    };
+    params: {
+        userId: string;
+    };
+    headers: {
+        authorization: string;
+    };
+    query?: {} | undefined;
+}>;
+export declare const getAllUsersSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    body: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+    query: z.ZodObject<{
+        page: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>>;
+        limit: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>>;
+        role: z.ZodOptional<z.ZodEnum<["RIDER", "PASSENGER", "AGENT", "ADMIN"]>>;
+        isActive: z.ZodOptional<z.ZodEffects<z.ZodEnum<["true", "false"]>, boolean, "true" | "false">>;
+        search: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        search?: string | undefined;
+        limit?: number | undefined;
+        isActive?: boolean | undefined;
+        role?: "RIDER" | "PASSENGER" | "ADMIN" | "AGENT" | undefined;
+        page?: number | undefined;
+    }, {
+        search?: string | undefined;
+        limit?: string | undefined;
+        isActive?: "true" | "false" | undefined;
+        role?: "RIDER" | "PASSENGER" | "ADMIN" | "AGENT" | undefined;
+        page?: string | undefined;
+    }>;
+    headers: z.ZodObject<{
+        authorization: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        authorization: string;
+    }, {
+        authorization: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    query: {
+        search?: string | undefined;
+        limit?: number | undefined;
+        isActive?: boolean | undefined;
+        role?: "RIDER" | "PASSENGER" | "ADMIN" | "AGENT" | undefined;
+        page?: number | undefined;
+    };
+    headers: {
+        authorization: string;
+    };
+    body?: {} | undefined;
+    params?: {} | undefined;
+}, {
+    query: {
+        search?: string | undefined;
+        limit?: string | undefined;
+        isActive?: "true" | "false" | undefined;
+        role?: "RIDER" | "PASSENGER" | "ADMIN" | "AGENT" | undefined;
+        page?: string | undefined;
+    };
+    headers: {
+        authorization: string;
+    };
+    body?: {} | undefined;
+    params?: {} | undefined;
+}>;
+export type CreateUserInput = z.infer<typeof createUserSchema>;
+export type GetUserByIdInput = z.infer<typeof getUserByIdSchema>;
+export type GetAdminProfileInput = z.infer<typeof getAdminProfileSchema>;
+export type UpdateUserProfileInput = z.infer<typeof updateUserProfileSchema>;
+export type GetAllUsersInput = z.infer<typeof getAllUsersSchema>;

package/dist/validations/profiles.validations.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllUsersSchema = exports.updateUserProfileSchema = exports.getAdminProfileSchema = exports.getUserByIdSchema = exports.createUserSchema = void 0;
+const zod_1 = require("zod");
+// Common validations
+const phoneNumberRegex = /^(078|079|072|073)\d{7}$/;
+const nationalIdRegex = /^\d{16}$/;
+// Admin Create User Schema (for creating agents/riders)
+exports.createUserSchema = zod_1.z.object({
+    body: zod_1.z.object({
+        firstName: zod_1.z
+            .string()
+            .min(2, "First name must be at least 2 characters")
+            .max(100, "First name cannot exceed 100 characters"),
+        lastName: zod_1.z
+            .string()
+            .min(2, "Last name must be at least 2 characters")
+            .max(100, "Last name cannot exceed 100 characters"),
+        phoneNumber: zod_1.z
+            .string()
+            .regex(phoneNumberRegex, "Phone number must be a valid Rwandan number (078/079/072/073) followed by 7 digits"),
+        nationalId: zod_1.z
+            .string()
+            .regex(nationalIdRegex, "National ID must be 16 digits"),
+        email: zod_1.z
+            .string()
+            .email("Invalid email address")
+            .optional()
+            .nullable()
+            .or(zod_1.z.literal("")),
+        password: zod_1.z
+            .string()
+            .min(6, "Password must be at least 6 characters")
+            .max(100, "Password cannot exceed 100 characters"),
+        role: zod_1.z.enum(["AGENT", "RIDER"], {
+            errorMap: () => ({ message: "Role must be either AGENT or RIDER" }),
+        }),
+        plateNumber: zod_1.z
+            .string()
+            .max(20, "Plate number cannot exceed 20 characters")
+            .optional()
+            .nullable(),
+    }),
+    params: zod_1.z.object({}).optional(),
+    query: zod_1.z.object({}).optional(),
+    headers: zod_1.z.object({
+        authorization: zod_1.z.string().regex(/^Bearer /, {
+            message: "Authorization header must start with 'Bearer '",
+        }),
+    }),
+});
+// Get User by ID Schema
+exports.getUserByIdSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        userId: zod_1.z.string().uuid("Invalid user ID format"),
+    }),
+    body: zod_1.z.object({}).optional(),
+    query: zod_1.z.object({}).optional(),
+    headers: zod_1.z.object({
+        authorization: zod_1.z.string().regex(/^Bearer /, {
+            message: "Authorization header must start with 'Bearer '",
+        }),
+    }),
+});
+// Get Admin Profile Schema
+exports.getAdminProfileSchema = zod_1.z.object({
+    params: zod_1.z.object({}).optional(),
+    body: zod_1.z.object({}).optional(),
+    query: zod_1.z.object({}).optional(),
+    headers: zod_1.z.object({
+        authorization: zod_1.z.string().regex(/^Bearer /, {
+            message: "Authorization header must start with 'Bearer '",
+        }),
+    }),
+});
+// Update User Profile Schema
+exports.updateUserProfileSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        userId: zod_1.z.string().uuid("Invalid user ID format"),
+    }),
+    body: zod_1.z
+        .object({
+        firstName: zod_1.z
+            .string()
+            .min(2, "First name must be at least 2 characters")
+            .max(100, "First name cannot exceed 100 characters")
+            .optional(),
+        lastName: zod_1.z
+            .string()
+            .min(2, "Last name must be at least 2 characters")
+            .max(100, "Last name cannot exceed 100 characters")
+            .optional(),
+        email: zod_1.z
+            .string()
+            .email("Invalid email address")
+            .optional()
+            .nullable()
+            .or(zod_1.z.literal("")),
+        plateNumber: zod_1.z
+            .string()
+            .max(20, "Plate number cannot exceed 20 characters")
+            .optional()
+            .nullable(),
+        isActive: zod_1.z.boolean().optional(),
+        isSuspended: zod_1.z.boolean().optional(),
+        password: zod_1.z
+            .string()
+            .min(6, "Password must be at least 6 characters")
+            .max(100, "Password cannot exceed 100 characters")
+            .optional(),
+    })
+        .refine((data) => Object.keys(data).length > 0, {
+        message: "At least one field must be provided for update",
+    }),
+    query: zod_1.z.object({}).optional(),
+    headers: zod_1.z.object({
+        authorization: zod_1.z.string().regex(/^Bearer /, {
+            message: "Authorization header must start with 'Bearer '",
+        }),
+    }),
+});
+// Get All Users Schema (with pagination/filtering)
+exports.getAllUsersSchema = zod_1.z.object({
+    params: zod_1.z.object({}).optional(),
+    body: zod_1.z.object({}).optional(),
+    query: zod_1.z.object({
+        page: zod_1.z.string().regex(/^\d+$/).default("1").transform(Number).optional(),
+        limit: zod_1.z.string().regex(/^\d+$/).default("20").transform(Number).optional(),
+        role: zod_1.z.enum(["RIDER", "PASSENGER", "AGENT", "ADMIN"]).optional(),
+        isActive: zod_1.z
+            .enum(["true", "false"])
+            .transform((val) => val === "true")
+            .optional(),
+        search: zod_1.z.string().optional(),
+    }),
+    headers: zod_1.z.object({
+        authorization: zod_1.z.string().regex(/^Bearer /, {
+            message: "Authorization header must start with 'Bearer '",
+        }),
+    }),
+});

package/dist/validations/validate.validations.d.ts

@@ -0,0 +1,13 @@
+import { Request, Response, NextFunction } from "express";
+import { AnyZodObject } from "zod";
+declare global {
+    namespace Express {
+        interface Request {
+            validatedQuery?: any;
+            validatedParams?: any;
+            validatedBody?: any;
+            validatedHeaders?: any;
+        }
+    }
+}
+export declare const validate: (schema: AnyZodObject) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/validations/validate.validations.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+const zod_1 = require("zod");
+const validate = (schema) => async (req, res, next) => {
+    try {
+        // Validate all parts of the request against the schema
+        const result = await schema.parseAsync({
+            body: req.body,
+            query: req.query,
+            params: req.params,
+            headers: req.headers // Add headers to validation
+        });
+        // Store validated values in custom properties
+        req.validatedBody = result.body;
+        req.validatedQuery = result.query;
+        req.validatedParams = result.params;
+        req.validatedHeaders = result.headers;
+        // Only replace body (other parts should remain read-only)
+        req.body = result.body || req.body;
+        return next();
+    }
+    catch (error) {
+        console.error(" validate middleware function Error::::::", error);
+        if (error instanceof zod_1.ZodError) {
+            res.status(400).json({
+                status: "fail",
+                errors: error.errors.map((err) => ({
+                    path: err.path.join("."),
+                    message: err.message
+                }))
+            });
+            return;
+        }
+        next(error);
+    }
+};
+exports.validate = validate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vr-commons",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "Shared functions package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",