vr-commons 1.0.46 → 1.0.48

package/dist/utils/bans.utils.d.ts

@@ -0,0 +1,36 @@
+import { Ban } from "vr-models";
+export declare const banUtil: {
+    formatBanForResponse: (ban: any) => {
+        id: any;
+        user: {
+            id: any;
+            name: string;
+            phoneNumber: any;
+            email: any;
+        } | null;
+        admin: {
+            id: any;
+            name: string;
+        } | null;
+        reason: any;
+        bannedAt: any;
+        isPermanent: any;
+        appeal: {
+            appealedAt: any;
+            appealReason: any;
+            appealStatus: any;
+        } | null;
+        revocation: {
+            revokedAt: any;
+            revokingAdmin: {
+                id: any;
+                name: string;
+            } | null;
+            revocationReason: any;
+        } | null;
+        createdAt: any;
+        updatedAt: any;
+    };
+    isBanActive: (ban: Ban) => boolean;
+    canAppeal: (ban: Ban) => boolean;
+};

package/dist/utils/bans.utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.banUtil = void 0;
+exports.banUtil = {
+    formatBanForResponse: (ban) => {
+        const banJson = ban.toJSON ? ban.toJSON() : ban;
+        return {
+            id: banJson.id,
+            user: banJson.user
+                ? {
+                    id: banJson.user.id,
+                    name: `${banJson.user.firstName} ${banJson.user.lastName}`,
+                    phoneNumber: banJson.user.phoneNumber,
+                    email: banJson.user.email,
+                }
+                : null,
+            admin: banJson.admin
+                ? {
+                    id: banJson.admin.id,
+                    name: `${banJson.admin.firstName} ${banJson.admin.lastName}`,
+                }
+                : null,
+            reason: banJson.reason,
+            bannedAt: banJson.bannedAt,
+            isPermanent: banJson.isPermanent,
+            appeal: banJson.appealedAt
+                ? {
+                    appealedAt: banJson.appealedAt,
+                    appealReason: banJson.appealReason,
+                    appealStatus: banJson.appealStatus,
+                }
+                : null,
+            revocation: banJson.revokedAt
+                ? {
+                    revokedAt: banJson.revokedAt,
+                    revokingAdmin: banJson.revokingAdmin
+                        ? {
+                            id: banJson.revokingAdmin.id,
+                            name: `${banJson.revokingAdmin.firstName} ${banJson.revokingAdmin.lastName}`,
+                        }
+                        : null,
+                    revocationReason: banJson.revocationReason,
+                }
+                : null,
+            createdAt: banJson.createdAt,
+            updatedAt: banJson.updatedAt,
+        };
+    },
+    isBanActive: (ban) => {
+        return !ban.revokedAt;
+    },
+    canAppeal: (ban) => {
+        return !ban.appealedAt && !ban.revokedAt && ban.isPermanent;
+    },
+};

package/dist/utils/index.d.ts

@@ -3,3 +3,6 @@ export { generateAdminToken, generatePassengerToken, generateRiderToken, verifyT
 export { logEvent } from "./eventLog.utils";
 export { sendSuccessResponse, sendErrorResponse } from "./response.utils";
 export { formatUserProfile, formatUserListResponse, hasRole, hasPermission, hasAnyPermission, hasAllPermissions, canModifyAccount, isAccountAccessible, getUserById, getUsersByRole, findSecurityClearanceByRole, generateUserSearchConditions, generateEventSearchConditions, getSortOrder, generateJacketId, validateUniqueFields, validatePassword, hashPassword, softDeleteUser, } from "./profiles.utils";
+export { canModerate, canModerateUser, getModeratableRoles, hasHigherAuthority, } from "./moderation.utils";
+export { banUtil } from "./bans.utils";
+export { suspensionUtil } from "./suspension.utils";

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.softDeleteUser = exports.hashPassword = exports.validatePassword = exports.validateUniqueFields = exports.generateJacketId = exports.getSortOrder = exports.generateEventSearchConditions = exports.generateUserSearchConditions = exports.findSecurityClearanceByRole = exports.getUsersByRole = exports.getUserById = exports.isAccountAccessible = exports.canModifyAccount = exports.hasAllPermissions = exports.hasAnyPermission = exports.hasPermission = exports.hasRole = exports.formatUserListResponse = exports.formatUserProfile = exports.sendErrorResponse = exports.sendSuccessResponse = exports.logEvent = exports.verifyToken = exports.generateRiderToken = exports.generatePassengerToken = exports.generateAdminToken = exports.checkSuspensionStatus = exports.checkIsUserBannedOrSuspended = exports.checkBanStatus = exports.hasActiveDependencies = exports.checkAccountDependencies = void 0;
+exports.suspensionUtil = exports.banUtil = exports.hasHigherAuthority = exports.getModeratableRoles = exports.canModerateUser = exports.canModerate = exports.softDeleteUser = exports.hashPassword = exports.validatePassword = exports.validateUniqueFields = exports.generateJacketId = exports.getSortOrder = exports.generateEventSearchConditions = exports.generateUserSearchConditions = exports.findSecurityClearanceByRole = exports.getUsersByRole = exports.getUserById = exports.isAccountAccessible = exports.canModifyAccount = exports.hasAllPermissions = exports.hasAnyPermission = exports.hasPermission = exports.hasRole = exports.formatUserListResponse = exports.formatUserProfile = exports.sendErrorResponse = exports.sendSuccessResponse = exports.logEvent = exports.verifyToken = exports.generateRiderToken = exports.generatePassengerToken = exports.generateAdminToken = exports.checkSuspensionStatus = exports.checkIsUserBannedOrSuspended = exports.checkBanStatus = 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; } });
@@ -44,3 +44,12 @@ Object.defineProperty(exports, "validatePassword", { enumerable: true, get: func
 Object.defineProperty(exports, "hashPassword", { enumerable: true, get: function () { return profiles_utils_1.hashPassword; } });
 // Account management functions
 Object.defineProperty(exports, "softDeleteUser", { enumerable: true, get: function () { return profiles_utils_1.softDeleteUser; } });
+var moderation_utils_1 = require("./moderation.utils");
+Object.defineProperty(exports, "canModerate", { enumerable: true, get: function () { return moderation_utils_1.canModerate; } });
+Object.defineProperty(exports, "canModerateUser", { enumerable: true, get: function () { return moderation_utils_1.canModerateUser; } });
+Object.defineProperty(exports, "getModeratableRoles", { enumerable: true, get: function () { return moderation_utils_1.getModeratableRoles; } });
+Object.defineProperty(exports, "hasHigherAuthority", { enumerable: true, get: function () { return moderation_utils_1.hasHigherAuthority; } });
+var bans_utils_1 = require("./bans.utils");
+Object.defineProperty(exports, "banUtil", { enumerable: true, get: function () { return bans_utils_1.banUtil; } });
+var suspension_utils_1 = require("./suspension.utils");
+Object.defineProperty(exports, "suspensionUtil", { enumerable: true, get: function () { return suspension_utils_1.suspensionUtil; } });

package/dist/utils/moderation.utils.d.ts

@@ -0,0 +1,25 @@
+import { User } from "vr-models";
+import { UserRole } from "vr-models";
+interface HierarchyCheckResult {
+    allowed: boolean;
+    reason?: string;
+    code?: "INSUFFICIENT_HIERARCHY" | "SAME_LEVEL_RESTRICTION" | "CANNOT_ACT_ON_HIGHER" | "CANNOT_ACT_ON_SELF";
+}
+/**
+ * Check if an actor can perform moderation actions on a target user
+ * based on role hierarchy and security clearance levels
+ */
+export declare function canModerateUser(actorUser: User, targetUser: User): Promise<HierarchyCheckResult>;
+/**
+ * Simplified version that just returns boolean
+ */
+export declare function canModerate(actorUser: User, targetUser: User): Promise<boolean>;
+/**
+ * Get list of roles that actor can moderate
+ */
+export declare function getModeratableRoles(actorRole: UserRole): UserRole[];
+/**
+ * Check if actor has higher authority than target
+ */
+export declare function hasHigherAuthority(actorRole: UserRole, actorLevel: number, targetRole: UserRole, targetLevel: number): boolean;
+export {};

package/dist/utils/moderation.utils.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canModerateUser = canModerateUser;
+exports.canModerate = canModerate;
+exports.getModeratableRoles = getModeratableRoles;
+exports.hasHigherAuthority = hasHigherAuthority;
+// Role hierarchy levels (higher number = more authority)
+const ROLE_HIERARCHY = {
+    RIDER: 0,
+    PASSENGER: 0,
+    AGENT: 1,
+    ADMIN: 2,
+    SUPER_ADMIN: 3,
+};
+// Who can act on whom matrix
+const CAN_ACT_ON = {
+    RIDER: [], // Riders cannot act on anyone
+    PASSENGER: [], // Passengers cannot act on anyone
+    AGENT: ["RIDER", "PASSENGER"], // Agents can act on riders and passengers
+    ADMIN: ["RIDER", "PASSENGER", "AGENT"], // Admins can act on riders, passengers, and agents
+    SUPER_ADMIN: ["RIDER", "PASSENGER", "AGENT", "ADMIN", "SUPER_ADMIN"], // Super admin can act on everyone
+};
+/**
+ * Check if an actor can perform moderation actions on a target user
+ * based on role hierarchy and security clearance levels
+ */
+async function canModerateUser(actorUser, targetUser) {
+    try {
+        // Cannot act on self
+        if (actorUser.id === targetUser.id) {
+            return {
+                allowed: false,
+                reason: "You cannot moderate your own account",
+                code: "CANNOT_ACT_ON_SELF",
+            };
+        }
+        // Get roles
+        const actorRole = actorUser.securityClearance?.role || "RIDER";
+        const targetRole = targetUser.securityClearance?.role || "RIDER";
+        // Get hierarchy levels
+        const actorLevel = ROLE_HIERARCHY[actorRole];
+        const targetLevel = ROLE_HIERARCHY[targetRole];
+        // Check if actor can act on target based on role matrix
+        const allowedTargets = CAN_ACT_ON[actorRole] || [];
+        if (!allowedTargets.includes(targetRole)) {
+            return {
+                allowed: false,
+                reason: `${actorRole === targetRole
+                    ? `Cannot moderate another ${actorRole.toLowerCase()}`
+                    : `${actorRole} cannot moderate ${targetRole}`}`,
+                code: "CANNOT_ACT_ON_HIGHER",
+            };
+        }
+        // If same role, check levels
+        if (actorRole === targetRole) {
+            // For same role, only higher level can moderate lower level
+            if (actorLevel <= targetLevel) {
+                return {
+                    allowed: false,
+                    reason: `Cannot moderate another ${actorRole.toLowerCase()} with equal or higher security level`,
+                    code: "SAME_LEVEL_RESTRICTION",
+                };
+            }
+        }
+        // All checks passed
+        return { allowed: true };
+    }
+    catch (error) {
+        console.error("Error in canModerateUser:", error);
+        return {
+            allowed: false,
+            reason: "Error checking moderation permissions",
+            code: "INSUFFICIENT_HIERARCHY",
+        };
+    }
+}
+/**
+ * Simplified version that just returns boolean
+ */
+async function canModerate(actorUser, targetUser) {
+    const result = await canModerateUser(actorUser, targetUser);
+    return result.allowed;
+}
+/**
+ * Get list of roles that actor can moderate
+ */
+function getModeratableRoles(actorRole) {
+    return CAN_ACT_ON[actorRole] || [];
+}
+/**
+ * Check if actor has higher authority than target
+ */
+function hasHigherAuthority(actorRole, actorLevel, targetRole, targetLevel) {
+    if (actorRole !== targetRole) {
+        // Different roles - check if actor can act on target
+        return (CAN_ACT_ON[actorRole] || []).includes(targetRole);
+    }
+    // Same role - compare levels
+    return actorLevel > targetLevel;
+}

package/dist/utils/suspension.utils.d.ts

@@ -0,0 +1,41 @@
+import { Suspension } from "vr-models";
+export declare const suspensionUtil: {
+    formatSuspensionForResponse: (suspension: any) => {
+        id: any;
+        user: {
+            id: any;
+            name: string;
+            phoneNumber: any;
+            email: any;
+        } | null;
+        admin: {
+            id: any;
+            name: string;
+        } | null;
+        reason: any;
+        startedAt: any;
+        endsAt: any;
+        isActive: any;
+        daysRemaining: number;
+        status: string;
+        appeal: {
+            appealedAt: any;
+            appealReason: any;
+            appealStatus: any;
+        } | null;
+        revocation: {
+            revokedAt: any;
+            revokingAdmin: {
+                id: any;
+                name: string;
+            } | null;
+            revocationReason: any;
+        } | null;
+        extensions: any;
+        createdAt: any;
+        updatedAt: any;
+    };
+    isSuspensionActive: (suspension: Suspension) => boolean;
+    canAppeal: (suspension: Suspension) => boolean;
+    getTimeRemaining: (suspension: Suspension) => number;
+};

package/dist/utils/suspension.utils.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suspensionUtil = void 0;
+exports.suspensionUtil = {
+    formatSuspensionForResponse: (suspension) => {
+        const suspensionJson = suspension.toJSON ? suspension.toJSON() : suspension;
+        const now = new Date();
+        const endDate = new Date(suspensionJson.endsAt);
+        const isCurrentlyActive = suspensionJson.isActive && endDate > now;
+        return {
+            id: suspensionJson.id,
+            user: suspensionJson.user
+                ? {
+                    id: suspensionJson.user.id,
+                    name: `${suspensionJson.user.firstName} ${suspensionJson.user.lastName}`,
+                    phoneNumber: suspensionJson.user.phoneNumber,
+                    email: suspensionJson.user.email,
+                }
+                : null,
+            admin: suspensionJson.admin
+                ? {
+                    id: suspensionJson.admin.id,
+                    name: `${suspensionJson.admin.firstName} ${suspensionJson.admin.lastName}`,
+                }
+                : null,
+            reason: suspensionJson.reason,
+            startedAt: suspensionJson.startedAt,
+            endsAt: suspensionJson.endsAt,
+            isActive: isCurrentlyActive,
+            daysRemaining: isCurrentlyActive
+                ? Math.ceil((endDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
+                : 0,
+            status: isCurrentlyActive
+                ? "ACTIVE"
+                : suspensionJson.revokedAt
+                    ? "REVOKED"
+                    : "EXPIRED",
+            appeal: suspensionJson.appealedAt
+                ? {
+                    appealedAt: suspensionJson.appealedAt,
+                    appealReason: suspensionJson.appealReason,
+                    appealStatus: suspensionJson.appealStatus,
+                }
+                : null,
+            revocation: suspensionJson.revokedAt
+                ? {
+                    revokedAt: suspensionJson.revokedAt,
+                    revokingAdmin: suspensionJson.revokingAdmin
+                        ? {
+                            id: suspensionJson.revokingAdmin.id,
+                            name: `${suspensionJson.revokingAdmin.firstName} ${suspensionJson.revokingAdmin.lastName}`,
+                        }
+                        : null,
+                    revocationReason: suspensionJson.revocationReason,
+                }
+                : null,
+            extensions: suspensionJson.metadata?.extensions || [],
+            createdAt: suspensionJson.createdAt,
+            updatedAt: suspensionJson.updatedAt,
+        };
+    },
+    isSuspensionActive: (suspension) => {
+        return suspension.isActive && new Date(suspension.endsAt) > new Date();
+    },
+    canAppeal: (suspension) => {
+        return (!suspension.appealedAt &&
+            !suspension.revokedAt &&
+            new Date(suspension.endsAt) > new Date());
+    },
+    getTimeRemaining: (suspension) => {
+        if (!suspension.isActive)
+            return 0;
+        const endDate = new Date(suspension.endsAt);
+        const now = new Date();
+        if (endDate <= now)
+            return 0;
+        return Math.ceil((endDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+    },
+};

package/dist/validations/appeals.validations.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const submitBanAppealSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        banId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        banId: string;
+    }, {
+        banId: string;
+    }>;
+    body: z.ZodObject<{
+        appealReason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        appealReason: string;
+    }, {
+        appealReason: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        banId: string;
+    };
+    body: {
+        appealReason: string;
+    };
+}, {
+    params: {
+        banId: string;
+    };
+    body: {
+        appealReason: string;
+    };
+}>;
+export declare const submitSuspensionAppealSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        suspensionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        suspensionId: string;
+    }, {
+        suspensionId: string;
+    }>;
+    body: z.ZodObject<{
+        appealReason: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        appealReason: string;
+    }, {
+        appealReason: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        suspensionId: string;
+    };
+    body: {
+        appealReason: string;
+    };
+}, {
+    params: {
+        suspensionId: string;
+    };
+    body: {
+        appealReason: string;
+    };
+}>;

package/dist/validations/appeals.validations.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitSuspensionAppealSchema = exports.submitBanAppealSchema = void 0;
+const zod_1 = require("zod");
+const uuidSchema = zod_1.z.string().uuid("Invalid ID format");
+exports.submitBanAppealSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        banId: uuidSchema,
+    }),
+    body: zod_1.z
+        .object({
+        appealReason: zod_1.z
+            .string()
+            .min(10, "Appeal reason must be at least 10 characters")
+            .max(2000, "Appeal reason cannot exceed 2000 characters"),
+    })
+        .strict(),
+});
+exports.submitSuspensionAppealSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        suspensionId: uuidSchema,
+    }),
+    body: zod_1.z
+        .object({
+        appealReason: zod_1.z
+            .string()
+            .min(10, "Appeal reason must be at least 10 characters")
+            .max(2000, "Appeal reason cannot exceed 2000 characters"),
+    })
+        .strict(),
+});

package/dist/validations/bans.validations.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const getBanSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        banId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        banId: string;
+    }, {
+        banId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        banId: string;
+    };
+}, {
+    params: {
+        banId: string;
+    };
+}>;
+export declare const getUserRestrictionsSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+    }, {
+        userId: string;
+    }>;
+    query: z.ZodObject<{
+        includeResolved: z.ZodOptional<z.ZodEnum<["true", "false"]>>;
+    }, "strip", z.ZodTypeAny, {
+        includeResolved?: "true" | "false" | undefined;
+    }, {
+        includeResolved?: "true" | "false" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+    };
+    query: {
+        includeResolved?: "true" | "false" | undefined;
+    };
+}, {
+    params: {
+        userId: string;
+    };
+    query: {
+        includeResolved?: "true" | "false" | undefined;
+    };
+}>;
+export declare const createBanSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+    }, {
+        userId: string;
+    }>;
+    body: z.ZodObject<{
+        reason: z.ZodString;
+        isPermanent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strict", z.ZodTypeAny, {
+        isPermanent: boolean;
+        reason: string;
+    }, {
+        reason: string;
+        isPermanent?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+    };
+    body: {
+        isPermanent: boolean;
+        reason: string;
+    };
+}, {
+    params: {
+        userId: string;
+    };
+    body: {
+        reason: string;
+        isPermanent?: boolean | undefined;
+    };
+}>;

package/dist/validations/bans.validations.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBanSchema = exports.getUserRestrictionsSchema = exports.getBanSchema = void 0;
+const zod_1 = require("zod");
+// Base schemas
+const uuidSchema = zod_1.z.string().uuid("Invalid UUID format");
+exports.getBanSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        banId: uuidSchema,
+    }),
+});
+exports.getUserRestrictionsSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        userId: uuidSchema,
+    }),
+    query: zod_1.z.object({
+        includeResolved: zod_1.z.enum(["true", "false"]).optional(),
+    }),
+});
+exports.createBanSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        userId: uuidSchema,
+    }),
+    body: zod_1.z
+        .object({
+        reason: zod_1.z
+            .string()
+            .min(5, "Reason must be at least 5 characters")
+            .max(1000, "Reason cannot exceed 1000 characters"),
+        isPermanent: zod_1.z.boolean().optional().default(false),
+    })
+        .strict(),
+});

package/dist/validations/dateRange.validations.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+/**
+ * Validates if a string is a valid date in any of the supported formats
+ * Supported formats:
+ * - YYYY-MM-DD (2024-03-18)
+ * - DD-MM-YYYY (18-03-2024)
+ * - YYYY/MM/DD (2024/03/18)
+ * - DD/MM/YYYY (18/03/2024)
+ */
+export declare const dateValidator: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Normalizes any supported date format to YYYY-MM-DD for database queries
+ */
+export declare const normalizeDate: (dateStr: string) => string;
+/**
+ * Creates a date schema that can be required or optional
+ */
+export declare const createDateSchema: (required?: boolean) => z.ZodEffects<z.ZodString, string, string> | z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+/**
+ * Date range schema for filtering between two dates
+ */
+export declare const dateRangeSchema: z.ZodEffects<z.ZodObject<{
+    fromDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    toDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    fromDate?: string | undefined;
+    toDate?: string | undefined;
+}, {
+    fromDate?: string | undefined;
+    toDate?: string | undefined;
+}>, {
+    fromDate?: string | undefined;
+    toDate?: string | undefined;
+}, {
+    fromDate?: string | undefined;
+    toDate?: string | undefined;
+}>;
+export declare const yyyyMmDdSchema: z.ZodString;
+export declare const ddMmYyyySchema: z.ZodString;