quival 0.1.0

package/src/Validator.js

@@ -0,0 +1,446 @@
+import Checkers from './Checkers.js';
+import ErrorBag from './ErrorBag.js';
+import Lang from './Lang.js';
+import Replacers from './Replacers.js';
+import { flattenObject, getByPath, isEmpty, isNumeric, isPlainObject, toCamelCase, toSnakeCase } from './helpers.js';
+
+export default class Validator {
+  static #customCheckers = {};
+  static #customReplacers = {};
+
+  static #dummyRules = [
+    'active_url',
+    'bail',
+    'current_password',
+    'enum',
+    'exclude',
+    'exclude_if',
+    'exclude_unless',
+    'exclude_with',
+    'exclude_without',
+    'exists',
+    'nullable',
+    'sometimes',
+    'unique',
+  ];
+
+  static #implicitRules = [
+    'accepted',
+    'accepted_if',
+    'declined',
+    'declined_if',
+    'filled',
+    'missing',
+    'missing_if',
+    'missing_unless',
+    'missing_with',
+    'missing_with_all',
+    'present',
+    'required',
+    'required_if',
+    'required_if_accepted',
+    'required_unless',
+    'required_with',
+    'required_with_all',
+    'required_without',
+    'required_without_all',
+  ];
+
+  #data;
+  #rules;
+  #customMessages;
+  #customAttributes;
+  #customValues;
+
+  #checkers;
+  #replacers;
+  #errors;
+
+  #implicitAttributes = {};
+  #stopOnFirstFailure = false;
+  #alwaysBail = false;
+
+  fileRules = ['file', 'image', 'mimetypes', 'mimes'];
+  numericRules = ['decimal', 'numeric', 'integer'];
+  sizeRules = ['size', 'between', 'min', 'max', 'gt', 'lt', 'gte', 'lte'];
+
+  static setLocale(locale) {
+    Lang.locale(locale);
+  }
+
+  static setMessages(locale, messages) {
+    Lang.setMessages(locale, messages);
+  }
+
+  static addChecker(rule, method, message) {
+    Validator.#customCheckers[rule] = method;
+
+    if (message) {
+      Lang.set(rule, message);
+    }
+  }
+
+  static addImplicitChecker(rule, method, message) {
+    Validator.addChecker(rule, method, message);
+    Validator.#implicitRules.push(rule);
+  }
+
+  static addReplacer(rule, method) {
+    Validator.#customReplacers[rule] = method;
+  }
+
+  static addDummyRule(rule) {
+    Validator.#dummyRules.push(rule);
+  }
+
+  constructor(data = {}, rules = {}, messages = {}, attributes = {}, values = {}) {
+    this.setProperties(data, rules, messages, attributes, values);
+
+    this.#checkers = new Checkers(this);
+    this.#replacers = new Replacers(this);
+
+    for (const [rule, checker] of Object.entries(Validator.#customCheckers)) {
+      this.#checkers[toCamelCase('check_' + rule)] = checker;
+    }
+
+    for (const [rule, replacer] of Object.entries(Validator.#customReplacers)) {
+      this.#replacers[toCamelCase('replace_' + rule)] = replacer;
+    }
+  }
+
+  setProperties(data = {}, rules = {}, messages = {}, attributes = {}, values = {}) {
+    this.#data = data;
+    this.#rules = this.parseRules(rules);
+    this.#customMessages = messages;
+    this.#customAttributes = attributes;
+    this.#customValues = flattenObject(values);
+
+    return this;
+  }
+
+  setData(data) {
+    this.#data = data;
+
+    return this;
+  }
+
+  setRules(rules) {
+    this.#rules = this.parseRules(rules);
+
+    return this;
+  }
+
+  setCustomMessages(messages) {
+    this.#customMessages = messages;
+
+    return this;
+  }
+
+  setCustomAttributes(attributes) {
+    this.#customAttributes = attributes;
+
+    return this;
+  }
+
+  setCustomValues(values) {
+    this.#customValues = flattenObject(values);
+
+    return this;
+  }
+
+  addImplicitAttribute(implicitAttribute, attribute) {
+    this.#implicitAttributes[implicitAttribute] = attribute;
+
+    return this;
+  }
+
+  stopOnFirstFailure(flag = true) {
+    this.#stopOnFirstFailure = flag;
+
+    return this;
+  }
+
+  alwaysBail(flag = true) {
+    this.#alwaysBail = flag;
+
+    return this;
+  }
+
+  parseRules(rules) {
+    const parsedRules = {};
+
+    const parseAttributeRules = (rules) => {
+      if (Array.isArray(rules)) {
+        return rules;
+      } else {
+        return String(rules).split('|');
+      }
+    };
+
+    for (const [attribute, attributeRules] of Object.entries(rules)) {
+      const attributes = attribute.includes('*') ? this.parseWildcardAttribute(attribute) : [attribute];
+
+      for (const attribute of attributes) {
+        const parsedAttributeRules = {};
+
+        for (const attributeRule of parseAttributeRules(attributeRules)) {
+          const parts = attributeRule.split(':');
+          const rule = parts[0];
+          const parameters = parts
+            .slice(1)
+            .join(':')
+            .split(',')
+            .filter((part) => part !== '');
+
+          parsedAttributeRules[rule] = parameters;
+        }
+
+        parsedRules[attribute] = parsedAttributeRules;
+      }
+    }
+
+    return parsedRules;
+  }
+
+  parseWildcardAttribute(attribute) {
+    const attributes = [];
+    const index = attribute.indexOf('*');
+    const parentPath = attribute.substring(0, index - 1);
+    const childPath = attribute.substring(index + 2);
+    const data = this.getValue(parentPath);
+
+    if (!(Array.isArray(data) || isPlainObject(data))) {
+      return [attribute];
+    }
+
+    Object.entries(data).forEach(([key, value]) => {
+      const implicitAttribute = `${parentPath}.${key}.${childPath}`.replace(/\.$/, '');
+      const implicitAttributes = implicitAttribute.includes('*') ? this.parseWildcardAttribute(implicitAttribute) : [implicitAttribute];
+
+      attributes.push(...implicitAttributes);
+      implicitAttributes.forEach((value) => (this.#implicitAttributes[value] = attribute));
+    });
+
+    return attributes;
+  }
+
+  async validate() {
+    this.#checkers.clearCaches();
+    this.#errors = new ErrorBag();
+
+    for (const [attribute, rules] of Object.entries(this.#rules)) {
+      let value = this.getValue(attribute);
+
+      const doBail = this.#alwaysBail || rules.hasOwnProperty('bail');
+      const isNullable = rules.hasOwnProperty('nullable');
+
+      if (rules.hasOwnProperty('sometimes') && typeof value === 'undefined') {
+        continue;
+      }
+
+      for (const [rule, parameters] of Object.entries(rules)) {
+        if (
+          !Validator.#implicitRules.includes(rule) &&
+          (typeof value == 'undefined' || (typeof value === 'string' && value.trim() === '') || (isNullable && value === null))
+        ) {
+          break;
+        }
+
+        let result, status, message;
+        const camelRule = toCamelCase('check_' + rule);
+
+        if (typeof this.#checkers[camelRule] === 'function') {
+          result = await this.#checkers[camelRule](attribute, value, parameters);
+        } else if (Validator.#dummyRules.includes(rule)) {
+          result = true;
+        } else {
+          throw new Error(`Invalid validation rule: ${rule}`);
+        }
+
+        if (typeof result === 'boolean') {
+          status = result;
+        } else {
+          ({ status, message } = result);
+        }
+
+        if (!status) {
+          message = isEmpty(message) ? this.getMessage(attribute, rule) : message;
+          message = this.makeReplacements(message, attribute, rule, parameters);
+
+          this.#errors.add(attribute, message);
+
+          if (doBail || Validator.#implicitRules.includes(rule)) {
+            break;
+          }
+        }
+      }
+
+      if (this.#stopOnFirstFailure && this.#errors.isNotEmpty()) {
+        break;
+      }
+    }
+
+    const messages = this.#errors.messages();
+
+    if (Object.keys(messages).length > 0) {
+      throw messages;
+    }
+  }
+
+  getMessage(attribute, rule) {
+    const value = this.getValue(attribute);
+    attribute = this.getPrimaryAttribute(attribute);
+
+    let message;
+
+    for (const key of [`${attribute}.${rule}`, rule]) {
+      if (this.#customMessages.hasOwnProperty(key)) {
+        message = this.#customMessages[key];
+
+        break;
+      }
+    }
+
+    if (!message) {
+      let key = rule;
+
+      if (this.sizeRules.includes(key)) {
+        if (Array.isArray(value) || isPlainObject(value) || this.hasRule(attribute, 'array')) {
+          key += '.array';
+        } else if (value instanceof File || this.hasRule(attribute, this.fileRules)) {
+          key += '.file';
+        } else if (typeof value === 'number' || this.hasRule(attribute, this.numericRules)) {
+          key += '.numeric';
+        } else {
+          key += '.string';
+        }
+      }
+
+      message = Lang.get(key);
+    }
+
+    return message ?? `validation.${rule}`;
+  }
+
+  makeReplacements(message, attribute, rule, parameters) {
+    const attributeName = this.getDisplayableAttribute(attribute);
+    const value = this.getValue(attribute);
+
+    const data = {
+      attribute: attributeName,
+      ATTRIBUTE: attributeName.toLocaleUpperCase(),
+      Attribute: attributeName.charAt(0).toLocaleUpperCase() + attributeName.substring(1),
+      input: this.getDisplayableValue(attribute, value),
+    };
+
+    for (const [key, value] of Object.entries(data)) {
+      message = message.replaceAll(':' + key, value);
+    }
+
+    const match = attribute.match(/\.(\d+)\.?/);
+    const index = match === null ? -1 : parseInt(match[1], 10);
+
+    if (index !== -1) {
+      message = message.replaceAll(':index', index).replaceAll(':position', index + 1);
+    }
+
+    const camelRule = toCamelCase('replace_' + rule);
+
+    if (typeof this.#replacers[camelRule] === 'function') {
+      message = this.#replacers[camelRule](message, attribute, rule, parameters);
+    }
+
+    return message;
+  }
+
+  getDisplayableAttribute(attribute) {
+    const unparsed = this.getPrimaryAttribute(attribute);
+
+    for (const name of [attribute, unparsed]) {
+      if (this.#customAttributes.hasOwnProperty(name)) {
+        return this.#customAttributes[name];
+      } else if (Lang.has(`attributes.${name}`)) {
+        return Lang.get(`attributes.${name}`);
+      }
+    }
+
+    if (this.#implicitAttributes.hasOwnProperty(attribute)) {
+      return attribute;
+    }
+
+    return toSnakeCase(attribute).replaceAll('_', ' ');
+  }
+
+  getDisplayableValue(attribute, value) {
+    attribute = this.getPrimaryAttribute(attribute);
+
+    const path = `${attribute}.${value}`;
+
+    if (isEmpty(value)) {
+      return 'empty';
+    } else if (typeof value === 'boolean' || this.hasRule(attribute, 'boolean')) {
+      return Number(value) ? 'true' : 'false';
+    } else if (this.#customValues.hasOwnProperty(path)) {
+      return this.#customValues[path];
+    } else if (Lang.has(`values.${path}`)) {
+      return Lang.get(`values.${path}`);
+    }
+
+    return value;
+  }
+
+  getSize(attribute, value) {
+    if (isEmpty(value)) {
+      return 0;
+    } else if (isNumeric(value) && this.hasRule(attribute, this.numericRules)) {
+      return parseFloat(typeof value === 'string' ? value.trim() : value, 10);
+    } else if (value instanceof File) {
+      return value.size / 1024;
+    } else if (isPlainObject(value)) {
+      return Object.keys(value).length;
+    } else if (value.hasOwnProperty('length')) {
+      return value.length;
+    }
+
+    return value;
+  }
+
+  getRule(attribute) {
+    attribute = this.getPrimaryAttribute(attribute);
+
+    return this.#rules[attribute];
+  }
+
+  hasRule(attribute, rules) {
+    attribute = this.getPrimaryAttribute(attribute);
+    rules = typeof rules === 'string' ? [rules] : rules;
+
+    if (!this.#rules.hasOwnProperty(attribute)) {
+      return false;
+    }
+
+    for (const rule of rules) {
+      if (this.#rules[attribute].hasOwnProperty(rule)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  getPrimaryAttribute(attribute) {
+    return this.#implicitAttributes.hasOwnProperty(attribute) ? this.#implicitAttributes[attribute] : attribute;
+  }
+
+  hasAttribute(attribute) {
+    return typeof this.getValue(attribute) !== 'undefined';
+  }
+
+  getValue(attribute) {
+    return getByPath(this.#data, attribute);
+  }
+
+  errors() {
+    return this.#errors;
+  }
+}

package/src/helpers.js

@@ -0,0 +1,229 @@
+export function toCamelCase(string) {
+  return string.replace(/(_\w)/g, (match) => match[1].toUpperCase());
+}
+
+export function toSnakeCase(string) {
+  return string.replace(/[\w]([A-Z])/g, (match) => match[0] + '_' + match[1].toLowerCase()).toLowerCase();
+}
+
+export function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function getByPath(obj, path, defaultValue) {
+  const keys = path.split('.');
+  let current = obj;
+
+  for (const key of keys) {
+    if (!current.hasOwnProperty(key)) {
+      return defaultValue;
+    }
+
+    current = current[key];
+  }
+
+  return current;
+}
+
+export function setByPath(obj, path, value) {
+  const keys = path.split('.');
+  let current = obj;
+
+  for (const key of keys.slice(0, -1)) {
+    if (!current.hasOwnProperty(key)) {
+      current[key] = {};
+    }
+
+    current = current[key];
+  }
+
+  current[keys.slice(-1)] = value;
+}
+
+export function flattenObject(obj, prefix = '') {
+  return Object.keys(obj).reduce((accumulator, key) => {
+    const prefixedKey = prefix ? `${prefix}.${key}` : key;
+
+    if (typeof obj[key] === 'object' && obj[key] !== null) {
+      Object.assign(accumulator, flattenObject(obj[key], prefixedKey));
+    } else {
+      accumulator[prefixedKey] = obj[key];
+    }
+
+    return accumulator;
+  }, {});
+}
+
+export function parseDate(value) {
+  if (isEmpty(value)) {
+    return new Date('');
+  } else if (value instanceof Date) {
+    return value;
+  }
+
+  let match, years, months, days, hours, minutes, seconds, meridiem;
+
+  const castToIntegers = (value) => (value && /^\d*$/.test(value) ? parseInt(value) : value);
+
+  if ((match = value.match(/^(\d{1,2})[.\/-](\d{1,2})[.\/-](\d{2,4})\s?((\d{1,2}):(\d{1,2})(:(\d{1,2}))?\s?(am|pm)?)?/i)) !== null) {
+    [, days, months, years, , hours = 0, minutes = 0, , seconds = 0, meridiem = 'am'] = match.map(castToIntegers);
+  } else if (
+    (match = value.match(/^(\d{2,4})[.\/-](\d{1,2})[.\/-](\d{1,2})\s?((\d{1,2}):(\d{1,2})(:(\d{1,2}))?\s?(am|pm)?)?/i)) !== null ||
+    (match = value.match(/^(\d{4})(\d{2})(\d{2})\s?((\d{2})(\d{2})((\d{2}))?\s?(am|pm)?)?/i)) !== null
+  ) {
+    [, years, months, days, , hours = 0, minutes = 0, , seconds = 0, meridiem = 'am'] = match.map(castToIntegers);
+  } else if ((match = value.match(/(\d{1,2}):(\d{1,2})(:(\d{1,2}))?\s?(am|pm)?\s?(\d{4})[.\/-](\d{2})[.\/-](\d{2})/i))) {
+    [, hours, minutes, , seconds, meridiem = 'am', years, months, days] = match.map(castToIntegers);
+  } else if ((match = value.match(/(\d{1,2}):(\d{1,2})(:(\d{1,2}))?\s?(am|pm)?\s?(\d{2})[.\/-](\d{2})[.\/-](\d{4})/i))) {
+    [, hours, minutes, , seconds, meridiem = 'am', days, months, years] = match.map(castToIntegers);
+  } else if ((match = value.match(/(\d{1,2}):(\d{1,2})(:(\d{1,2}))?\s?(am|pm)?/i))) {
+    const current = new Date();
+
+    years = current.getFullYear();
+    months = current.getMonth() + 1;
+    days = current.getDate();
+
+    [, hours = 0, minutes = 0, , seconds = 0, meridiem = 'am'] = match.map(castToIntegers);
+  } else {
+    return new Date(value);
+  }
+
+  if (years >= 10 && years < 100) {
+    years += 2000;
+  }
+
+  if (meridiem.toLowerCase() === 'pm' && hours < 12) {
+    hours += 12;
+  }
+
+  return new Date(`${years}-${months}-${days} ${hours}:${minutes}:${seconds}`);
+}
+
+export function parseDateByFormat(value, format) {
+  if (isEmpty(value)) {
+    return new Date('');
+  }
+
+  format = format.split('');
+
+  const formats = {
+    Y: '(\\d{4})',
+    y: '(\\d{2})',
+    m: '(\\d{2})',
+    n: '([1-9]\\d?)',
+    d: '(\\d{2})',
+    j: '([1-9]\\d?)',
+    G: '([1-9]\\d?)',
+    g: '([1-9]\\d?)',
+    H: '(\\d{2})',
+    h: '(\\d{2})',
+    i: '(\\d{2})',
+    s: '(\\d{2})',
+    A: '(AM|PM)',
+    a: '(am|pm)',
+  };
+
+  let pattern = '^';
+  let indices = {
+    years: -1,
+    months: -1,
+    days: -1,
+    hours: -1,
+    minutes: -1,
+    seconds: -1,
+    meridiem: -1,
+  };
+
+  let index = 1;
+
+  for (const char of format) {
+    if (formats.hasOwnProperty(char)) {
+      pattern += formats[char];
+
+      if (['Y', 'y'].indexOf(char) !== -1) {
+        indices.years = index++;
+      } else if (['m', 'n'].indexOf(char) !== -1) {
+        indices.months = index++;
+      } else if (['d', 'j'].indexOf(char) !== -1) {
+        indices.days = index++;
+      } else if (['G', 'g', 'H', 'h'].indexOf(char) !== -1) {
+        indices.hours = index++;
+      } else if (char === 'i') {
+        indices.minutes = index++;
+      } else if (char === 's') {
+        indices.seconds = index++;
+      } else if (['A', 'a'].indexOf(char) !== -1) {
+        indices.meridiem = index++;
+      }
+    } else {
+      pattern += '\\' + char;
+    }
+  }
+
+  pattern += '$';
+
+  let match = value.match(new RegExp(pattern));
+
+  if (match === null) {
+    return new Date('');
+  }
+
+  match = match.map((value) => (value && /^\d*$/.test(value) ? parseInt(value) : value));
+
+  const current = new Date();
+
+  let years = match[indices.years];
+  let months = match[indices.months];
+  let days = match[indices.days];
+  let hours = match[indices.hours] ?? 0;
+  let minutes = match[indices.minutes] ?? 0;
+  let seconds = match[indices.seconds] ?? 0;
+  let meridiem = match[indices.meridiem] ?? 'am';
+
+  if (!years && !months && !days) {
+    years = current.getFullYear();
+    months = current.getMonth() + 1;
+    days = current.getDate();
+  } else if (years && !months && !days) {
+    months = 1;
+    days = 1;
+  } else if (!years && months && !days) {
+    years = current.getFullYear();
+    days = 1;
+  } else if (!years && !months && days) {
+    years = current.getFullYear();
+    months = current.getMonth() + 1;
+  }
+
+  if (years >= 10 && years < 100) {
+    years = years + 2000;
+  }
+
+  if (meridiem.toLowerCase() === 'pm' && hours < 12) {
+    hours += 12;
+  }
+
+  return new Date(`${years}-${months}-${days} ${hours}:${minutes}:${seconds}`);
+}
+
+export function isDigits(value) {
+  return String(value).search(/[^0-9]/) === -1;
+}
+
+export function isEmpty(value) {
+  return value === '' || value === null || typeof value === 'undefined';
+}
+
+export function isNumeric(value) {
+  const number = Number(value);
+
+  return value !== null && typeof value !== 'boolean' && typeof number === 'number' && !isNaN(number);
+}
+
+export function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+export function isValidDate(value) {
+  return value instanceof Date && value.toDateString() !== 'Invalid Date';
+}

package/src/index.js

@@ -0,0 +1,7 @@
+import Checkers from './Checkers.js';
+import ErrorBag from './ErrorBag.js';
+import Lang from './Lang.js';
+import Replacers from './Replacers.js';
+import Validator from './Validator.js';
+
+export { Checkers, ErrorBag, Lang, Replacers, Validator };