cr-static-shared-components 9.9.0

package/src/validation.js

@@ -0,0 +1,403 @@
+'use strict';
+
+/**
+ * Validation Module
+ * Provides comprehensive type checking, schema validation, and data sanitization
+ *
+ * @module validation
+ */
+
+const errors = require('./errors');
+
+/**
+ * Type validators
+ */
+const TYPE_VALIDATORS = {
+  string: (val) => typeof val === 'string',
+  number: (val) => typeof val === 'number' && !isNaN(val),
+  boolean: (val) => typeof val === 'boolean',
+  object: (val) => typeof val === 'object' && val !== null && !Array.isArray(val),
+  array: (val) => Array.isArray(val),
+  function: (val) => typeof val === 'function',
+  null: (val) => val === null,
+  undefined: (val) => val === undefined,
+  date: (val) => val instanceof Date && !isNaN(val.getTime()),
+  regexp: (val) => val instanceof RegExp,
+  symbol: (val) => typeof val === 'symbol',
+  bigint: (val) => typeof val === 'bigint'
+};
+
+/**
+ * Email validation (RFC 5322 compliant)
+ */
+function email(value) {
+  if (typeof value !== 'string') return false;
+
+  const emailRegex = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+  if (!emailRegex.test(value)) return false;
+
+  // Additional checks
+  const [local, domain] = value.split('@');
+  if (local.length > 64) return false;
+  if (domain.length > 255) return false;
+
+  // Check for consecutive dots
+  if (value.includes('..')) return false;
+
+  return true;
+}
+
+/**
+ * URL validation
+ */
+function url(value, options = {}) {
+  if (typeof value !== 'string') return false;
+
+  const defaults = {
+    protocols: ['http', 'https', 'ftp'],
+    requireProtocol: true
+  };
+
+  const opts = { ...defaults, ...options };
+
+  try {
+    const parsed = new URL(value);
+
+    if (opts.requireProtocol && !parsed.protocol) {
+      return false;
+    }
+
+    if (opts.protocols.length > 0) {
+      const protocol = parsed.protocol.replace(':', '');
+      if (!opts.protocols.includes(protocol)) {
+        return false;
+      }
+    }
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * String validation with options
+ */
+function string(value, options = {}) {
+  if (typeof value !== 'string') return false;
+
+  if (options.minLength && value.length < options.minLength) {
+    return false;
+  }
+
+  if (options.maxLength && value.length > options.maxLength) {
+    return false;
+  }
+
+  if (options.pattern && !new RegExp(options.pattern).test(value)) {
+    return false;
+  }
+
+  if (options.enum && !options.enum.includes(value)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Number validation with constraints
+ */
+function number(value, options = {}) {
+  if (typeof value !== 'number' || isNaN(value)) return false;
+
+  if (options.min !== undefined && value < options.min) {
+    return false;
+  }
+
+  if (options.max !== undefined && value > options.max) {
+    return false;
+  }
+
+  if (options.integer && !Number.isInteger(value)) {
+    return false;
+  }
+
+  if (options.positive && value <= 0) {
+    return false;
+  }
+
+  if (options.negative && value >= 0) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Array validation
+ */
+function array(itemType, data) {
+  if (!Array.isArray(data)) {
+    return { valid: false, errors: ['Value is not an array'] };
+  }
+
+  if (!TYPE_VALIDATORS[itemType]) {
+    return { valid: false, errors: [`Unknown type: ${itemType}`] };
+  }
+
+  const validator = TYPE_VALIDATORS[itemType];
+  const errors = [];
+
+  data.forEach((item, index) => {
+    if (!validator(item)) {
+      errors.push(`Item at index ${index} is not of type ${itemType}`);
+    }
+  });
+
+  return {
+    valid: errors.length === 0,
+    errors: errors.length > 0 ? errors : undefined
+  };
+}
+
+/**
+ * Object schema validation
+ */
+function object(schema, data) {
+  if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+    return { valid: false, errors: ['Value is not an object'] };
+  }
+
+  const errors = [];
+
+  // Check required fields
+  for (const [key, typeOrSchema] of Object.entries(schema)) {
+    if (!(key in data)) {
+      errors.push(`Missing required field: ${key}`);
+      continue;
+    }
+
+    const value = data[key];
+
+    // Nested schema
+    if (typeof typeOrSchema === 'object' && !Array.isArray(typeOrSchema)) {
+      const result = object(typeOrSchema, value);
+      if (!result.valid) {
+        errors.push(`Invalid nested object at ${key}: ${result.errors.join(', ')}`);
+      }
+      continue;
+    }
+
+    // Type validation
+    if (typeof typeOrSchema === 'string') {
+      // Special types
+      if (typeOrSchema === 'email') {
+        if (!email(value)) {
+          errors.push(`Field ${key} is not a valid email`);
+        }
+        continue;
+      }
+
+      if (typeOrSchema === 'url') {
+        if (!url(value)) {
+          errors.push(`Field ${key} is not a valid URL`);
+        }
+        continue;
+      }
+
+      // Standard types
+      const validator = TYPE_VALIDATORS[typeOrSchema];
+      if (!validator) {
+        errors.push(`Unknown type for field ${key}: ${typeOrSchema}`);
+        continue;
+      }
+
+      if (!validator(value)) {
+        errors.push(`Field ${key} is not of type ${typeOrSchema}`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors: errors.length > 0 ? errors : undefined
+  };
+}
+
+/**
+ * UUID validation
+ */
+function uuid(value, version = null) {
+  if (typeof value !== 'string') return false;
+
+  const patterns = {
+    3: /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    all: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+  };
+
+  const pattern = version ? patterns[version] : patterns.all;
+  return pattern ? pattern.test(value) : false;
+}
+
+/**
+ * IP address validation
+ */
+function ip(value, version = null) {
+  if (typeof value !== 'string') return false;
+
+  const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+  const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$/;
+
+  if (version === 4) return ipv4Regex.test(value);
+  if (version === 6) return ipv6Regex.test(value);
+
+  return ipv4Regex.test(value) || ipv6Regex.test(value);
+}
+
+/**
+ * Credit card validation (Luhn algorithm)
+ */
+function creditCard(value) {
+  if (typeof value !== 'string') return false;
+
+  const sanitized = value.replace(/[\s-]/g, '');
+  if (!/^\d{13,19}$/.test(sanitized)) return false;
+
+  let sum = 0;
+  let shouldDouble = false;
+
+  for (let i = sanitized.length - 1; i >= 0; i--) {
+    let digit = parseInt(sanitized.charAt(i), 10);
+
+    if (shouldDouble) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+
+    sum += digit;
+    shouldDouble = !shouldDouble;
+  }
+
+  return sum % 10 === 0;
+}
+
+/**
+ * Date range validation
+ */
+function dateRange(value, options = {}) {
+  const date = value instanceof Date ? value : new Date(value);
+
+  if (isNaN(date.getTime())) return false;
+
+  if (options.min) {
+    const minDate = options.min instanceof Date ? options.min : new Date(options.min);
+    if (date < minDate) return false;
+  }
+
+  if (options.max) {
+    const maxDate = options.max instanceof Date ? options.max : new Date(options.max);
+    if (date > maxDate) return false;
+  }
+
+  return true;
+}
+
+/**
+ * Phone number validation (international format)
+ */
+function phone(value, format = 'international') {
+  if (typeof value !== 'string') return false;
+
+  if (format === 'international') {
+    // E.164 format
+    return /^\+[1-9]\d{1,14}$/.test(value);
+  }
+
+  if (format === 'us') {
+    return /^(\+1)?[-.\s]?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}$/.test(value);
+  }
+
+  return false;
+}
+
+/**
+ * Postal code validation
+ */
+function postalCode(value, country = 'US') {
+  if (typeof value !== 'string') return false;
+
+  const patterns = {
+    US: /^\d{5}(-\d{4})?$/,
+    UK: /^[A-Z]{1,2}\d{1,2}\s?\d[A-Z]{2}$/i,
+    CA: /^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i,
+    DE: /^\d{5}$/,
+    FR: /^\d{5}$/,
+    JP: /^\d{3}-?\d{4}$/,
+    CN: /^\d{6}$/
+  };
+
+  const pattern = patterns[country.toUpperCase()];
+  return pattern ? pattern.test(value) : false;
+}
+
+/**
+ * JSON validation
+ */
+function json(value) {
+  if (typeof value !== 'string') return false;
+
+  try {
+    JSON.parse(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Base64 validation
+ */
+function base64(value) {
+  if (typeof value !== 'string') return false;
+  return /^[A-Za-z0-9+/]*={0,2}$/.test(value);
+}
+
+/**
+ * Hex color validation
+ */
+function hexColor(value) {
+  if (typeof value !== 'string') return false;
+  return /^#?([0-9A-F]{3}|[0-9A-F]{6})$/i.test(value);
+}
+
+/**
+ * MAC address validation
+ */
+function macAddress(value) {
+  if (typeof value !== 'string') return false;
+  return /^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$/i.test(value);
+}
+
+module.exports = {
+  object,
+  array,
+  email,
+  url,
+  string,
+  number,
+  uuid,
+  ip,
+  creditCard,
+  dateRange,
+  phone,
+  postalCode,
+  json,
+  base64,
+  hexColor,
+  macAddress,
+  TYPE_VALIDATORS
+};