@warlock.js/core 3.0.12 → 3.0.13

package/esm/validator/v/schema.js

@@ -1,1212 +0,0 @@
-import {trans}from'@mongez/localization';import {clone}from'@mongez/reinforcements';import {isPlainObject,isObject}from'@mongez/supportive-is';import {stripUnknownMutator,objectTrimMutator,flipArrayMutator,uniqueArrayMutator,sortArrayMutator,stringMutator,lowercaseMutator,uppercaseMutator,capitalizeMutator,dateMutator,numberMutator}from'./mutators.js';import {equalRule,requiredRule,requiredWithRule,requiredIfAbsentRule,requiredIfSiblingFieldIsAbsentRule,requiredIfSiblingFieldAllAbsentRule,requiredIfEmptyRule,requiredIfSiblingFieldEmptyRule,requiredIfFieldRule,requiredIfSiblingFieldRule,requiredUnlessSiblingFieldRule,forbiddenRule,whenRule,objectRule,unknownKeyRule,arrayRule,minLengthRule,maxLengthRule,lengthRule,uniqueArrayRule,stringRule,emailRule,urlRule,matchesRule,withoutWhitespaceRule,patternRule,uploadableRule,wordsRule,minWordsRule,maxWordsRule,alphaRule,alphaNumericRule,isNumericRule,startsWithRule,endsWithRule,containsRule,notContainsRule,ipRule,ip4Rule,ip6Rule,isCreditCardRule,colorRule,hexColorRule,hslColorRule,rgbColorRule,rgbaColorRule,lightColorRule,darkColorRule,dateRule,maxDateRule,minDateRule,intRule,floatRule,booleanRule,scalarRule,enumRule,inRule,allowedValuesRule,notAllowedValuesRule,fileRule,imageRule,fileExtensionRule,fileTypeRule,minFileSizeRule,maxFileSizeRule,minWidthRule,maxWidthRule,minHeightRule,maxHeightRule,numberRule,minRule,maxRule,moduloRule,positiveRule}from'./rules.js';import {invalidRule,VALID_RULE,setKeyPath}from'./utils.js';import {uniqueRule,uniqueExceptCurrentUserRule,uniqueExceptCurrentIdRule,existsRule,existsExceptCurrentUserRule,existsExceptCurrentIdRule}from'./database.js';/* eslint-disable @typescript-eslint/no-this-alias */
-// TODO: Allow developer to extend the validator with custom rules and custom validators
-class BaseValidator {
-    rules = [];
-    mutators = [];
-    defaultValue;
-    description;
-    /**
-     * Get the default value
-     */
-    getDefaultValue() {
-        return this.defaultValue;
-    }
-    /**
-     * Add description to the validator
-     */
-    describe(description) {
-        this.description = description;
-        return this;
-    }
-    /**
-     * Value must be equal to the given value
-     */
-    equal(value, errorMessage) {
-        const rule = this.addRule(equalRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Add rule to the schema
-     */
-    addRule(rule, errorMessage) {
-        const newRule = {
-            ...clone(rule),
-            context: {
-                errorMessage,
-                options: {},
-            },
-        };
-        if (errorMessage) {
-            newRule.errorMessage = errorMessage;
-        }
-        if (rule.sortOrder === undefined) {
-            newRule.sortOrder = this.rules.length + 1;
-        }
-        this.rules.push(newRule);
-        return newRule;
-    }
-    /**
-     * Define custom rule
-     */
-    refine(callback) {
-        this.addRule({
-            name: "custom",
-            async validate(value, context) {
-                const result = await callback(value, context);
-                if (result) {
-                    this.context.errorMessage = result;
-                    return invalidRule(this, context);
-                }
-                return VALID_RULE;
-            },
-        });
-        return this;
-    }
-    /**
-     * Add custom rule to the schema
-     * @alias refine
-     */
-    custom(callback) {
-        return this.refine(callback);
-    }
-    /**
-     * Add mutator to the schema
-     *
-     * A mutator is a function that mutates the value of the field before validation
-     */
-    addMutator(mutator, options = {}) {
-        this.mutators.push({
-            mutate: mutator,
-            context: {
-                options,
-                ctx: {},
-            },
-        });
-        return this;
-    }
-    /**
-     * Set default value for the field
-     */
-    default(value) {
-        this.defaultValue = value;
-        return this;
-    }
-    /**
-     * Value must be present but not necessarily has a value
-     */
-    present(errorMessage) {
-        this.addRule(requiredRule, errorMessage);
-        return this;
-    }
-    /**
-     * This value must be present and has a value
-     */
-    required(errorMessage) {
-        this.addRule(requiredRule, errorMessage);
-        return this;
-    }
-    /**
-     * This value must be present if the given input is present
-     */
-    requiredWith(input, errorMessage) {
-        const rule = this.addRule(requiredWithRule, errorMessage);
-        rule.context.options.field = input;
-        return this;
-    }
-    /**
-     * Mark this field as required if the given input field is present
-     */
-    requiredIfPresent(input, errorMessage) {
-        return this.requiredWith(input, errorMessage);
-    }
-    /**
-     * Value is required if the given input field (global) is absent
-     */
-    requiredIfAbsent(input, errorMessage) {
-        const rule = this.addRule(requiredIfAbsentRule, errorMessage);
-        rule.context.options.field = input;
-        return this;
-    }
-    /**
-     * Value is required if given sibling field is absent
-     */
-    requireIfSiblingIsAbsent(field, errorMessage) {
-        const rule = this.addRule(requiredIfSiblingFieldIsAbsentRule, errorMessage);
-        rule.context.options.field = field;
-        return this;
-    }
-    /**
-     * Value is required if all given input fields in same parent context are absent
-     */
-    requiredIfSiblingFieldAllAbsent(fields, errorMessage) {
-        const rule = this.addRule(requiredIfSiblingFieldAllAbsentRule, errorMessage);
-        rule.context.options.fields = fields;
-        return this;
-    }
-    /**
-     * @alias requiredIfAbsent
-     */
-    requiredIfMissing(input, errorMessage) {
-        return this.requiredIfAbsent(input, errorMessage);
-    }
-    /**
-     * Value is required if and only if the given input field is empty
-     */
-    requiredIfEmpty(input, errorMessage) {
-        const rule = this.addRule(requiredIfEmptyRule, errorMessage);
-        rule.context.options.field = input;
-        return this;
-    }
-    /**
-     * Value is required if and only if the given input field in same parent context is empty
-     */
-    requiredIfSiblingFieldEmpty(input, errorMessage) {
-        const rule = this.addRule(requiredIfSiblingFieldEmptyRule, errorMessage);
-        rule.context.options.field = input;
-        return this;
-    }
-    /**
-     * Value is required if and only if the given input field has the given value
-     */
-    requiredIfField(input, value, errorMessage) {
-        const rule = this.addRule(requiredIfFieldRule, errorMessage);
-        rule.context.options.field = input;
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value is required if and only if the given input field in same parent context has the given value
-     */
-    requiredIfSiblingField(input, value, errorMessage) {
-        const rule = this.addRule(requiredIfSiblingFieldRule, errorMessage);
-        rule.context.options.field = input;
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value is required unless the given input field in same parent context has the given value
-     */
-    requiredUnlessSiblingField(input, value, errorMessage) {
-        const rule = this.addRule(requiredUnlessSiblingFieldRule, errorMessage);
-        rule.context.options.field = input;
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Mutate the data
-     * Please note this method should not be called directly, as it is used internally by the `validate` method
-     */
-    async mutate(data, context) {
-        let mutatedData = data;
-        for (const mutator of this.mutators) {
-            mutator.context.ctx = context;
-            mutatedData = await mutator.mutate(mutatedData, mutator.context);
-        }
-        return mutatedData;
-    }
-    /**
-     * Value is forbidden to be present
-     */
-    forbidden(errorMessage) {
-        this.addRule(forbiddenRule, errorMessage);
-        return this;
-    }
-    /**
-     * Apply conditional validation rules based on another field value
-     *
-     * @example
-     * ```ts
-     * v.object({
-     *   status: v.when("type", {
-     *     is: {
-     *       post: v.string().required().in(["active", "inactive"]),
-     *       news: v.string().required().in(["published", "draft"]),
-     *     },
-     *     otherwise: v.forbidden(),
-     *   }),
-     * })
-     * ```
-     */
-    when(field, options) {
-        const rule = this.addRule(whenRule);
-        rule.context.options.field = field;
-        rule.context.options.is = options.is;
-        rule.context.options.otherwise = options.otherwise;
-        return this;
-    }
-    /**
-     * Validate the data
-     */
-    async validate(data, context) {
-        const mutatedData = await this.mutate(data ?? this.defaultValue, context);
-        const errors = [];
-        let isValid = true;
-        const isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;
-        for (const rule of this.rules) {
-            if ((rule.requiresValue ?? true) && data === undefined)
-                continue;
-            const result = await rule.validate(mutatedData, context);
-            if (result.isValid === false) {
-                isValid = false;
-                errors.push({
-                    type: rule.name,
-                    error: result.error,
-                    input: result.path ?? context.path,
-                });
-                if (isFirstErrorOnly) {
-                    break;
-                }
-            }
-        }
-        return {
-            isValid,
-            errors,
-            data: mutatedData,
-        };
-    }
-}
-class AnyValidator extends BaseValidator {
-}
-/**
- * Recursively remove undefined values from an object
- */
-function removeUndefinedValues(obj) {
-    if (isObject(obj) && !isPlainObject(obj)) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(item => removeUndefinedValues(item));
-    }
-    if (obj !== null && typeof obj === "object") {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            if (value !== undefined) {
-                result[key] = removeUndefinedValues(value);
-            }
-        }
-        return result;
-    }
-    return obj;
-}
-class ObjectValidator extends BaseValidator {
-    schema;
-    /**
-     * Whether to allow unknown properties
-     *
-     * @default false
-     */
-    shouldAllowUnknown = false;
-    /**
-     * Allowed keys that could be in the data but not necessarily validated
-     */
-    allowedKeys = [];
-    constructor(schema, errorMessage) {
-        super();
-        this.schema = schema;
-        this.addRule(objectRule, errorMessage);
-    }
-    /**
-     * Strip unknown keys from the data
-     *
-     * @mutate
-     */
-    stripUnknown() {
-        const validator = this;
-        this.addMutator(stripUnknownMutator, {
-            get allowedKeys() {
-                return validator.allowedKeys;
-            },
-        });
-        return this;
-    }
-    /**
-     * Add list of allowed keys that could be in the data but not necessarily validated
-     */
-    allow(...keys) {
-        this.allowedKeys.push(...keys);
-        return this;
-    }
-    /**
-     * Trim values of the object properties
-     */
-    trim(recursive = true) {
-        this.addMutator(objectTrimMutator, { recursive });
-        return this;
-    }
-    /**
-     * Whether to allow unknown properties
-     *
-     * @default false
-     */
-    allowUnknown(allow = true) {
-        this.shouldAllowUnknown = allow;
-        return this;
-    }
-    /**
-     * Mutate the data
-     *
-     * Please note this method should not be called directly, as it is used internally by the `validate` method
-     */
-    mutate(data, context) {
-        if (!isPlainObject(data))
-            return data;
-        return super.mutate({ ...data }, context);
-    }
-    /**
-     * Validate the data
-     */
-    async validate(data, context) {
-        context.schema = this.schema;
-        const mutatedData = await this.mutate(data, context);
-        // now we need to check if the object has unknown properties
-        if (this.shouldAllowUnknown === false) {
-            const rule = this.addRule(unknownKeyRule);
-            rule.context.options.allowedKeys = this.allowedKeys;
-            rule.context.options.schema = this.schema;
-        }
-        const result = await super.validate(mutatedData, context);
-        if (result.isValid === false)
-            return result;
-        // if no data and the object is valid, then return it as-is, nothing to do
-        if (data === undefined)
-            return result;
-        // now we need to validate the object properties
-        const errors = [];
-        const finalData = {};
-        const validationPromises = Object.keys(this.schema).map(async (key) => {
-            const value = mutatedData?.[key];
-            const validator = this.schema[key];
-            // Only process fields that were provided in the input or have explicit defaults
-            if (key in data || validator.getDefaultValue() !== undefined) {
-                const childContext = {
-                    ...context,
-                    parent: mutatedData,
-                    value,
-                    key,
-                    path: setKeyPath(context.path, key),
-                };
-                const childResult = await validator.validate(value, childContext);
-                if (childResult.data !== undefined) {
-                    finalData[key] = childResult.data;
-                }
-                if (childResult.isValid === false) {
-                    errors.push(...childResult.errors);
-                }
-            }
-        });
-        await Promise.all(validationPromises);
-        // Remove undefined values from the final data
-        const cleanedData = removeUndefinedValues(finalData);
-        return {
-            isValid: errors.length === 0,
-            errors,
-            data: cleanedData,
-        };
-    }
-}
-class ArrayValidator extends BaseValidator {
-    validator;
-    constructor(validator, errorMessage) {
-        super();
-        this.validator = validator;
-        this.addRule(arrayRule, errorMessage);
-    }
-    /**
-     * Reverse array order
-     *
-     * @mutate
-     */
-    flip() {
-        return this.addMutator(flipArrayMutator);
-    }
-    /**
-     * Reverse array order
-     *
-     * @mutate
-     */
-    reverse() {
-        return this.addMutator(flipArrayMutator);
-    }
-    /**
-     * Make it has only unique values
-     *
-     * @mutate
-     */
-    onlyUnique() {
-        return this.addMutator(uniqueArrayMutator);
-    }
-    /**
-     * Sort array
-     *
-     * If key is passed, it will sort by the key value
-     *
-     * @mutate
-     * @supports dot notation
-     */
-    sort(direction = "asc", key) {
-        this.addMutator(sortArrayMutator, { direction, key });
-        return this;
-    }
-    // End of mutators
-    //   Start of rules
-    /**
-     * Array length must be greater than the given length
-     */
-    minLength(length, errorMessage) {
-        const rule = this.addRule(minLengthRule, errorMessage);
-        rule.context.options.minLength = length;
-        return this;
-    }
-    /**
-     * Array length must be less than the given length
-     */
-    maxLength(length, errorMessage) {
-        const rule = this.addRule(maxLengthRule, errorMessage);
-        rule.context.options.maxLength = length;
-        return this;
-    }
-    /**
-     * Array length must be of the given length
-     */
-    length(length, errorMessage) {
-        const rule = this.addRule(lengthRule, errorMessage);
-        rule.context.options.length = length;
-        return this;
-    }
-    /**
-     * Array must have unique values
-     */
-    unique() {
-        this.addRule(uniqueArrayRule);
-        return this;
-    }
-    /**
-     * Mutate the data
-     *
-     * Please note this method should not be called directly, as it is used internally by the `validate` method
-     */
-    mutate(data, context) {
-        if (!Array.isArray(data))
-            return data;
-        return super.mutate([...data], context);
-    }
-    /**
-     * Validate array
-     */
-    async validate(data, context) {
-        const mutatedData = (await this.mutate(data, context)) || [];
-        const result = await super.validate(data, context);
-        if (result.isValid === false)
-            return result;
-        const errors = [];
-        for (let index = 0; index < mutatedData.length; index++) {
-            const value = mutatedData[index];
-            const childContext = {
-                ...context,
-                parent: mutatedData,
-                value,
-                key: index.toString(),
-                path: setKeyPath(context.path, index.toString()),
-            };
-            const childResult = await this.validator.validate(value, childContext);
-            mutatedData[index] = childResult.data;
-            if (childResult.isValid === false) {
-                errors.push(...childResult.errors);
-            }
-            if (context.configurations?.firstErrorOnly && errors.length) {
-                break;
-            }
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-            data: mutatedData,
-        };
-    }
-}
-class StringValidator extends BaseValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(stringRule, errorMessage);
-        this.addMutator(stringMutator);
-    }
-    /**
-     * Convert string to lowercase
-     *
-     * @mutate
-     */
-    lowercase() {
-        this.addMutator(lowercaseMutator);
-        return this;
-    }
-    /**
-     * Convert string to uppercase
-     *
-     * @mutate
-     */
-    uppercase() {
-        this.addMutator(uppercaseMutator);
-        return this;
-    }
-    /**
-     * Capitalize the first letter of the string
-     *
-     * @mutate
-     */
-    capitalize() {
-        this.addMutator(capitalizeMutator);
-        return this;
-    }
-    /**
-     * Value must be a valid email
-     */
-    email(errorMessage) {
-        this.addRule(emailRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be a valid URL
-     */
-    url(errorMessage) {
-        this.addRule(urlRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must match the value of the given field
-     */
-    matches(field, errorMessage) {
-        const rule = this.addRule(matchesRule, errorMessage);
-        rule.context.options.field = field;
-        return this;
-    }
-    /**
-     * Value can not have whitespace
-     */
-    withoutWhitespace(errorMessage) {
-        this.addRule(withoutWhitespaceRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must match the given pattern
-     */
-    pattern(pattern, errorMessage) {
-        const rule = this.addRule(patternRule, errorMessage);
-        rule.context.options.pattern = pattern;
-        return this;
-    }
-    /**
-     * Validate the current string as an uploadable hash id
-     */
-    uploadable(errorMessage) {
-        this.addRule(uploadableRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be exactly the given number of words
-     */
-    words(words, errorMessage) {
-        const rule = this.addRule(wordsRule, errorMessage);
-        rule.context.options.words = words;
-        return this;
-    }
-    /**
-     * Value must be at least the given number of words
-     */
-    minWords(words, errorMessage) {
-        const rule = this.addRule(minWordsRule, errorMessage);
-        rule.context.options.minWords = words;
-        return this;
-    }
-    /**
-     * Value must be at most the given number of words
-     */
-    maxWords(words, errorMessage) {
-        const rule = this.addRule(maxWordsRule, errorMessage);
-        rule.context.options.maxWords = words;
-        return this;
-    }
-    /**
-     * Value length must be greater than the given length
-     */
-    minLength(length, errorMessage) {
-        const rule = this.addRule(minLengthRule, errorMessage);
-        rule.context.options.minLength = length;
-        return this;
-    }
-    /**
-     * @alias minLength
-     */
-    min(min, errorMessage) {
-        return this.minLength(min, errorMessage);
-    }
-    /**
-     * Value length must be less than the given length
-     */
-    maxLength(length, errorMessage) {
-        const rule = this.addRule(maxLengthRule, errorMessage);
-        rule.context.options.maxLength = length;
-        return this;
-    }
-    /**
-     * @alias maxLength
-     */
-    max(max, errorMessage) {
-        return this.maxLength(max, errorMessage);
-    }
-    /**
-     * Value must be of the given length
-     */
-    length(length, errorMessage) {
-        const rule = this.addRule(lengthRule, errorMessage);
-        rule.context.options.length = length;
-        return this;
-    }
-    /**
-     * Allow only alphabetic characters
-     */
-    alpha(errorMessage) {
-        this.addRule(alphaRule, errorMessage);
-        return this;
-    }
-    /**
-     * Allow only alphanumeric characters
-     */
-    alphanumeric(errorMessage) {
-        this.addRule(alphaNumericRule, errorMessage);
-        return this;
-    }
-    /**
-     * Allow only numeric characters
-     */
-    numeric(errorMessage) {
-        this.addRule(isNumericRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must starts with the given string
-     */
-    startsWith(value, errorMessage) {
-        const rule = this.addRule(startsWithRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value must ends with the given string
-     */
-    endsWith(value, errorMessage) {
-        const rule = this.addRule(endsWithRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value must contain the given string
-     */
-    contains(value, errorMessage) {
-        const rule = this.addRule(containsRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value must not contain the given string
-     */
-    notContains(value, errorMessage) {
-        const rule = this.addRule(notContainsRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Value must be a valid IP address
-     */
-    ip(errorMessage) {
-        this.addRule(ipRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be a valid IPv4 address
-     */
-    ip4(errorMessage) {
-        this.addRule(ip4Rule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be a valid IPv6 address
-     */
-    ip6(errorMessage) {
-        this.addRule(ip6Rule, errorMessage);
-        return this;
-    }
-    /**
-     * Check if the string matches a credit card number
-     */
-    creditCard(errorMessage) {
-        this.addRule(isCreditCardRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid color
-     * This validation rule will check for hex, rgb, rgba, hsl colors
-     */
-    color(errorMessage) {
-        this.addRule(colorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid hex color
-     */
-    hexColor(errorMessage) {
-        this.addRule(hexColorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid HSL color
-     */
-    hslColor(errorMessage) {
-        this.addRule(hslColorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid RGB color
-     */
-    rgbColor(errorMessage) {
-        this.addRule(rgbColorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid RGBA color
-     */
-    rgbaColor(errorMessage) {
-        this.addRule(rgbaColorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid light color
-     */
-    lightColor(errorMessage) {
-        this.addRule(lightColorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Determine if the value is a valid dark color
-     */
-    darkColor(errorMessage) {
-        this.addRule(darkColorRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be one of the given values
-     */
-    enum = ScalarValidator.prototype.enum;
-    /**
-     * Value must be one of the given values
-     */
-    in = ScalarValidator.prototype.in;
-    /**
-     * @alias in
-     */
-    oneOf = ScalarValidator.prototype.in;
-    /**
-     * Value must be unique
-     */
-    unique = ScalarValidator.prototype.unique;
-    /**
-     * Value must be unique except current user
-     */
-    uniqueExceptCurrentUser = ScalarValidator.prototype.uniqueExceptCurrentUser;
-    /**
-     * Value must be unique except current id
-     */
-    uniqueExceptCurrentId = ScalarValidator.prototype.uniqueExceptCurrentId;
-    /**
-     * Value must exist
-     */
-    exists = ScalarValidator.prototype.exists;
-    /**
-     * Value must exist except current user
-     */
-    existsExceptCurrentUser = ScalarValidator.prototype.existsExceptCurrentUser;
-    /**
-     * Value must exist except current id
-     */
-    existsExceptCurrentId = ScalarValidator.prototype.existsExceptCurrentId;
-    /**
-     * Add rule to check if the value is one of the allowed values
-     */
-    allowsOnly = ScalarValidator.prototype.allowsOnly;
-    /**
-     * Add rule to forbid the value from being one of the given values
-     */
-    forbids = ScalarValidator.prototype.forbids;
-    /**
-     * @alias forbids
-     */
-    notIn = ScalarValidator.prototype.forbids;
-}
-class DateValidator extends BaseValidator {
-    constructor(format, errorMessage) {
-        super();
-        const rule = this.addRule(dateRule, errorMessage);
-        if (format) {
-            rule.context.options.format = format;
-        }
-        this.addMutator(dateMutator);
-    }
-    /**
-     * Date must be before the given date
-     */
-    before(date, errorMessage) {
-        const rule = this.addRule(maxDateRule, errorMessage);
-        rule.context.options.maxDate = date;
-        return this;
-    }
-    /**
-     * Date must be after the given date
-     */
-    after(date, errorMessage) {
-        const rule = this.addRule(minDateRule, errorMessage);
-        rule.context.options.minDate = date;
-        return this;
-    }
-}
-class NumberValidator extends BaseValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(numberRule, errorMessage);
-        this.addMutator(numberMutator);
-    }
-    /**
-     * Value must be equal or higher than the given number
-     */
-    min(min, errorMessage) {
-        const rule = this.addRule(minRule, errorMessage);
-        rule.context.options.min = min;
-        return this;
-    }
-    /**
-     * Value must be equal or less than the given number
-     */
-    max(max, errorMessage) {
-        const rule = this.addRule(maxRule, errorMessage);
-        rule.context.options.max = max;
-        return this;
-    }
-    /**
-     * Value must be a modulo of the given number
-     */
-    modulo(value, errorMessage) {
-        const rule = this.addRule(moduloRule, errorMessage);
-        rule.context.options.value = value;
-        return this;
-    }
-    /**
-     * Accept only numbers higher than 0
-     */
-    positive(errorMessage) {
-        this.addRule(positiveRule, errorMessage);
-        return this;
-    }
-    /**
-     * Value must be unique and not exist in database
-     */
-    unique = ScalarValidator.prototype.unique;
-    /**
-     * Value must exist in database
-     */
-    exists = ScalarValidator.prototype.exists;
-    /**
-     * Value must be one of the given values
-     */
-    enum = ScalarValidator.prototype.enum;
-    /**
-     * Value must be one of the given values
-     */
-    in = ScalarValidator.prototype.in;
-    /**
-     * @alias in
-     */
-    oneOf = ScalarValidator.prototype.in;
-    /**
-     * Add rule to check if the value is one of the allowed values
-     */
-    allowsOnly = ScalarValidator.prototype.allowsOnly;
-    /**
-     * Add rule to forbid the value from being one of the given values
-     */
-    forbids = ScalarValidator.prototype.forbids;
-    /**
-     * @alias forbids
-     */
-    notIn = ScalarValidator.prototype.forbids;
-    /**
-     * Validate number length
-     */
-    length = StringValidator.prototype.length;
-    /**
-     * Validate number min length
-     */
-    minLength = StringValidator.prototype.minLength;
-    /**
-     * Validate number max length
-     */
-    maxLength = StringValidator.prototype.maxLength;
-}
-class IntValidator extends NumberValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(intRule, errorMessage);
-    }
-}
-class FloatValidator extends NumberValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(floatRule, errorMessage);
-    }
-}
-class BooleanValidator extends BaseValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(booleanRule, errorMessage);
-    }
-}
-class ScalarValidator extends BaseValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(scalarRule, errorMessage);
-    }
-    /**
-     * Value must be unique in database
-     */
-    unique(model, optionsList) {
-        const { errorMessage, ...options } = optionsList || {};
-        const rule = this.addRule(uniqueRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    /**
-     * Value must be unique in database except current user
-     */
-    uniqueExceptCurrentUser(model, optionsList) {
-        const { errorMessage, ...options } = optionsList || {};
-        const rule = this.addRule(uniqueExceptCurrentUserRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    /**
-     * Value must be unique in database except current id
-     */
-    uniqueExceptCurrentId(model, optionsList) {
-        const { errorMessage, ...options } = optionsList || {};
-        const rule = this.addRule(uniqueExceptCurrentIdRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    /**
-     * Value must exist in database
-     */
-    exists(model, optionsList) {
-        const { errorMessage, ...options } = optionsList || {};
-        const rule = this.addRule(existsRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    /**
-     * Value must exist in database except current user
-     */
-    existsExceptCurrentUser(model, optionsList) {
-        const { errorMessage, ...options } = optionsList || {};
-        const rule = this.addRule(existsExceptCurrentUserRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    /**
-     * Value must exists in database except current id
-     */
-    existsExceptCurrentId(model, optionsList) {
-        const { errorMessage, ...options } = optionsList || {};
-        const rule = this.addRule(existsExceptCurrentIdRule, errorMessage);
-        rule.context.options = {
-            ...options,
-            Model: model,
-        };
-        return this;
-    }
-    /**
-     * Value must be one of the given values
-     */
-    enum(values, errorMessage) {
-        const rule = this.addRule(enumRule, errorMessage);
-        rule.context.options.enum = values;
-        return this;
-    }
-    /**
-     * Value must be one of the given values
-     */
-    in(values, errorMessage) {
-        const rule = this.addRule(inRule, errorMessage);
-        rule.context.options.values = values;
-        return this;
-    }
-    /**
-     * @alias in
-     */
-    oneOf = ScalarValidator.prototype.in;
-    /**
-     * Add rule to check if the value is one of the allowed values
-     */
-    allowsOnly(values, errorMessage) {
-        const rule = this.addRule(allowedValuesRule, errorMessage);
-        rule.context.options.allowedValues = values;
-        return this;
-    }
-    /**
-     * Forbid the value from being one of the given values
-     */
-    forbids(values, errorMessage) {
-        const rule = this.addRule(notAllowedValuesRule, errorMessage);
-        rule.context.options.notAllowedValues = values;
-        return this;
-    }
-}
-class FileValidator extends BaseValidator {
-    constructor(errorMessage) {
-        super();
-        this.addRule(fileRule, errorMessage);
-    }
-    image(errorMessage) {
-        this.addRule(imageRule, errorMessage);
-        return this;
-    }
-    accept(extensions, errorMessage) {
-        const rule = this.addRule(fileExtensionRule, errorMessage);
-        rule.context.options.extensions = extensions;
-        return this;
-    }
-    mimeType(mimeTypes, errorMessage) {
-        const rule = this.addRule(fileTypeRule, errorMessage);
-        rule.context.options.mimeTypes = mimeTypes;
-        return this;
-    }
-    /**
-     * Allow only pdf files
-     */
-    pdf(errorMessage) {
-        return this.mimeType("application/pdf", errorMessage);
-    }
-    /**
-     * Allow only excel files
-     */
-    excel(errorMessage) {
-        return this.mimeType([
-            "application/vnd.ms-excel",
-            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        ], errorMessage);
-    }
-    /**
-     * Allow only word files
-     */
-    word(errorMessage) {
-        return this.mimeType([
-            "application/msword",
-            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        ], errorMessage);
-    }
-    minSize(size, errorMessage) {
-        const rule = this.addRule(minFileSizeRule, errorMessage);
-        rule.context.options.minFileSize = size;
-        return this;
-    }
-    min(size, errorMessage) {
-        return this.minSize(size, errorMessage);
-    }
-    maxSize(size, errorMessage) {
-        const rule = this.addRule(maxFileSizeRule, errorMessage);
-        rule.context.options.maxFileSize = size;
-        return this;
-    }
-    max(size, errorMessage) {
-        return this.maxSize(size, errorMessage);
-    }
-    minWidth(width, errorMessage) {
-        const rule = this.addRule(minWidthRule, errorMessage);
-        rule.context.options.minWidth = width;
-        return this;
-    }
-    maxWidth(width, errorMessage) {
-        const rule = this.addRule(maxWidthRule, errorMessage);
-        rule.context.options.maxWidth = width;
-        return this;
-    }
-    minHeight(height, errorMessage) {
-        const rule = this.addRule(minHeightRule, errorMessage);
-        rule.context.options.minHeight = height;
-        return this;
-    }
-    maxHeight(height, errorMessage) {
-        const rule = this.addRule(maxHeightRule, errorMessage);
-        rule.context.options.maxHeight = height;
-        return this;
-    }
-}
-const validate = async (schema, data) => {
-    const context = {
-        allValues: data,
-        parent: null,
-        value: data,
-        key: "",
-        path: "",
-        translator(rule, attributes) {
-            return trans(`validation.${rule}`, attributes);
-        },
-    };
-    return await schema.validate(data, context);
-};
-const v = {
-    object: (schema, errorMessage) => new ObjectValidator(schema, errorMessage),
-    any: () => new AnyValidator(),
-    forbidden: () => v.any().forbidden(),
-    array: (validator, errorMessage) => new ArrayValidator(validator, errorMessage),
-    date: (format, errorMessage) => new DateValidator(format, errorMessage),
-    string: (errorMessage) => new StringValidator(errorMessage),
-    enum: (values, errorMessage) => new StringValidator().enum(values, errorMessage),
-    number: (errorMessage) => new NumberValidator(errorMessage),
-    int: (errorMessage) => new IntValidator(errorMessage),
-    float: (errorMessage) => new FloatValidator(errorMessage),
-    boolean: (errorMessage) => new BooleanValidator(errorMessage),
-    scalar: (errorMessage) => new ScalarValidator(errorMessage),
-    file: (errorMessage) => new FileValidator(errorMessage),
-    localized: (valueValidator, errorMessage) => v.array(v.object({
-        localeCode: v.string().required(),
-        value: (valueValidator || v.string()).required(),
-    }), errorMessage),
-    /**
-     * TODO: Added validateCallback to declare a schema and the second argument is a callback that will be only executed if schema validation passes
-     * This will return a new callback that will be executed with the validated data
-     *
-     * @example
-     * ```ts
-     * export const createNewUser = v.validateCallback(schema, (data) => {
-     *  // Do something with the validated data
-     * })
-     * ```
-     */
-    // validateCallback: (
-    //   schema: BaseValidator,
-    //   callback: (data: InferType<BaseValidator>) => Promise<any> | any,
-    // ) => v.validate(schema, callback),
-    validate,
-};export{AnyValidator,ArrayValidator,BaseValidator,BooleanValidator,DateValidator,FileValidator,FloatValidator,IntValidator,ObjectValidator,ScalarValidator,StringValidator,v,validate};//# sourceMappingURL=schema.js.map