quantique-field-validator 1.0.0

package/index.js

@@ -0,0 +1,300 @@
+/**
+ * Enhanced dynamic validator with custom function support
+ * @param {string} value - The value to validate
+ * @param {string} type - Type of validation ('name', 'email', 'mobile', 'address', etc.)
+ * @param {object} rules - Custom rules for validation
+ * @param {function} [customValidator] - Optional custom validation function
+ * @returns {object} - Returns { isValid: boolean, error: string }
+ */
+const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
+  // Default error messages
+  const defaultErrorMessages = {
+    required: "This field is required",
+    minLength: `Minimum length should be ${rules.minLength}`,
+    maxLength: `Maximum length should be ${rules.maxLength}`,
+    invalid: `Invalid ${type}`,
+    custom: "Validation failed",
+    customValidation:
+      rules.errorMessages?.customValidation || "Custom validation failed",
+  };
+
+  // Trim the value if it's a string
+  const trimmedValue = typeof value === "string" ? value.trim() : value;
+
+  // Check if field is required and empty
+  if (rules.required && (!trimmedValue || trimmedValue === "")) {
+    return {
+      isValid: false,
+      error: rules.errorMessages?.required || defaultErrorMessages.required,
+    };
+  }
+
+  // Skip further validation if the field is empty and not required
+  if (!rules.required && (!trimmedValue || trimmedValue === "")) {
+    return { isValid: true, error: "" };
+  }
+
+  // First run custom validator if provided (highest priority)
+  if (customValidator && typeof customValidator === "function") {
+    const customValidation = customValidator(trimmedValue);
+
+    if (
+      typeof customValidation === "object" &&
+      customValidation.isValid === false
+    ) {
+      return {
+        isValid: false,
+        error: customValidation.error || defaultErrorMessages.customValidation,
+      };
+    } else if (customValidation === false) {
+      return {
+        isValid: false,
+        error: defaultErrorMessages.customValidation,
+      };
+    }
+    // If custom validator returns true or { isValid: true }, continue with other validations
+  }
+
+  // Then run any custom validator in rules
+  if (rules.customValidator && typeof rules.customValidator === "function") {
+    const rulesCustomValidation = rules.customValidator(trimmedValue);
+
+    if (
+      typeof rulesCustomValidation === "object" &&
+      rulesCustomValidation.isValid === false
+    ) {
+      return {
+        isValid: false,
+        error: rulesCustomValidation.error || defaultErrorMessages.custom,
+      };
+    } else if (rulesCustomValidation === false) {
+      return {
+        isValid: false,
+        error: defaultErrorMessages.custom,
+      };
+    }
+  }
+
+  // Then validate based on type
+  switch (type) {
+    case "name":
+      return validateName(trimmedValue, rules, defaultErrorMessages);
+    case "email":
+      return validateEmail(trimmedValue, rules, defaultErrorMessages);
+    case "mobile":
+      return validateMobile(trimmedValue, rules, defaultErrorMessages);
+    case "address":
+      return validateAddress(trimmedValue, rules, defaultErrorMessages);
+    case "password":
+      return validatePassword(trimmedValue, rules, defaultErrorMessages);
+    default:
+      return validateCustom(trimmedValue, rules, defaultErrorMessages);
+  }
+};
+
+// ... (keep all the existing validateName, validateEmail, etc. functions from previous solution)
+
+// Name validation
+const validateName = (value, rules, defaultErrorMessages) => {
+  // Check length constraints
+  if (rules?.minLength && value?.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
+    };
+  }
+
+  if (rules?.maxLength && value?.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+    };
+  }
+
+  // Check against custom regex if provided
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
+    };
+  }
+
+  // Default name validation (only letters, spaces, and basic punctuation)
+  const nameRegex = /^[a-zA-ZÀ-ÿ\s'-.]*$/;
+  if (!nameRegex.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid || "Name contains invalid characters",
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+// Email validation
+const validateEmail = (value, rules, defaultErrorMessages) => {
+  // Check length constraints
+  if (rules?.minLength && value.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+    };
+  }
+
+  // Check against custom regex if provided
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
+    };
+  }
+
+  // Default email regex
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid || "Please enter a valid email address",
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+// Mobile validation
+const validateMobile = (value, rules, defaultErrorMessages) => {
+  // Check length constraints
+  if (rules?.minLength && value.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+    };
+  }
+
+  // Check against custom regex if provided
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
+    };
+  }
+
+  // Default mobile regex (accepts numbers, +, -, and spaces)
+  const mobileRegex = /^[\d\s+\-()]*$/;
+  if (!mobileRegex.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid || "Please enter a valid mobile number",
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+// Address validation
+const validateAddress = (value, rules, defaultErrorMessages) => {
+  // Check length constraints
+  if (rules?.minLength && value.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+    };
+  }
+
+  // Check against custom regex if provided
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+// Add password validation
+const validatePassword = (value, rules, defaultErrorMessages) => {
+  // Check length constraints
+  if (rules?.minLength && value.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+    };
+  }
+
+  // Check against custom regex if provided
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
+    };
+  }
+
+  // Default password validation (at least one letter, one number)
+  const passwordRegex = /^(?=.*[A-Za-z])(?=.*\d).+$/;
+  if (!passwordRegex.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        "Password must contain at least one letter and one number",
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+// Custom validation
+const validateCustom = (value, rules, defaultErrorMessages) => {
+  // Check length constraints if value is a string
+  if (typeof value === "string") {
+    if (rules?.minLength && value.length < rules?.minLength) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
+      };
+    }
+
+    if (rules?.maxLength && value.length > rules?.maxLength) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+      };
+    }
+  }
+};
+
+module.exports = dynamicValidator;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "quantique-field-validator",
+  "version": "1.0.0",
+  "description": "Validator to verify all form fields.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saketsinhaquantique/quantique-field-validator.git"
+  },
+  "keywords": [
+    "QFV"
+  ],
+  "author": "Saket Brij Sinha <saket.sinha@quantique.ai>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/saketsinhaquantique/quantique-field-validator/issues"
+  },
+  "homepage": "https://github.com/saketsinhaquantique/quantique-field-validator#readme"
+}