vr-commons 1.0.45 → 1.0.47

package/dist/middlewares/index.d.ts

@@ -1 +1,2 @@
 export { checkUserAuthentication } from "./auth.middlewares";
+export { checkUserAccountStatus, checkIsUserBanned, checkIsUserSuspended, } from "./account.middlewares";

package/dist/middlewares/index.js

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

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;

package/dist/validations/dateRange.validations.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ddMmYyyySchema = exports.yyyyMmDdSchema = exports.dateRangeSchema = exports.createDateSchema = exports.normalizeDate = exports.dateValidator = void 0;
+const zod_1 = require("zod");
+// Regular expressions for date formats
+const YYYY_MM_DD_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const DD_MM_YYYY_REGEX = /^\d{2}-\d{2}-\d{4}$/;
+const YYYY_MM_DD_HYPHEN_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const DD_MM_YYYY_SLASH_REGEX = /^\d{2}\/\d{2}\/\d{4}$/;
+const YYYY_MM_DD_SLASH_REGEX = /^\d{4}\/\d{2}\/\d{2}$/;
+/**
+ * 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)
+ */
+exports.dateValidator = zod_1.z.string().refine((val) => {
+    // Check YYYY-MM-DD format
+    if (YYYY_MM_DD_REGEX.test(val)) {
+        const [year, month, day] = val.split("-").map(Number);
+        const date = new Date(year, month - 1, day);
+        return (date.getFullYear() === year &&
+            date.getMonth() === month - 1 &&
+            date.getDate() === day);
+    }
+    // Check DD-MM-YYYY format
+    if (DD_MM_YYYY_REGEX.test(val)) {
+        const [day, month, year] = val.split("-").map(Number);
+        const date = new Date(year, month - 1, day);
+        return (date.getFullYear() === year &&
+            date.getMonth() === month - 1 &&
+            date.getDate() === day);
+    }
+    // Check YYYY/MM/DD format
+    if (YYYY_MM_DD_SLASH_REGEX.test(val)) {
+        const [year, month, day] = val.split("/").map(Number);
+        const date = new Date(year, month - 1, day);
+        return (date.getFullYear() === year &&
+            date.getMonth() === month - 1 &&
+            date.getDate() === day);
+    }
+    // Check DD/MM/YYYY format
+    if (DD_MM_YYYY_SLASH_REGEX.test(val)) {
+        const [day, month, year] = val.split("/").map(Number);
+        const date = new Date(year, month - 1, day);
+        return (date.getFullYear() === year &&
+            date.getMonth() === month - 1 &&
+            date.getDate() === day);
+    }
+    return false;
+}, {
+    message: "Date must be in one of these formats: YYYY-MM-DD, DD-MM-YYYY, YYYY/MM/DD, or DD/MM/YYYY",
+});
+/**
+ * Normalizes any supported date format to YYYY-MM-DD for database queries
+ */
+const normalizeDate = (dateStr) => {
+    // Already YYYY-MM-DD
+    if (YYYY_MM_DD_REGEX.test(dateStr)) {
+        return dateStr;
+    }
+    // DD-MM-YYYY to YYYY-MM-DD
+    if (DD_MM_YYYY_REGEX.test(dateStr)) {
+        const [day, month, year] = dateStr.split("-");
+        return `${year}-${month}-${day}`;
+    }
+    // YYYY/MM/DD to YYYY-MM-DD
+    if (YYYY_MM_DD_SLASH_REGEX.test(dateStr)) {
+        const [year, month, day] = dateStr.split("/");
+        return `${year}-${month}-${day}`;
+    }
+    // DD/MM/YYYY to YYYY-MM-DD
+    if (DD_MM_YYYY_SLASH_REGEX.test(dateStr)) {
+        const [day, month, year] = dateStr.split("/");
+        return `${year}-${month}-${day}`;
+    }
+    return dateStr;
+};
+exports.normalizeDate = normalizeDate;
+/**
+ * Creates a date schema that can be required or optional
+ */
+const createDateSchema = (required = false) => {
+    if (required) {
+        return exports.dateValidator;
+    }
+    return exports.dateValidator.optional();
+};
+exports.createDateSchema = createDateSchema;
+/**
+ * Date range schema for filtering between two dates
+ */
+exports.dateRangeSchema = zod_1.z
+    .object({
+    fromDate: exports.dateValidator.optional(),
+    toDate: exports.dateValidator.optional(),
+})
+    .transform((data) => {
+    if (data.fromDate) {
+        data.fromDate = (0, exports.normalizeDate)(data.fromDate);
+    }
+    if (data.toDate) {
+        data.toDate = (0, exports.normalizeDate)(data.toDate);
+    }
+    return data;
+});
+// Export individual format validators if needed
+exports.yyyyMmDdSchema = zod_1.z
+    .string()
+    .regex(YYYY_MM_DD_REGEX, "Date must be in YYYY-MM-DD format");
+exports.ddMmYyyySchema = zod_1.z
+    .string()
+    .regex(DD_MM_YYYY_REGEX, "Date must be in DD-MM-YYYY format");

package/dist/validations/index.d.ts

@@ -1,3 +1,7 @@
 export { validate } from "./validate.validations";
 export { riderLoginSchema, forgotPasswordSchema, userLoginSchema, } from "./auth.validations";
 export { createUserSchema, getUserByIdSchema, updateUserProfileSchema, getAllUsersSchema, viewProfileSchema, passengerSignupSchema, updatePassengerProfileSchema, updateRiderProfileSchema, createRiderSchema, changePasswordSchema, deactivateAccountSchema, deleteAccountSchema, } from "./profiles.validations";
+export { listBansSchema, listPendingAppealsSchema, listSuspensionsSchema, reviewAppealSchema, revokeBanSchema, revokeSuspensionSchema, extendSuspensionSchema, exportBansSchema, } from "./moderation.validations";
+export { submitBanAppealSchema, submitSuspensionAppealSchema, } from "./appeals.validations";
+export { getBanSchema, getUserRestrictionsSchema, createBanSchema, } from "./bans.validations";
+export { getSuspensionSchema, getUserSuspensionsSchema, createSuspensionSchema, } from "./suspensions.validations";

package/dist/validations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteAccountSchema = exports.deactivateAccountSchema = exports.changePasswordSchema = exports.createRiderSchema = exports.updateRiderProfileSchema = exports.updatePassengerProfileSchema = exports.passengerSignupSchema = exports.viewProfileSchema = exports.getAllUsersSchema = exports.updateUserProfileSchema = exports.getUserByIdSchema = exports.createUserSchema = exports.userLoginSchema = exports.forgotPasswordSchema = exports.riderLoginSchema = exports.validate = void 0;
+exports.createSuspensionSchema = exports.getUserSuspensionsSchema = exports.getSuspensionSchema = exports.createBanSchema = exports.getUserRestrictionsSchema = exports.getBanSchema = exports.submitSuspensionAppealSchema = exports.submitBanAppealSchema = exports.exportBansSchema = exports.extendSuspensionSchema = exports.revokeSuspensionSchema = exports.revokeBanSchema = exports.reviewAppealSchema = exports.listSuspensionsSchema = exports.listPendingAppealsSchema = exports.listBansSchema = exports.deleteAccountSchema = exports.deactivateAccountSchema = exports.changePasswordSchema = exports.createRiderSchema = exports.updateRiderProfileSchema = exports.updatePassengerProfileSchema = exports.passengerSignupSchema = exports.viewProfileSchema = exports.getAllUsersSchema = exports.updateUserProfileSchema = exports.getUserByIdSchema = exports.createUserSchema = exports.userLoginSchema = exports.forgotPasswordSchema = exports.riderLoginSchema = 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");
@@ -25,3 +25,23 @@ Object.defineProperty(exports, "createRiderSchema", { enumerable: true, get: fun
 Object.defineProperty(exports, "changePasswordSchema", { enumerable: true, get: function () { return profiles_validations_1.changePasswordSchema; } });
 Object.defineProperty(exports, "deactivateAccountSchema", { enumerable: true, get: function () { return profiles_validations_1.deactivateAccountSchema; } });
 Object.defineProperty(exports, "deleteAccountSchema", { enumerable: true, get: function () { return profiles_validations_1.deleteAccountSchema; } });
+var moderation_validations_1 = require("./moderation.validations");
+Object.defineProperty(exports, "listBansSchema", { enumerable: true, get: function () { return moderation_validations_1.listBansSchema; } });
+Object.defineProperty(exports, "listPendingAppealsSchema", { enumerable: true, get: function () { return moderation_validations_1.listPendingAppealsSchema; } });
+Object.defineProperty(exports, "listSuspensionsSchema", { enumerable: true, get: function () { return moderation_validations_1.listSuspensionsSchema; } });
+Object.defineProperty(exports, "reviewAppealSchema", { enumerable: true, get: function () { return moderation_validations_1.reviewAppealSchema; } });
+Object.defineProperty(exports, "revokeBanSchema", { enumerable: true, get: function () { return moderation_validations_1.revokeBanSchema; } });
+Object.defineProperty(exports, "revokeSuspensionSchema", { enumerable: true, get: function () { return moderation_validations_1.revokeSuspensionSchema; } });
+Object.defineProperty(exports, "extendSuspensionSchema", { enumerable: true, get: function () { return moderation_validations_1.extendSuspensionSchema; } });
+Object.defineProperty(exports, "exportBansSchema", { enumerable: true, get: function () { return moderation_validations_1.exportBansSchema; } });
+var appeals_validations_1 = require("./appeals.validations");
+Object.defineProperty(exports, "submitBanAppealSchema", { enumerable: true, get: function () { return appeals_validations_1.submitBanAppealSchema; } });
+Object.defineProperty(exports, "submitSuspensionAppealSchema", { enumerable: true, get: function () { return appeals_validations_1.submitSuspensionAppealSchema; } });
+var bans_validations_1 = require("./bans.validations");
+Object.defineProperty(exports, "getBanSchema", { enumerable: true, get: function () { return bans_validations_1.getBanSchema; } });
+Object.defineProperty(exports, "getUserRestrictionsSchema", { enumerable: true, get: function () { return bans_validations_1.getUserRestrictionsSchema; } });
+Object.defineProperty(exports, "createBanSchema", { enumerable: true, get: function () { return bans_validations_1.createBanSchema; } });
+var suspensions_validations_1 = require("./suspensions.validations");
+Object.defineProperty(exports, "getSuspensionSchema", { enumerable: true, get: function () { return suspensions_validations_1.getSuspensionSchema; } });
+Object.defineProperty(exports, "getUserSuspensionsSchema", { enumerable: true, get: function () { return suspensions_validations_1.getUserSuspensionsSchema; } });
+Object.defineProperty(exports, "createSuspensionSchema", { enumerable: true, get: function () { return suspensions_validations_1.createSuspensionSchema; } });

package/dist/validations/moderation.validations.d.ts

@@ -0,0 +1,404 @@
+import { z } from "zod";
+export declare const listBansSchema: z.ZodObject<{
+    query: z.ZodEffects<z.ZodObject<{
+        page: z.ZodPipeline<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, z.ZodNumber>;
+        limit: z.ZodPipeline<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, z.ZodNumber>;
+    } & {
+        userId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<["active", "revoked"]>>;
+        appealStatus: z.ZodOptional<z.ZodEnum<["pending", "approved", "rejected"]>>;
+        isPermanent: z.ZodOptional<z.ZodEnum<["true", "false"]>>;
+        fromDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        toDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        search: z.ZodOptional<z.ZodString>;
+        sortBy: z.ZodOptional<z.ZodEnum<["bannedAt", "createdAt", "reason"]>>;
+        sortOrder: z.ZodOptional<z.ZodEnum<["ASC", "DESC"]>>;
+    }, "strip", z.ZodTypeAny, {
+        page: number;
+        limit: number;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        isPermanent?: "true" | "false" | undefined;
+        search?: string | undefined;
+        sortBy?: "bannedAt" | "createdAt" | "reason" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }, {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        isPermanent?: "true" | "false" | undefined;
+        search?: string | undefined;
+        sortBy?: "bannedAt" | "createdAt" | "reason" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }>, {
+        page: number;
+        limit: number;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        isPermanent?: "true" | "false" | undefined;
+        search?: string | undefined;
+        sortBy?: "bannedAt" | "createdAt" | "reason" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }, {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        isPermanent?: "true" | "false" | undefined;
+        search?: string | undefined;
+        sortBy?: "bannedAt" | "createdAt" | "reason" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    query: {
+        page: number;
+        limit: number;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        isPermanent?: "true" | "false" | undefined;
+        search?: string | undefined;
+        sortBy?: "bannedAt" | "createdAt" | "reason" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    };
+}, {
+    query: {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        isPermanent?: "true" | "false" | undefined;
+        search?: string | undefined;
+        sortBy?: "bannedAt" | "createdAt" | "reason" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    };
+}>;
+export declare const listSuspensionsSchema: z.ZodObject<{
+    query: z.ZodEffects<z.ZodObject<{
+        page: z.ZodPipeline<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, z.ZodNumber>;
+        limit: z.ZodPipeline<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, z.ZodNumber>;
+    } & {
+        userId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<["active", "expired", "revoked"]>>;
+        appealStatus: z.ZodOptional<z.ZodEnum<["pending", "approved", "rejected"]>>;
+        fromDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        toDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        search: z.ZodOptional<z.ZodString>;
+        sortBy: z.ZodOptional<z.ZodEnum<["startedAt", "endsAt", "createdAt", "reason"]>>;
+        sortOrder: z.ZodOptional<z.ZodEnum<["ASC", "DESC"]>>;
+    }, "strip", z.ZodTypeAny, {
+        page: number;
+        limit: number;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | "expired" | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        search?: string | undefined;
+        sortBy?: "createdAt" | "reason" | "startedAt" | "endsAt" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }, {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | "expired" | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        search?: string | undefined;
+        sortBy?: "createdAt" | "reason" | "startedAt" | "endsAt" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }>, {
+        page: number;
+        limit: number;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | "expired" | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        search?: string | undefined;
+        sortBy?: "createdAt" | "reason" | "startedAt" | "endsAt" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }, {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | "expired" | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        search?: string | undefined;
+        sortBy?: "createdAt" | "reason" | "startedAt" | "endsAt" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    query: {
+        page: number;
+        limit: number;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | "expired" | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        search?: string | undefined;
+        sortBy?: "createdAt" | "reason" | "startedAt" | "endsAt" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    };
+}, {
+    query: {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        status?: "active" | "revoked" | "expired" | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+        userId?: string | undefined;
+        appealStatus?: "pending" | "approved" | "rejected" | undefined;
+        search?: string | undefined;
+        sortBy?: "createdAt" | "reason" | "startedAt" | "endsAt" | undefined;
+        sortOrder?: "ASC" | "DESC" | undefined;
+    };
+}>;
+export declare const revokeBanSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        banId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        banId: string;
+    }, {
+        banId: string;
+    }>;
+    body: z.ZodObject<{
+        revocationReason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        revocationReason?: string | undefined;
+    }, {
+        revocationReason?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        banId: string;
+    };
+    body: {
+        revocationReason?: string | undefined;
+    };
+}, {
+    params: {
+        banId: string;
+    };
+    body: {
+        revocationReason?: string | undefined;
+    };
+}>;
+export declare const revokeSuspensionSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        suspensionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        suspensionId: string;
+    }, {
+        suspensionId: string;
+    }>;
+    body: z.ZodObject<{
+        revocationReason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        revocationReason?: string | undefined;
+    }, {
+        revocationReason?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        suspensionId: string;
+    };
+    body: {
+        revocationReason?: string | undefined;
+    };
+}, {
+    params: {
+        suspensionId: string;
+    };
+    body: {
+        revocationReason?: string | undefined;
+    };
+}>;
+export declare const extendSuspensionSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        suspensionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        suspensionId: string;
+    }, {
+        suspensionId: string;
+    }>;
+    body: z.ZodEffects<z.ZodObject<{
+        newEndDate: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        extensionReason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        newEndDate: string;
+        extensionReason?: string | undefined;
+    }, {
+        newEndDate: string;
+        extensionReason?: string | undefined;
+    }>, {
+        newEndDate: string;
+        extensionReason?: string | undefined;
+    }, {
+        newEndDate: string;
+        extensionReason?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        suspensionId: string;
+    };
+    body: {
+        newEndDate: string;
+        extensionReason?: string | undefined;
+    };
+}, {
+    params: {
+        suspensionId: string;
+    };
+    body: {
+        newEndDate: string;
+        extensionReason?: string | undefined;
+    };
+}>;
+export declare const listPendingAppealsSchema: z.ZodObject<{
+    query: z.ZodEffects<z.ZodObject<{
+        page: z.ZodPipeline<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, z.ZodNumber>;
+        limit: z.ZodPipeline<z.ZodEffects<z.ZodOptional<z.ZodString>, number, string | undefined>, z.ZodNumber>;
+    } & {
+        type: z.ZodOptional<z.ZodEnum<["ban", "suspension"]>>;
+        fromDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        toDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        page: number;
+        limit: number;
+        type?: "ban" | "suspension" | undefined;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+    }, {
+        type?: "ban" | "suspension" | undefined;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+    }>, {
+        page: number;
+        limit: number;
+        type?: "ban" | "suspension" | undefined;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+    }, {
+        type?: "ban" | "suspension" | undefined;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    query: {
+        page: number;
+        limit: number;
+        type?: "ban" | "suspension" | undefined;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+    };
+}, {
+    query: {
+        type?: "ban" | "suspension" | undefined;
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        page?: string | undefined;
+        limit?: string | undefined;
+    };
+}>;
+export declare const reviewAppealSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        banId: z.ZodOptional<z.ZodString>;
+        suspensionId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        banId?: string | undefined;
+        suspensionId?: string | undefined;
+    }, {
+        banId?: string | undefined;
+        suspensionId?: string | undefined;
+    }>;
+    body: z.ZodObject<{
+        appealStatus: z.ZodEnum<["approved", "rejected"]>;
+        adminNotes: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        appealStatus: "approved" | "rejected";
+        adminNotes?: string | undefined;
+    }, {
+        appealStatus: "approved" | "rejected";
+        adminNotes?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        banId?: string | undefined;
+        suspensionId?: string | undefined;
+    };
+    body: {
+        appealStatus: "approved" | "rejected";
+        adminNotes?: string | undefined;
+    };
+}, {
+    params: {
+        banId?: string | undefined;
+        suspensionId?: string | undefined;
+    };
+    body: {
+        appealStatus: "approved" | "rejected";
+        adminNotes?: string | undefined;
+    };
+}>;
+export declare const exportBansSchema: z.ZodObject<{
+    query: z.ZodEffects<z.ZodObject<{
+        fromDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        toDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        format: z.ZodDefault<z.ZodEnum<["csv"]>>;
+    }, "strip", z.ZodTypeAny, {
+        format: "csv";
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+    }, {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        format?: "csv" | undefined;
+    }>, {
+        format: "csv";
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+    }, {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        format?: "csv" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    query: {
+        format: "csv";
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+    };
+}, {
+    query: {
+        fromDate?: string | undefined;
+        toDate?: string | undefined;
+        format?: "csv" | undefined;
+    };
+}>;

package/dist/validations/moderation.validations.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportBansSchema = exports.reviewAppealSchema = exports.listPendingAppealsSchema = exports.extendSuspensionSchema = exports.revokeSuspensionSchema = exports.revokeBanSchema = exports.listSuspensionsSchema = exports.listBansSchema = void 0;
+const zod_1 = require("zod");
+const dateRange_validations_1 = require("./dateRange.validations");
+const uuidSchema = zod_1.z.string().uuid("Invalid UUID format");
+// Base query schema with common pagination fields
+const paginationSchema = zod_1.z.object({
+    page: zod_1.z
+        .string()
+        .optional()
+        .transform((val) => (val ? parseInt(val) : 1))
+        .pipe(zod_1.z.number().min(1)),
+    limit: zod_1.z
+        .string()
+        .optional()
+        .transform((val) => (val ? parseInt(val) : 20))
+        .pipe(zod_1.z.number().min(1).max(100)),
+});
+exports.listBansSchema = zod_1.z.object({
+    query: paginationSchema
+        .extend({
+        userId: zod_1.z.string().uuid("Invalid user ID").optional(),
+        status: zod_1.z.enum(["active", "revoked"]).optional(),
+        appealStatus: zod_1.z.enum(["pending", "approved", "rejected"]).optional(),
+        isPermanent: zod_1.z.enum(["true", "false"]).optional(),
+        fromDate: dateRange_validations_1.dateValidator.optional(),
+        toDate: dateRange_validations_1.dateValidator.optional(),
+        search: zod_1.z.string().optional(),
+        sortBy: zod_1.z.enum(["bannedAt", "createdAt", "reason"]).optional(),
+        sortOrder: zod_1.z.enum(["ASC", "DESC"]).optional(),
+    })
+        .transform((data) => {
+        // Normalize dates for DB queries
+        if (data.fromDate) {
+            data.fromDate = (0, dateRange_validations_1.normalizeDate)(data.fromDate);
+        }
+        if (data.toDate) {
+            data.toDate = (0, dateRange_validations_1.normalizeDate)(data.toDate);
+        }
+        return data;
+    }),
+});
+exports.listSuspensionsSchema = zod_1.z.object({
+    query: paginationSchema
+        .extend({
+        userId: zod_1.z.string().uuid("Invalid user ID").optional(),
+        status: zod_1.z.enum(["active", "expired", "revoked"]).optional(),
+        appealStatus: zod_1.z.enum(["pending", "approved", "rejected"]).optional(),
+        fromDate: dateRange_validations_1.dateValidator.optional(),
+        toDate: dateRange_validations_1.dateValidator.optional(),
+        search: zod_1.z.string().optional(),
+        sortBy: zod_1.z.enum(["startedAt", "endsAt", "createdAt", "reason"]).optional(),
+        sortOrder: zod_1.z.enum(["ASC", "DESC"]).optional(),
+    })
+        .transform((data) => {
+        // Normalize dates for DB queries
+        if (data.fromDate) {
+            data.fromDate = (0, dateRange_validations_1.normalizeDate)(data.fromDate);
+        }
+        if (data.toDate) {
+            data.toDate = (0, dateRange_validations_1.normalizeDate)(data.toDate);
+        }
+        return data;
+    }),
+});
+exports.revokeBanSchema = zod_1.z.object({
+    params: zod_1.z.object({ banId: uuidSchema }),
+    body: zod_1.z.object({ revocationReason: zod_1.z.string().max(500).optional() }).strict(),
+});
+exports.revokeSuspensionSchema = zod_1.z.object({
+    params: zod_1.z.object({ suspensionId: uuidSchema }),
+    body: zod_1.z.object({ revocationReason: zod_1.z.string().max(500).optional() }).strict(),
+});
+exports.extendSuspensionSchema = zod_1.z.object({
+    params: zod_1.z.object({ suspensionId: uuidSchema }),
+    body: zod_1.z
+        .object({
+        newEndDate: dateRange_validations_1.dateValidator.refine((date) => {
+            const normalizedDate = (0, dateRange_validations_1.normalizeDate)(date);
+            return new Date(normalizedDate) > new Date();
+        }, { message: "New end date must be in the future" }),
+        extensionReason: zod_1.z.string().max(500).optional(),
+    })
+        .strict()
+        .transform((data) => ({
+        ...data,
+        newEndDate: (0, dateRange_validations_1.normalizeDate)(data.newEndDate), // Normalize for DB
+    })),
+});
+exports.listPendingAppealsSchema = zod_1.z.object({
+    query: paginationSchema
+        .extend({
+        type: zod_1.z.enum(["ban", "suspension"]).optional(),
+        fromDate: dateRange_validations_1.dateValidator.optional(),
+        toDate: dateRange_validations_1.dateValidator.optional(),
+    })
+        .transform((data) => {
+        // Normalize dates for DB queries
+        if (data.fromDate) {
+            data.fromDate = (0, dateRange_validations_1.normalizeDate)(data.fromDate);
+        }
+        if (data.toDate) {
+            data.toDate = (0, dateRange_validations_1.normalizeDate)(data.toDate);
+        }
+        return data;
+    }),
+});
+exports.reviewAppealSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        banId: uuidSchema.optional(),
+        suspensionId: uuidSchema.optional(),
+    }),
+    body: zod_1.z
+        .object({
+        appealStatus: zod_1.z.enum(["approved", "rejected"]),
+        adminNotes: zod_1.z.string().max(1000).optional(),
+    })
+        .strict(),
+});
+exports.exportBansSchema = zod_1.z.object({
+    query: zod_1.z
+        .object({
+        fromDate: dateRange_validations_1.dateValidator.optional(),
+        toDate: dateRange_validations_1.dateValidator.optional(),
+        format: zod_1.z.enum(["csv"]).default("csv"),
+    })
+        .transform((data) => {
+        // Normalize dates for DB queries
+        if (data.fromDate) {
+            data.fromDate = (0, dateRange_validations_1.normalizeDate)(data.fromDate);
+        }
+        if (data.toDate) {
+            data.toDate = (0, dateRange_validations_1.normalizeDate)(data.toDate);
+        }
+        return data;
+    }),
+});

package/dist/validations/suspensions.validations.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+export declare const getSuspensionSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        suspensionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        suspensionId: string;
+    }, {
+        suspensionId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        suspensionId: string;
+    };
+}, {
+    params: {
+        suspensionId: string;
+    };
+}>;
+export declare const getUserSuspensionsSchema: 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"]>>;
+        status: z.ZodOptional<z.ZodEnum<["active", "expired", "revoked"]>>;
+    }, "strip", z.ZodTypeAny, {
+        status?: "active" | "revoked" | "expired" | undefined;
+        includeResolved?: "true" | "false" | undefined;
+    }, {
+        status?: "active" | "revoked" | "expired" | undefined;
+        includeResolved?: "true" | "false" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+    };
+    query: {
+        status?: "active" | "revoked" | "expired" | undefined;
+        includeResolved?: "true" | "false" | undefined;
+    };
+}, {
+    params: {
+        userId: string;
+    };
+    query: {
+        status?: "active" | "revoked" | "expired" | undefined;
+        includeResolved?: "true" | "false" | undefined;
+    };
+}>;
+export declare const createSuspensionSchema: z.ZodObject<{
+    params: z.ZodObject<{
+        userId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+    }, {
+        userId: string;
+    }>;
+    body: z.ZodObject<{
+        reason: z.ZodString;
+        endsAt: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        reason: string;
+        endsAt: string;
+    }, {
+        reason: string;
+        endsAt: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    params: {
+        userId: string;
+    };
+    body: {
+        reason: string;
+        endsAt: string;
+    };
+}, {
+    params: {
+        userId: string;
+    };
+    body: {
+        reason: string;
+        endsAt: string;
+    };
+}>;

package/dist/validations/suspensions.validations.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSuspensionSchema = exports.getUserSuspensionsSchema = exports.getSuspensionSchema = void 0;
+const zod_1 = require("zod");
+// Base schemas
+const uuidSchema = zod_1.z.string().uuid("Invalid UUID format");
+exports.getSuspensionSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        suspensionId: uuidSchema,
+    }),
+});
+exports.getUserSuspensionsSchema = zod_1.z.object({
+    params: zod_1.z.object({
+        userId: uuidSchema,
+    }),
+    query: zod_1.z.object({
+        includeResolved: zod_1.z.enum(["true", "false"]).optional(),
+        status: zod_1.z.enum(["active", "expired", "revoked"]).optional(),
+    }),
+});
+exports.createSuspensionSchema = 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"),
+        endsAt: zod_1.z
+            .string()
+            .datetime("Invalid date format")
+            .refine((date) => new Date(date) > new Date(), {
+            message: "End date must be in the future",
+        }),
+    })
+        .strict(),
+});

package/package.json

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