@lyxa.ai/types/utilities/validation/common-validation.js

Lyxa type definitions and validation schemas for both frontend and backend

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AssignRiderSchema = exports.UpdateFcmTokenInputSchema = exports.ShareableLinkResponseSchema = exports.GetOneQuerySchema = exports.GetByTokenInputSchema = exports.GetOrderByIdInputSchema = exports.GetProductByIdInputSchema = exports.GetByIdInputSchema = exports.IdSchema = exports.DeleteSchema = exports.UpdateSortingOrderSchema = exports.TokenSchema = exports.createResponseSchema = exports.createPaginatedSchema = exports.LoginSchema = exports.WorkHourSettingSchema = exports.HolidayHourSchema = exports.NormalHourSchema = exports.DurationSchema = exports.CourierAddressSchema = exports.RegularOrderAddressSchema = exports.UserAddressSchema = exports.AddressSchema = exports.StringSchema = exports.FilterSchema = void 0;
const zod_1 = require("zod");
const global_validation_1 = require("./global-validation");
const enum_1 = require("../enum");
const MongoQuerySchema = zod_1.z.lazy(() => zod_1.z.record(zod_1.z.union([zod_1.z.any(), MongoOperatorsSchema])));
const MongoOperatorsSchema = zod_1.z.object({
    $eq: zod_1.z.any().optional(),
    $ne: zod_1.z.any().optional(),
    $gt: zod_1.z.any().optional(),
    $gte: zod_1.z.any().optional(),
    $lt: zod_1.z.any().optional(),
    $lte: zod_1.z.any().optional(),
    $in: zod_1.z.array(zod_1.z.any()).optional(),
    $nin: zod_1.z.array(zod_1.z.any()).optional(),
    $exists: zod_1.z.boolean().optional(),
    $regex: zod_1.z.string().optional(),
    $and: zod_1.z.array(MongoQuerySchema).optional(),
    $or: zod_1.z.array(MongoQuerySchema).optional(),
    $not: MongoQuerySchema.optional(),
    $nor: zod_1.z.array(MongoQuerySchema).optional(),
});
const sortSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(1), zod_1.z.literal(-1)]));
const populateSchema = zod_1.z.lazy(() => zod_1.z.object({
    path: zod_1.z.string(),
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    match: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
    options: zod_1.z
        .object({
        sort: sortSchema.optional(),
        limit: zod_1.z.number().optional(),
        skip: zod_1.z.number().optional(),
    })
        .optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
}));
exports.FilterSchema = zod_1.z
    .object({
    size: zod_1.z
        .number()
        .min(1, { message: 'Size must be greater than 0.' })
        .max(100, { message: 'Size cannot exceed 100.' })
        .optional()
        .default(10),
    page: zod_1.z.number().min(1, { message: 'Page number must be at least 1.' }).optional().default(1),
    sort: sortSchema.optional(),
    query: MongoQuerySchema.optional(),
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
    search: zod_1.z.object({ searchKey: zod_1.z.string(), searchFields: zod_1.z.array(zod_1.z.string()).optional() }).optional(),
})
    .optional();
exports.StringSchema = zod_1.z.string().min(1, 'String cannot be empty').max(255, 'String is too long');
exports.AddressSchema = zod_1.z.object({
    address: global_validation_1.ZodValidation.string('Address'),
    description: global_validation_1.ZodValidation.string('Description').optional(),
    city: global_validation_1.ZodValidation.string('City'),
    state: global_validation_1.ZodValidation.string('State').optional(),
    country: global_validation_1.ZodValidation.string('Country'),
    location: zod_1.z.object({
        type: global_validation_1.ZodValidation.enumType(enum_1.GeoLocationType, 'GeoLocationType').default(enum_1.GeoLocationType.POINT),
        coordinates: zod_1.z.tuple([
            global_validation_1.ZodValidation.number('Longitude', { min: -180, max: 180 }),
            global_validation_1.ZodValidation.number('Latitude', { min: -90, max: 90 }),
        ]),
    }),
    latitude: global_validation_1.ZodValidation.number('Latitude', { min: -90, max: 90 }),
    longitude: global_validation_1.ZodValidation.number('Longitude', { min: -180, max: 180 }),
    zone: global_validation_1.ZodValidation.objectId('Zone').optional(),
});
exports.UserAddressSchema = exports.AddressSchema.extend({
    addressLabel: global_validation_1.ZodValidation.string('Address Label'),
    apartment: global_validation_1.ZodValidation.string('Apartment'),
    buildingName: global_validation_1.ZodValidation.string('Building Name'),
    deliveryOption: global_validation_1.ZodValidation.string('Delivery Option').optional(),
    instructions: global_validation_1.ZodValidation.string('Instructions').optional(),
});
exports.RegularOrderAddressSchema = exports.UserAddressSchema.extend({
    _id: global_validation_1.ZodValidation.objectId('ID of the user address'),
});
exports.CourierAddressSchema = exports.UserAddressSchema.extend({
    name: global_validation_1.ZodValidation.string('Name'),
    phoneNumber: global_validation_1.ZodValidation.string('Phone Number'),
});
exports.DurationSchema = zod_1.z.object({
    start: global_validation_1.ZodValidation.date('Start'),
    end: global_validation_1.ZodValidation.date('End').optional(),
});
const TimeStringSchema = zod_1.z
    .string()
    .regex(/^([0-9]|[01]\d|2[0-3]):([0-5]\d)$/, 'Time must be in HH:mm format (e.g., 09:30 or 9:30)')
    .transform(time => {
    let [h, m] = time.split(':');
    h = h.padStart(2, '0');
    return `${h}:${m}`;
})
    .refine(time => {
    const [h, m] = time.split(':').map(Number);
    return h >= 0 && h <= 23 && m >= 0 && m <= 59;
}, { message: 'Invalid time range, must be between 00:00 and 23:59' });
const StartEndTimeSchema = zod_1.z
    .object({
    start: TimeStringSchema,
    end: TimeStringSchema,
})
    .refine(data => {
    const start = parseInt(data.start.replace(':', ''));
    const end = parseInt(data.end.replace(':', ''));
    return end > start;
}, {
    message: 'End time must be later than start time',
    path: ['end'],
})
    .refine(data => {
    const end = parseInt(data.end.replace(':', ''));
    return end <= 2359;
}, {
    message: 'End time cannot exceed 23:59',
    path: ['end'],
});
exports.NormalHourSchema = zod_1.z.object({
    day: global_validation_1.ZodValidation.enumType(enum_1.WeekDay, 'Day'),
    status: global_validation_1.ZodValidation.enumType(enum_1.WorkStatus, 'Status'),
    openingHours: global_validation_1.ZodValidation.array(StartEndTimeSchema)
        .default([])
        .refine(arr => {
        if (arr.length === 0)
            return true;
        for (let i = 1; i < arr.length; i++) {
            const prevEnd = parseInt(arr[i - 1].end.replace(':', ''));
            const currStart = parseInt(arr[i].start.replace(':', ''));
            if (currStart < prevEnd)
                return false;
        }
        return true;
    }, {
        message: 'Opening hours must be non-overlapping and in chronological order',
    }),
});
exports.HolidayHourSchema = zod_1.z.object({
    date: global_validation_1.ZodValidation.date('Date'),
    status: global_validation_1.ZodValidation.enumType(enum_1.HolidayWorkStatus, 'Status'),
    closingHour: StartEndTimeSchema,
});
exports.WorkHourSettingSchema = zod_1.z.object({
    normalHours: global_validation_1.ZodValidation.array(exports.NormalHourSchema).default([]),
    holidayHours: global_validation_1.ZodValidation.array(exports.HolidayHourSchema).default([]),
});
exports.LoginSchema = zod_1.z.object({
    email: global_validation_1.ZodValidation.email('Email', {
        requiredMessage: 'Please enter a valid email address.',
        invalidMessage: 'Please enter a valid email address.',
    }),
    password: global_validation_1.ZodValidation.string('Password', { requiredMessage: 'Please enter password' }),
});
const metadataSchema = zod_1.z.object({
    page: global_validation_1.ZodValidation.number(),
    size: global_validation_1.ZodValidation.number(),
    totalElements: global_validation_1.ZodValidation.number(),
    totalPages: global_validation_1.ZodValidation.number(),
});
const createPaginatedSchema = (documentSchema) => zod_1.z.object({
    metadata: metadataSchema.optional(),
    documents: global_validation_1.ZodValidation.array(documentSchema),
});
exports.createPaginatedSchema = createPaginatedSchema;
const createResponseSchema = (schema) => zod_1.z.object({
    success: global_validation_1.ZodValidation.boolean(),
    message: global_validation_1.ZodValidation.string(),
    data: zod_1.z.union([(0, exports.createPaginatedSchema)(schema), schema]).optional(),
});
exports.createResponseSchema = createResponseSchema;
exports.TokenSchema = zod_1.z.object({
    accessToken: global_validation_1.ZodValidation.string('AccessToken'),
    refreshToken: global_validation_1.ZodValidation.string('RefreshToken'),
});
exports.UpdateSortingOrderSchema = zod_1.z.object({
    _id: global_validation_1.ZodValidation.objectId('_id'),
    newPosition: global_validation_1.ZodValidation.number('New position'),
});
exports.DeleteSchema = zod_1.z.object({
    _id: global_validation_1.ZodValidation.objectId('_id'),
    softDelete: global_validation_1.ZodValidation.boolean('Soft Delete').default(true),
});
exports.IdSchema = global_validation_1.ZodValidation.objectId();
exports.GetByIdInputSchema = zod_1.z.object({
    _id: global_validation_1.ZodValidation.objectId('_id'),
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
});
exports.GetProductByIdInputSchema = zod_1.z.object({
    _id: global_validation_1.ZodValidation.objectId('_id'),
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
    withAttributeHiddenItems: zod_1.z.boolean().optional().default(true),
    withAddonsHiddenItems: zod_1.z.boolean().optional().default(true),
});
exports.GetOrderByIdInputSchema = zod_1.z.object({
    _id: global_validation_1.ZodValidation.objectId('_id'),
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
    userOrderCompletionScope: global_validation_1.ZodValidation.enumType(enum_1.UserOrderCompletionScope).optional(),
});
exports.GetByTokenInputSchema = zod_1.z
    .object({
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
})
    .optional();
exports.GetOneQuerySchema = zod_1.z.object({
    query: MongoQuerySchema.optional(),
    select: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)])).optional(),
    populate: zod_1.z.union([populateSchema, zod_1.z.array(populateSchema)]).optional(),
});
const ShareableLinkSchema = zod_1.z.object({
    link: global_validation_1.ZodValidation.url('Link'),
    message: global_validation_1.ZodValidation.string('Message'),
});
exports.ShareableLinkResponseSchema = (0, exports.createResponseSchema)(ShareableLinkSchema);
exports.UpdateFcmTokenInputSchema = zod_1.z.object({
    fcmToken: global_validation_1.ZodValidation.string('Fcm token'),
    action: global_validation_1.ZodValidation.enumType(enum_1.ActionType, 'Action'),
});
exports.AssignRiderSchema = zod_1.z.object({
    _id: global_validation_1.ZodValidation.objectId('Rider id'),
    language: global_validation_1.ZodValidation.enumType(enum_1.Language, 'Rider language'),
});
//# sourceMappingURL=common-validation.js.map