validno 0.1.9 → 0.1.10

package/src/utils/validations.ts

@@ -1,111 +0,0 @@
-const _validations: {[key: string]: Function} = {};
-
-_validations.isString = (value: any) => {
-  return typeof value === 'string';
-};
-
-_validations.isDate = (value: any) => {
-  return value instanceof Date && String(value) !== 'Invalid Date';
-};
-
-_validations.isNumber = (value: any) => {
-  return typeof value === 'number';
-};
-
-_validations.isNumberGte = (value: any, gte: number) => {
-  return typeof value === 'number' && value >= gte;
-};
-
-_validations.isNumberLte = (value: any, lte: number) => {
-  return typeof value === 'number' && value <= lte;
-};
-
-_validations.isArray = (value: any) => {
-  return Array.isArray(value);
-};
-
-_validations.isObject = (value: any) => {
-  return typeof value === 'object' && !Array.isArray(value) && value !== null
-};
-
-_validations.lengthIs = (value: any, length: number) => {
-  return value.length === length;
-};
-
-_validations.lengthNot = (value: any, length: number) => {
-  return value.length !== length;
-};
-
-_validations.lengthMin = (value: any, min: number) => {
-  return value.length >= min;
-};
-
-_validations.lengthMax = (value: any, max: number) => {
-  return value.length <= max;
-};
-
-_validations.isEmail = (value: string) => {
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(value);
-};
-
-_validations.isRegex = (value: any) => {
-  return value instanceof RegExp
-}
-
-_validations.hasKey = (obj: object, key: string) => {
-  return key in obj;
-};
-
-_validations.isNot = (value: any, not: any) => {
-  if (typeof not === 'object' && Array.isArray(not)) {
-    for (let i = 0; i < not.length; i++) {
-      if (value === not[i]) return false;
-    }
-
-    return true;
-  }
-
-  return value !== not;
-};
-
-_validations.is = (value: any, compareTo: any) => {
-  if (typeof compareTo === 'object' && Array.isArray(compareTo)) {
-    for (let i = 0; i < compareTo.length; i++) {
-      if (value === compareTo[i]) return true;
-    }
-
-    return false;
-  }
-
-  return value === compareTo;
-};
-
-_validations.isDateYYYYMMDD = (value: string) => {
-  const regex = /^\d{4}-\d{2}-\d{2}$/;
-  return regex.test(value);
-};
-
-_validations.regexTested = (value: string, regex: RegExp) =>{
-  if (!regex) throw new Error('regex argument is not defined');
-  return regex.test(value);
-};
-
-_validations.isHex = (value: string) => {
-  const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
-  return regex.test(value);
-};
-
-_validations.isBoolean = (value: string) => {
-  return typeof value === 'boolean'
-}
-
-_validations.isNull = (value: string) => {
-  return value === null
-}
-
-_validations.isUndefined = (value: string) => {
-  return value === undefined
-}
-
-export default _validations

package/src/validate.ts

@@ -1,198 +0,0 @@
-import checkRules from "./checkRules.js";
-import checkType from "./checkType.js";
-import _errors from "./utils/errors.js";
-import _validations from "./utils/validations.js";
-import { defaultSchemaKeys, Schema, TSchemaInput } from "./Schema.js";
-import { ErrorKeywords } from "./constants/details.js";
-
-export type TResult = {
-    ok: null | boolean,
-    missed: string[],
-    failed: string[],
-    passed: string[],
-    errors: string[],
-    byKeys: {[key: string]: boolean},
-    errorsByKeys: {[key: string]: string[]},
-};
-
-export const getResultDefaults = (): TResult => {
-  return {
-    ok: null,
-    missed: [],
-    failed: [],
-    passed: [],
-    errors: [],
-    byKeys: {},
-    errorsByKeys: {},
-  };
-}
-
-const checkIsNested = (obj: {[key: string]: any}) => {
-  if (!_validations.isObject(obj)) return false
-
-  const objKeys = Object.keys(obj)
-
-  if (objKeys.every((k: any) => defaultSchemaKeys.includes(k))) {
-    return false
-  } else {
-    return true
-  }
-}
-
-export const mergeResults = (resultsOld: TResult, resultsNew: TResult) => {
-  const output = getResultDefaults()
-
-  output.failed = [...resultsOld.failed, ...resultsNew.failed]
-  output.errors = [...resultsOld.errors, ...resultsNew.errors]
-  output.missed = [...resultsOld.missed, ...resultsNew.missed]
-  output.passed = [...resultsOld.passed, ...resultsNew.passed]
-  output.byKeys = {...resultsOld.byKeys, ...resultsNew.byKeys}
-  output.errorsByKeys = {...resultsOld.errorsByKeys, ...resultsNew.errorsByKeys}
-
-  return output
-}
-
-export function handleReqKey(this: any, key: string, data: any, reqs: TSchemaInput, deepKey = key) {
-  let results = getResultDefaults()
-  const hasNested = checkIsNested(reqs)
-  const keyTitle = 'title' in reqs ? reqs.title : deepKey
-
-  const missedCheck: boolean[] = [];
-  const typeChecked: boolean[] = [];
-  const rulesChecked: boolean[] = [];
-
-  // If nested key is present but no data provided
-  // @ts-ignore
-  if (reqs.required && (
-    data === undefined || 
-    (_validations.isObject(data) && !Object.keys(data).length))
-  ) {
-    results.missed.push(deepKey)
-    results.failed.push(deepKey)
-    results.byKeys[deepKey] = false
-
-    return results
-  }
-
-  // Handle nested keys first
-  if (hasNested) {
-    const nestedReqKeys: string[] = Object.keys(reqs)
-    results.byKeys[deepKey] = true
-
-    let i = 0;
-    while (i < nestedReqKeys.length) {
-      const reqKeyI: string = nestedReqKeys[i]
-
-      const deepResults = handleReqKey.call(
-        this,
-        reqKeyI,
-        data[key],
-        // @ts-ignore
-        reqs[reqKeyI],
-        deepKey + '.' + reqKeyI
-      )
-
-      results = mergeResults(results, deepResults)
-
-      i++
-    }
-
-    return results
-  }
-
-  // Check missing keys
-  // @ts-ignore
-  if (reqs.required === true && key in data === false || data === undefined) {
-    let errMsg = _errors.getMissingError(deepKey)
-    
-    if (reqs.customMessage && typeof reqs.customMessage === 'function') {
-      // @ts-ignore
-      errMsg = reqs.customMessage({
-        keyword: ErrorKeywords.Missing,
-        value: data[key],
-        key: deepKey,
-        title: keyTitle,
-        reqs: reqs,
-        schema: this.schema
-      })
-    }
-
-    missedCheck.push(false)
-    results.missed.push(deepKey)
-    results.failed.push(deepKey)
-    results.errors.push(errMsg)
-    results.byKeys[deepKey] = false
-
-    return results
-  }
-
-  // Check value type
-  const typeCheck = checkType(key, data[key], reqs, deepKey);
-  
-  typeCheck.forEach(res => {
-    if (res.passed === false) {
-      typeChecked.push(res.passed)
-      results.errors.push(res.details)
-    }
-  })
-
-  // Check all rules
-  // @ts-ignore
-  const ruleCheck = checkRules.call(this, deepKey, data[key], reqs, data);
-
-  if (!ruleCheck.ok) {
-    rulesChecked.push(false)
-    ruleCheck.details.forEach((el) => {
-      if (deepKey in results.errorsByKeys) results.errorsByKeys[deepKey] = []
-
-      results.errors.push(el)
-      results.errorsByKeys[deepKey] = ['1']
-    })
-  }
-
-  // Combine final result
-  if (missedCheck.length) results.missed.push(deepKey)
-
-  if (typeChecked.length || rulesChecked.length) {
-    results.failed.push(deepKey)
-  } else {
-    results.passed.push(deepKey)
-  }
-
-  results.errorsByKeys[deepKey] = [
-    ...results.errors
-  ]
-
-  results.byKeys[deepKey] = (
-    missedCheck.length + typeChecked.length + rulesChecked.length
-  ) === 0
-
-  return results
-}
-
-const checkIfValidationIsNeeded = (key: string, hasLimits: boolean, onlyKeys?: string | string[]) => {
-  return !hasLimits || (key === onlyKeys || Array.isArray(onlyKeys) && onlyKeys?.includes(key))
-}
-
-function validate(schema: Schema, data: any, onlyKeys?: string | string[]): TResult {
-    let results: TResult = getResultDefaults()
-    const areKeysLimited = (Array.isArray(onlyKeys) && onlyKeys.length > 0) || (typeof onlyKeys === 'string' && onlyKeys.length > 0)
-
-    for (const [key, reqs] of Object.entries(schema.schema)) {
-      const isValidationRequired = checkIfValidationIsNeeded(key, areKeysLimited, onlyKeys)
-      
-      if (isValidationRequired) {
-        // @ts-ignore
-        const keyResult = handleReqKey.call(this, key, data, reqs)
-
-        results = mergeResults(results, keyResult)
-      }
-    }
-  
-    if (results.failed.length) results.ok = false
-    else results.ok = true
-    
-    return results;
-};
-
-export default validate;

package/tests/missing.test.js

@@ -1,131 +0,0 @@
-import {describe, expect, test} from '@jest/globals';
-import { Schema } from '../dist/Schema.js';
-import _errors from '../dist/utils/errors.js';
-
-describe('Тестирование обработки пропущенных свойста', () => {
-    test('Отсутствующий ключ правильно отображается в результате', () => {
-        const missedKey = 'testKey'
-        const missedKey2 = 'testKey2'
-
-        const okKey = 'okKey'
-
-        const scheme = new Schema({
-            [missedKey]: {
-                required: true,
-                type: String
-            },
-            [missedKey2]: {
-                required: true,
-                type: String
-            },
-            [okKey]: {
-                required: true,
-                type: String
-            }
-        })
-
-        const obj = {
-            [okKey]: 'string'
-        }
-
-        const result = scheme.validate(obj)
-
-        expect(result).toEqual({
-            ok: false,
-            failed: [missedKey, missedKey2],
-            missed: [missedKey, missedKey2],
-            errors: [
-                _errors.getMissingError(missedKey),
-                _errors.getMissingError(missedKey2)
-            ],
-            passed: [okKey],
-            byKeys: {
-                [missedKey]: false,
-                [missedKey2]: false,
-                [okKey]: true
-            },
-            errorsByKeys: {
-                [okKey]: [],
-                [missedKey]: [_errors.getMissingError(missedKey)],
-                [missedKey2]: [_errors.getMissingError(missedKey2)]
-            }
-        })
-    })
-
-    test('Присутствующий ключ правильно отображается в результате', () => {
-        const key = 'testKey'
-        const key2 = 'testKey2'
-
-        const scheme = new Schema({
-            [key]: {
-                required: true,
-                type: String
-            },
-            [key2]: {
-                required: true,
-                type: String
-            }
-        })
-
-        const obj = {
-            [key]: 'string',
-            [key2]: 'string'
-        }
-
-        const result = scheme.validate(obj)
-        
-        expect(result).toEqual({
-            ok: true,
-            failed: [],
-            missed: [],
-            errors: [],
-            passed: [key, key2],
-            byKeys: {
-                [key]: true,
-                [key2]: true
-            },
-            errorsByKeys: {
-                [key]: [],
-                [key2]: []
-            }
-        })
-    })
-
-    test('Отсутствующий необязательный ключ правильно отображается в результах', () => {
-        const key = 'testKey'
-        const key2 = 'testKey2'
-
-        const scheme = new Schema({
-            [key]: {
-                required: false,
-                type: String
-            },
-            [key2]: {
-                required: true,
-                type: String
-            }
-        })
-
-        const obj = {
-            [key2]: 'string'
-        }
-
-        const result = scheme.validate(obj)
-        
-        expect(result).toEqual({
-            ok: true,
-            failed: [],
-            missed: [],
-            errors: [],
-            passed: [key, key2],
-            byKeys: {
-                [key]: true,
-                [key2]: true
-            },
-            errorsByKeys: {
-                [key]: [],
-                [key2]: []
-            }
-        })
-    })
-})