@warlock.js/core 2.0.4 → 2.1.1

package/esm/validator/v/rules.js

@@ -1,4 +1,4 @@
-import {get}from'@mongez/reinforcements';import {isEmpty,isPlainObject,isEmail}from'@mongez/supportive-is';import {Aggregate}from'@warlock.js/cascade';import {UploadedFile}from'../../http/UploadedFile.js';import {invalidRule,VALID_RULE,setKeyPath}from'./utils.js';const requiredRule = {
+import {get}from'@mongez/reinforcements';import {isEmpty,isPlainObject,isEmail,isNumeric}from'@mongez/supportive-is';import {Aggregate}from'@warlock.js/cascade';import dayjs from'dayjs';import {isIP}from'net';import {UploadedFile}from'../../http/UploadedFile.js';import {Upload}from'../../modules/uploads/models/upload.js';import {invalidRule,VALID_RULE,setKeyPath}from'./utils.js';const requiredRule = {
     name: "required",
     defaultErrorMessage: "The :input is required",
     requiresValue: false,
@@ -36,7 +36,7 @@ const requiredIfAbsentRule = {
     errorMessage: "The :input is required",
     async validate(value, context) {
         const otherField = this.context.options.field;
-        const fieldValue = get(context.allValues, otherField);
+        const fieldValue = get(context.allValues || {}, otherField);
         const isPresent = ![undefined, null].includes(fieldValue);
         if (!isPresent && isEmpty(value)) {
             return invalidRule(this, context);
@@ -44,6 +44,28 @@ const requiredIfAbsentRule = {
         return VALID_RULE;
     },
 };
+const requiredIfSiblingFieldAllAbsentRule = {
+    name: "requiredIfSiblingFieldAllAbsent",
+    description: "The field is required if all other fields are absent",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
+    async validate(value, context) {
+        const fields = this.context.options.fields;
+        let isPresent = false;
+        for (const field of fields) {
+            const fieldValue = get(context.parent, field);
+            if (![undefined, null].includes(fieldValue)) {
+                isPresent = true;
+                break;
+            }
+        }
+        if (!isPresent && isEmpty(value)) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
 const requiredIfEmptyRule = {
     name: "requiredIfEmpty",
     description: "The field is required if another field is empty",
@@ -59,6 +81,22 @@ const requiredIfEmptyRule = {
         return VALID_RULE;
     },
 };
+// required if sibling field is empty
+const requiredIfSiblingFieldEmptyRule = {
+    name: "requiredIfSiblingFieldEmpty",
+    description: "The field is required if another field in same parent context is empty",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
+    async validate(value, context) {
+        const otherField = this.context.options.field;
+        const fieldValue = get(context.parent, otherField);
+        if (isEmpty(fieldValue) && isEmpty(value)) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
 const requiredIfFieldRule = {
     name: "requiredIfField",
     description: "The field is required if another field has a specific value",
@@ -78,21 +116,45 @@ const requiredIfFieldRule = {
         return VALID_RULE;
     },
 };
-const objectRule = {
-    name: "object",
-    defaultErrorMessage: "The :input must be an object",
+const requiredIfSiblingFieldRule = {
+    name: "requiredIfSiblingField",
+    description: "The field is required if another field in same parent context has a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
     async validate(value, context) {
-        if (isPlainObject(value)) {
-            return VALID_RULE;
+        const otherField = this.context.options.field;
+        const otherFieldValue = this.context.options.value;
+        const parentValues = context.parent;
+        const fieldValue = get(parentValues, otherField);
+        if (fieldValue === otherFieldValue && isEmpty(value)) {
+            return invalidRule(this, context);
         }
-        return invalidRule(this, context);
+        return VALID_RULE;
     },
 };
-const arrayRule = {
-    name: "array",
-    defaultErrorMessage: "The :input must be an array",
+const requiredUnlessSiblingFieldRule = {
+    name: "requiredUnlessSiblingField",
+    description: "The field is required unless another field in same parent context has a specific value",
+    sortOrder: -2,
+    requiresValue: false,
+    errorMessage: "The :input is required",
     async validate(value, context) {
-        if (Array.isArray(value)) {
+        const otherField = this.context.options.field;
+        const otherFieldValue = this.context.options.value;
+        const parentValues = context.parent;
+        const fieldValue = get(parentValues, otherField);
+        if (fieldValue !== otherFieldValue && isEmpty(value)) {
+            return invalidRule(this, context);
+        }
+        return VALID_RULE;
+    },
+};
+const objectRule = {
+    name: "object",
+    defaultErrorMessage: "The :input must be an object",
+    async validate(value, context) {
+        if (isPlainObject(value)) {
             return VALID_RULE;
         }
         return invalidRule(this, context);
@@ -158,7 +220,59 @@ const inRule = {
         return invalidRule(this, context);
     },
 };
-const enumRule = inRule;
+const enumRule = {
+    name: "enum",
+    errorMessage: "The :input must be one of the following values: :options",
+    async validate(value, context) {
+        const enumObject = this.context.options.enum;
+        const enumValues = Object.values(enumObject);
+        if (enumValues.includes(value)) {
+            return VALID_RULE;
+        }
+        this.context.options.enum = enumValues.join(", ");
+        return invalidRule(this, context);
+    },
+};
+const withoutWhitespaceRule = {
+    name: "withoutWhitespace",
+    errorMessage: "The :input must not contain whitespace",
+    async validate(value, context) {
+        if (!/\s/.test(value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const minWordsRule = {
+    name: "minWords",
+    errorMessage: `The :input must be at least :minWords words`,
+    async validate(value, context) {
+        if (value?.split(" ").length >= this.context.options.minWords) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const maxWordsRule = {
+    name: "maxWords",
+    errorMessage: `The :input must be at most :maxWords words`,
+    async validate(value, context) {
+        if (value?.split(" ").length <= this.context.options.maxWords) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const wordsRule = {
+    name: "words",
+    errorMessage: `The :input must be exactly :words words`,
+    async validate(value, context) {
+        if (value?.split(" ").length === this.context.options.words) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
 const minLengthRule = {
     name: "minLength",
     errorMessage: `The :input must be at least :minLength characters long`,
@@ -276,12 +390,44 @@ const dateRule = {
     name: "date",
     errorMessage: "The :input must be a valid date",
     async validate(value, context) {
+        const format = this.context.options.format;
+        // use dayjs for date validation
+        if (format) {
+            const date = dayjs(value, format);
+            if (date.isValid()) {
+                return VALID_RULE;
+            }
+            return invalidRule(this, context);
+        }
         if (new Date(value).toString() !== "Invalid Date") {
             return VALID_RULE;
         }
         return invalidRule(this, context);
     },
 };
+// Must be used with Date mutator
+const minDateRule = {
+    name: "minDate",
+    description: "The field must be at least the given date",
+    errorMessage: `The :input must be at least :minDate`,
+    async validate(value, context) {
+        if (value >= this.context.options.minDate) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+// Must be used with Date mutator
+const maxDateRule = {
+    name: "maxDate",
+    errorMessage: `The :input must be at most :maxDate`,
+    async validate(value, context) {
+        if (value <= this.context.options.maxDate) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
 const urlRule = {
     name: "url",
     errorMessage: "The :input must be a valid URL",
@@ -295,6 +441,109 @@ const urlRule = {
         }
     },
 };
+const ipRule = {
+    name: "ip",
+    errorMessage: "The :input must be a valid IP address",
+    async validate(value, context) {
+        const result = isIP(value);
+        if (result !== 0) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const ip4Rule = {
+    name: "ip4",
+    errorMessage: "The :input must be a valid IPv4 address",
+    async validate(value, context) {
+        const result = isIP(value);
+        if (result === 4) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const ip6Rule = {
+    name: "ip6",
+    errorMessage: "The :input must be a valid IPv6 address",
+    async validate(value, context) {
+        const result = isIP(value);
+        if (result === 6) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const isNumericRule = {
+    name: "isNumeric",
+    errorMessage: "The :input must be a numeric value",
+    async validate(value, context) {
+        if (isNumeric(value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const startsWithRule = {
+    name: "startsWith",
+    errorMessage: "The :input must start with :value",
+    async validate(value, context) {
+        if (value.startsWith(this.context.options.value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const endsWithRule = {
+    name: "endsWith",
+    errorMessage: "The :input must end with :value",
+    async validate(value, context) {
+        if (value.endsWith(this.context.options.value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const containsRule = {
+    name: "contains",
+    errorMessage: "The :input must contain :value",
+    async validate(value, context) {
+        if (value.includes(this.context.options.value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const notContainsRule = {
+    name: "notContains",
+    errorMessage: "The :input must not contain :value",
+    async validate(value, context) {
+        if (!value.includes(this.context.options.value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const alphaRule = {
+    name: "alpha",
+    errorMessage: "The :input must contain only alphabetic characters",
+    async validate(value, context) {
+        if (/^[a-zA-Z]+$/.test(value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const alphaNumericRule = {
+    name: "alphaNumeric",
+    errorMessage: "The :input must contain only alphabetic and numeric characters",
+    async validate(value, context) {
+        if (/^[a-zA-Z0-9]+$/.test(value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
 const patternRule = {
     name: "pattern",
     errorMessage: "The :input does not match the pattern",
@@ -305,6 +554,42 @@ const patternRule = {
         return invalidRule(this, context);
     },
 };
+const moduloRule = {
+    name: "modulo",
+    errorMessage: "The :input must be a multiple of :value",
+    async validate(value, context) {
+        if (value % this.context.options.value === 0) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const isCreditCardRule = {
+    name: "isCreditCard",
+    description: "The field must be a valid credit card number",
+    errorMessage: "The :input must be a valid credit card number",
+    async validate(value, context) {
+        // Luhn algorithm
+        const cardNumber = value.toString().replace(/\D/g, "");
+        let sum = 0;
+        let isEven = false;
+        for (let i = cardNumber.length - 1; i >= 0; i--) {
+            let digit = parseInt(cardNumber[i]);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9) {
+                    digit -= 9;
+                }
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        if (sum % 10 === 0) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
 const positiveRule = {
     name: "positive",
     errorMessage: "The :input must be a positive number",
@@ -361,6 +646,17 @@ const uniqueRule = {
         return invalidRule(this, context);
     },
 };
+const uploadableRule = {
+    name: "uploadable",
+    errorMessage: "The :input must be a valid uploadable hash id",
+    async validate(value, context) {
+        const hashExists = await Upload.aggregate().where("hash", value).exists();
+        if (hashExists) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
 const existsRule = {
     name: "exists",
     errorMessage: "The :input must exist",
@@ -382,7 +678,7 @@ const existsRule = {
         return invalidRule(this, context);
     },
 };
-const fileRile = {
+const fileRule = {
     name: "file",
     errorMessage: "The :input must be a file",
     async validate(value, context) {
@@ -392,6 +688,34 @@ const fileRile = {
         return invalidRule(this, context);
     },
 };
+const fileTypeRule = {
+    name: "fileType",
+    errorMessage: "The :input must be a :types file",
+    async validate(value, context) {
+        let mimeTypes = this.context.options.mimeTypes;
+        if (typeof mimeTypes === "string") {
+            mimeTypes = [mimeTypes];
+        }
+        if (mimeTypes.includes(value.mimeType)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const fileExtensionRule = {
+    name: "fileExtension",
+    errorMessage: "The :input must have one of the following extensions: :extensions",
+    async validate(value, context) {
+        let extensions = this.context.options.extensions;
+        if (typeof extensions === "string") {
+            extensions = [extensions];
+        }
+        if (extensions.includes(value.extension)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
 const maxFileSizeRule = {
     name: "maxFileSize",
     errorMessage: "The :input must not exceed :maxFileSize",
@@ -454,4 +778,175 @@ const minHeightRule = {
         }
         return invalidRule(this, context);
     },
-};export{arrayRule,booleanRule,dateRule,emailRule,enumRule,equalRule,existsRule,fileRile,floatRule,imageRule,inRule,intRule,lengthRule,matchesRule,maxFileSizeRule,maxLengthRule,maxRule,maxWidthRule,minFileSizeRule,minHeightRule,minLengthRule,minRule,minWidthRule,numberRule,objectRule,patternRule,positiveRule,requiredIfAbsentRule,requiredIfEmptyRule,requiredIfFieldRule,requiredRule,requiredWithRule,scalarRule,stringRule,uniqueArrayRule,uniqueRule,unknownKeyRule,urlRule};//# sourceMappingURL=rules.js.map
+};
+const maxHeightRule = {
+    name: "maxHeight",
+    errorMessage: "The :input must be at most :maxHeight pixels tall",
+    async validate(value, context) {
+        const dimensions = await value.dimensions();
+        if (dimensions.height <= this.context.options.maxHeight) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Check if the value is one of the allowed values
+ */
+const allowedValuesRule = {
+    name: "arrayOfValues",
+    errorMessage: "The :input must be an array containing only the allowed values: :allowedValues",
+    async validate(value, context) {
+        const allowedValues = this.context.options.allowedValues;
+        // Check if the value is an array
+        if (!Array.isArray(value)) {
+            return invalidRule(this, context);
+        }
+        // Check if all elements in the array are allowed values
+        const isValid = value.every(item => allowedValues.includes(item));
+        if (isValid) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+/**
+ * Value must not be any of the given values
+ */
+const notAllowedValuesRule = {
+    name: "notAllowedValues",
+    errorMessage: "The :input must not be any of the following values: :notAllowedValues",
+    async validate(value, context) {
+        const notAllowedValues = this.context.options.notAllowedValues;
+        if (!notAllowedValues.includes(value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+// Array rules
+const arrayRule = {
+    name: "array",
+    defaultErrorMessage: "The :input must be an array",
+    async validate(value, context) {
+        if (Array.isArray(value)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+// End of Array rules
+// Color rules
+const colorValidationRegex = {
+    hex: /^#([0-9a-f]{3}){1,2}$/i,
+    rgb: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+    rgba: /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*(0?\.\d+)\)$/,
+    hsl: /^hsl\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+    light: /^#([0-9a-f]{3}){1,2}$/i,
+    dark: /^#([0-9a-f]{3}){1,2}$/i,
+};
+const rgbColorRule = {
+    name: "rgbColor",
+    errorMessage: "The :input must be a valid RGB color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.rgb)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const rgbaColorRule = {
+    name: "rgbaColor",
+    errorMessage: "The :input must be a valid RGBA color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.rgba)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const hexColorRule = {
+    name: "hexColor",
+    errorMessage: "The :input must be a valid hex color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.hex)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const hslColorRule = {
+    name: "hslColor",
+    errorMessage: "The :input must be a valid HSL color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.hsl)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const lightColorRule = {
+    name: "lightColor",
+    errorMessage: "The :input must be a light color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.light)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const darkColorRule = {
+    name: "darkColor",
+    errorMessage: "The :input must be a dark color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.dark)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const colorRule = {
+    name: "color",
+    errorMessage: "The :input must be a valid color",
+    async validate(value, context) {
+        if (value.match(colorValidationRegex.hex) ||
+            value.match(colorValidationRegex.rgb) ||
+            value.match(colorValidationRegex.rgba) ||
+            value.match(colorValidationRegex.hsl)) {
+            return VALID_RULE;
+        }
+        return invalidRule(this, context);
+    },
+};
+const forbiddenRule = {
+    name: "forbidden",
+    errorMessage: "The :input is forbidden",
+    async validate(_value, context) {
+        return invalidRule(this, context);
+    },
+};
+/**
+ * When rule applies a condition validation rule based on another field value
+ */
+const whenRule = {
+    name: "when",
+    description: "Apply conditional validation rules based on another field value",
+    async validate(value, context) {
+        const { field, is, otherwise, local } = this.context.options;
+        const parent = local ? context.parent : context.allValues;
+        const fieldValue = get(parent, field);
+        const condition = is[fieldValue] || otherwise;
+        if (condition) {
+            const result = await condition.validate(value, context);
+            if (!result.isValid) {
+                return {
+                    isValid: false,
+                    error: result.errors[0].error,
+                    input: result.errors[0].input,
+                    path: context.path,
+                };
+            }
+        }
+        return VALID_RULE;
+    },
+};export{allowedValuesRule,alphaNumericRule,alphaRule,arrayRule,booleanRule,colorRule,containsRule,darkColorRule,dateRule,emailRule,endsWithRule,enumRule,equalRule,existsRule,fileExtensionRule,fileRule,fileTypeRule,floatRule,forbiddenRule,hexColorRule,hslColorRule,imageRule,inRule,intRule,ip4Rule,ip6Rule,ipRule,isCreditCardRule,isNumericRule,lengthRule,lightColorRule,matchesRule,maxDateRule,maxFileSizeRule,maxHeightRule,maxLengthRule,maxRule,maxWidthRule,maxWordsRule,minDateRule,minFileSizeRule,minHeightRule,minLengthRule,minRule,minWidthRule,minWordsRule,moduloRule,notAllowedValuesRule,notContainsRule,numberRule,objectRule,patternRule,positiveRule,requiredIfAbsentRule,requiredIfEmptyRule,requiredIfFieldRule,requiredIfSiblingFieldAllAbsentRule,requiredIfSiblingFieldEmptyRule,requiredIfSiblingFieldRule,requiredRule,requiredUnlessSiblingFieldRule,requiredWithRule,rgbColorRule,rgbaColorRule,scalarRule,startsWithRule,stringRule,uniqueArrayRule,uniqueRule,unknownKeyRule,uploadableRule,urlRule,whenRule,withoutWhitespaceRule,wordsRule};//# sourceMappingURL=rules.js.map