quantique-field-validator 1.0.1 → 1.0.2

package/Validators/validateName.js

@@ -0,0 +1,59 @@
+// Name validation
+const validateName = (
+  value,
+  rules = { type: "user" },
+  defaultErrorMessages,
+  type
+) => {
+  // Check length constraints
+  if (rules?.minLength && value?.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value?.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  // Default name validation (only letters, spaces, and basic punctuation)
+  // Check against custom regex if provided
+  if (rules?.type === "user") {
+    const defaultRegex = /^[a-zA-ZÀ-ÿ\s'-.]*$/;
+    const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+    if (!regexToUse.test(value)) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.invalid || "Name contains invalid characters",
+      };
+    }
+  }
+
+  if (rules?.type === "corporate") {
+    const defaultRegex = /^[A-Za-z0-9&.,'()\- ]*$/;
+    const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+    if (!regexToUse.test(value)) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.invalid ||
+          "Corporate Name contains invalid characters",
+      };
+    }
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateName;

package/Validators/validateNumber.js

@@ -0,0 +1,75 @@
+// Number validation
+const validateNumber = (value, rules, defaultErrorMessages, type) => {
+  // Reject if value contains spaces
+  if (/\s/.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).noSpace ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  // Whole number only regex
+  const defaultNumberRegex = /^\d+$/;
+  const regexToUse = rules?.regex
+    ? new RegExp(rules.regex)
+    : defaultNumberRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid ||
+        "Please enter a valid whole number",
+    };
+  }
+
+  const numberValue = Number(value);
+
+  // Length checks (on the string)
+  if (rules?.minLength && value.length < rules.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  // Value range checks
+  if (rules?.minValue !== undefined && numberValue < rules.minValue) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minValue ||
+        defaultErrorMessages(rules, type).minValue ||
+        `Value must be at least ${rules.minValue}`,
+    };
+  }
+
+  if (rules?.maxValue !== undefined && numberValue > rules.maxValue) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxValue ||
+        defaultErrorMessages(rules, type).maxValue ||
+        `Value must not exceed ${rules.maxValue}`,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateNumber;

package/Validators/validatePanCard.js

@@ -0,0 +1,34 @@
+const validatePanCard = (
+  value,
+  rules,
+  defaultErrorMessages,
+  type
+) => {
+  const defaultRules = {
+    regex: /^[A-Z]{5}[0-9]{4}[A-Z]{1}$/, 
+  };
+
+  
+  const effectiveRules = {
+    ...defaultRules,
+    ...rules,
+  };
+
+  
+
+  if (
+    effectiveRules?.regex &&
+    !new RegExp(effectiveRules?.regex).test(value)
+  ) {
+    return {
+      isValid: false,
+      error:
+        effectiveRules?.errorMessages?.invalid ||
+        defaultErrorMessages(effectiveRules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validatePanCard;

package/Validators/validatePassword.js

@@ -0,0 +1,38 @@
+// Add password validation
+const validatePassword = (value, rules, defaultErrorMessages, type) => {
+  // Check length constraints
+  if (rules?.minLength && value.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  // Check against custom regex if provided
+  const defaultRegex = /^(?=.*[A-Za-z])(?=.*\d).+$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        "Password must contain at least one letter and one number",
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validatePassword;

package/Validators/validateString.js

@@ -0,0 +1,41 @@
+// String validation
+const validateString = (value, rules, defaultErrorMessages, type) => {
+  if (typeof value !== "string") {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+  if (rules?.minLength && value.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateString;

package/index.js

@@ -1,5 +1,3 @@
-const { parsePhoneNumberFromString } = require("libphonenumber-js/max");
-
 /**
  * Enhanced dynamic validator with custom function support
  * @param {string} value - The value to validate
@@ -8,38 +6,47 @@ const { parsePhoneNumberFromString } = require("libphonenumber-js/max");
  * @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}`,
-    noValidation: `No validation exist for ${type}`,
-    custom: "Validation failed",
-    customValidation:
-      rules.errorMessages?.customValidation || "Custom validation failed",
-  };
 
+const defaultErrorMessages = require("./Messages/defaultErrorMessages");
+const validateString = require("./Validators/validateString");
+const validateAlphanumeric = require("./Validators/validateAlphanumeric");
+const validateNumber = require("./Validators/validateNumber");
+const validateFloatNumber = require("./Validators/validateFloatNumber");
+const validateDate = require("./Validators/validateDate");
+const validateName = require("./Validators/validateName");
+const validateEmail = require("./Validators/validateEmail");
+const validateMobile = require("./Validators/validateMobile");
+const validateAddress = require("./Validators/validateAddress");
+const validatePassword = require("./Validators/validatePassword");
+const validateCustom = require("./Validators/validateCustom");
+const validateAadhaar = require("./Validators/validateAadhaar");
+const validatePanCard = require("./Validators/validatePanCard");
+const validateChassisNumber = require("./Validators/ValidateChassisNumber");
+
+const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
   // Trim the value if it's a string
-  const trimmedValue = typeof value === "string" ? value.trim() : value;
+  // const selectedValue = typeof value === "string" ? value.trim() : value;
+
+  const selectedValue = value;
 
   // Check if field is required and empty
-  if (rules.required && (!trimmedValue || trimmedValue === "")) {
+  if (rules.required && (!selectedValue || selectedValue === "")) {
     return {
       isValid: false,
-      error: rules.errorMessages?.required || defaultErrorMessages.required,
+      error:
+        rules.errorMessages?.required ||
+        defaultErrorMessages(rules, type).required,
     };
   }
 
   // Skip further validation if the field is empty and not required
-  if (!rules.required && (!trimmedValue || trimmedValue === "")) {
+  if (!rules.required && (!selectedValue || selectedValue === "")) {
     return { isValid: true, error: "" };
   }
 
   // First run custom validator if provided (highest priority)
   if (customValidator && typeof customValidator === "function") {
-    const customValidation = customValidator(trimmedValue);
+    const customValidation = customValidator(selectedValue);
 
     if (
       typeof customValidation === "object" &&
@@ -47,12 +54,14 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
     ) {
       return {
         isValid: false,
-        error: customValidation.error || defaultErrorMessages.customValidation,
+        error:
+          customValidation.error ||
+          defaultErrorMessages(rules, type).customValidation,
       };
     } else if (customValidation === false) {
       return {
         isValid: false,
-        error: defaultErrorMessages.customValidation,
+        error: defaultErrorMessages(rules, type).customValidation,
       };
     }
     // If custom validator returns true or { isValid: true }, continue with other validations
@@ -60,7 +69,7 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
 
   // Then run any custom validator in rules
   if (rules.customValidator && typeof rules.customValidator === "function") {
-    const rulesCustomValidation = rules.customValidator(trimmedValue);
+    const rulesCustomValidation = rules.customValidator(selectedValue);
 
     if (
       typeof rulesCustomValidation === "object" &&
@@ -68,292 +77,69 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
     ) {
       return {
         isValid: false,
-        error: rulesCustomValidation.error || defaultErrorMessages.custom,
+        error:
+          rulesCustomValidation.error ||
+          defaultErrorMessages(rules, type).custom,
       };
     } else if (rulesCustomValidation === false) {
       return {
         isValid: false,
-        error: defaultErrorMessages.custom,
+        error: defaultErrorMessages(rules, type).custom,
       };
     }
   }
 
   // Then validate based on type
   switch (type) {
+    case "string":
+      return validateString(selectedValue, rules, defaultErrorMessages, type);
+    case "alphanumeric":
+      return validateAlphanumeric(
+        selectedValue,
+        rules,
+        defaultErrorMessages,
+        type
+      );
+    case "number":
+      return validateNumber(selectedValue, rules, defaultErrorMessages, type);
+    case "float":
+      return validateFloatNumber(
+        selectedValue,
+        rules,
+        defaultErrorMessages,
+        type
+      );
+    case "date":
+      return validateDate(selectedValue, rules, defaultErrorMessages, type);
     case "name":
-      return validateName(trimmedValue, rules, defaultErrorMessages);
+      return validateName(trimmedValue, rules, defaultErrorMessages, type);
     case "email":
-      return validateEmail(trimmedValue, rules, defaultErrorMessages);
+      return validateEmail(selectedValue, rules, defaultErrorMessages, type);
     case "mobile":
-      return validateMobile(trimmedValue, rules, defaultErrorMessages);
+      return validateMobile(selectedValue, rules, defaultErrorMessages, type);
     case "address":
-      return validateAddress(trimmedValue, rules, defaultErrorMessages);
+      return validateAddress(selectedValue, rules, defaultErrorMessages, type);
     case "password":
-      return validatePassword(trimmedValue, rules, defaultErrorMessages);
+      return validatePassword(trimmedValue, rules, defaultErrorMessages, type);
+    case "chassis":
+      return validateChassisNumber(
+        trimmedValue,
+        rules,
+        defaultErrorMessages,
+        type
+      );
+      return validatePassword(selectedValue, rules, defaultErrorMessages, type);
+    case "aadhaar":
+      return validateAadhaar(selectedValue, rules, defaultErrorMessages, type);
+    case "pan":
+      return validatePanCard(selectedValue, rules, defaultErrorMessages, type);
     case "custom":
-      return validateCustom(trimmedValue, rules, defaultErrorMessages);
+      return validateCustom(selectedValue, rules, defaultErrorMessages, type);
     default:
-      return { isValid: false, error: defaultErrorMessages?.noValidation };
-  }
-};
-
-// ... (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: "" };
-// };
-
-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,
-    };
-  }
-
-  // Custom regex check
-  if (rules.regex && !new RegExp(rules.regex).test(value)) {
-    return {
-      isValid: false,
-      error: rules.errorMessages?.invalid || defaultErrorMessages.invalid,
-    };
-  }
-
-  // Validate using libphonenumber-js
-  const phoneNumber = parsePhoneNumberFromString(
-    value,
-    rules?.countryCode || "IN"
-  );
-
-  //   console.log('phoneNumber', phoneNumber)
-  console.log(
-    "phoneNumber.isValid()",
-    phoneNumber.isValid(),
-    phoneNumber.getType()
-  );
-
-  if (
-    !phoneNumber?.isValid() &&
-    (phoneNumber?.getType() !== "MOBILE" ||
-      phoneNumber?.getType() !== "FIXED_LINE_OR_MOBILE")
-  ) {
-    return {
-      isValid: false,
-      error:
-        rules.errorMessages?.invalid ||
-        defaultErrorMessages.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,
+        error: defaultErrorMessages(rules, type)?.noValidation,
       };
-    }
   }
 };