valgen 3.2.0 → 4.0.0-alpha.2

package/lib/factories/ArrayFactory.js

@@ -1,148 +0,0 @@
-'use strict';
-const {AnyFactory} = require('./AnyFactory');
-const {coerceToInt, coerceToBoolean, coerceToArray, coalesce} = require('putil-varhelpers');
-
-class ArrayFactory extends AnyFactory {
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-        return coerceToArray(v);
-      case 'minItems':
-      case 'maxItems':
-        return coerceToInt(v);
-      case 'uniqueItems':
-        return coerceToBoolean(v);
-      case 'items':
-        return v;
-    }
-    return super.normalizeAttribute(attr, v);
-  }
-
-  set(target, attr, v, info) {
-    switch (attr) {
-      case 'default':
-        target.default = coerceToArray(v);
-        return;
-      case 'items': {
-        target.items = !v ? v :
-            v instanceof AnyFactory ? /* istanbul ignore next*/ v :
-                info.library.getType(v);
-        return;
-      }
-      case 'minItems':
-      case 'maxItems': {
-        target[attr] = coerceToInt(v);
-        return;
-      }
-      case 'uniqueItems':
-        target[attr] = coerceToBoolean(v);
-        return;
-    }
-    super.set(target, attr, v, info);
-  }
-
-  normalizeCompileOptions(options) {
-    const o = super.normalizeCompileOptions(options);
-    o.strictFormat = coerceToBoolean(options.strictFormat);
-    o.coerceTypes = coerceToBoolean(options.coerceTypes);
-    o.maxArrayErrors = coerceToInt(options.maxArrayErrors);
-    return o;
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    const minItems = coalesce(dataType.get('minItems'), dataType.options.minItems);
-    const maxItems = coalesce(dataType.get('maxItems'), dataType.options.maxItems);
-    const uniqueItems = coalesce(dataType.get('uniqueItems'), dataType.options.uniqueItems);
-    const items = dataType.get('items');
-    const strictFormat = coalesce(options.strictFormat,
-        dataType.get('strictFormat'), dataType.options.strictFormat);
-    const maxErrors = data.variables.maxErrors = options.maxArrayErrors;
-    const itemsValidator = data.variables.itemsValidator = items &&
-        items.generate(options);
-    if (strictFormat)
-      data.code += `
-    if (!Array.isArray(value))
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Value must be an array',
-            errorType: 'invalid-data-type'
-        });`;
-    data.code += `
-    const arr = Array.isArray(value) ? value : [value];`;
-
-    if (minItems)
-      data.code += `
-    if (arr.length < ${minItems})
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Minimum accepted array length is ${minItems}, actual ' + arr.length,
-            errorType: 'invalid-value-length',
-            min: ${minItems},                
-            actual: arr.length
-        });`;
-    if (maxItems) {
-      data.code += `
-    if (arr.length > ${maxItems})
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Maximum accepted array length is ${maxItems}, actual ' + arr.length,
-            errorType: 'invalid-value-length',
-            max: ${maxItems},               
-            actual: arr.length
-        });`;
-    }
-    const forIterator = itemsValidator || uniqueItems;
-    if (forIterator) {
-      data.code += `    
-    const itemsLen = arr.length;
-    ${maxErrors > 1 ? 'let numErrors = 0;' : ''}
-    ${itemsValidator && options.coerceTypes ? `   
-    const resultArray = [];
-    const lookupArray = resultArray;` : `
-    const lookupArray = arr;`}
-    ${itemsValidator ? 'const pathData = ctx.path;' : ''}
-
-    ${itemsValidator ? `
-    if (typeCheck) {
-      for (let i = 0; i < itemsLen; i++) {        
-        if (!itemsValidator(arr[i], ctx).valid)
-          return Failed;
-      }
-    }` : ''}
-
-    if (typeCheck) return;
-
-    for (let i = 0; i < itemsLen; i++) {
-      ${itemsValidator ? 'pathData.push(i);' : ''}
-      ${itemsValidator ? `        
-        let v = itemsValidator(arr[i], ctx);        
-        if (!v.valid) {          
-          ${maxErrors > 1 ?
-          'if (++numErrors >= maxErrors) return;' : 'return Failed;'}
-        } else v = v.value;        
-      ` : 'const v = arr[i];'}
-    `;
-      if (uniqueItems)
-        data.code += `
-        if (lookupArray.indexOf(v, i+1) >= 0) {                        
-            return ctx.logError({
-                message: 'Items must be unique',
-                errorType: 'unique-item-error'                               
-            });            
-      }`;
-      data.code += `
-        ${itemsValidator && options.coerceTypes ? 'resultArray.push(v);' : ''}
-      ${itemsValidator ? 'pathData.pop();' : ''}  
-    }`;
-    }
-
-    data.code += `    
-    if (typeCheck) return;`;
-
-    if (options.coerceTypes)
-      data.code += `            
-    ${itemsValidator ? 'value = resultArray;' : 'value = arr'}`;
-    return data;
-  }
-}
-
-module.exports = {ArrayFactory};

package/lib/factories/Base64Factory.d.ts

@@ -1,12 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace Base64Factory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: string;
-    }
-}
-
-export class Base64Factory extends AnyFactory {
-    schema: Base64Factory.ITypeSchema;
-}

package/lib/factories/Base64Factory.js

@@ -1,31 +0,0 @@
-'use strict';
-const {coerceToString} = require('putil-varhelpers');
-const {AnyFactory} = require('./AnyFactory');
-
-const Base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-
-class Base64Factory extends AnyFactory {
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-        return coerceToString(v);
-    }
-    return super.normalizeAttribute(attr, v);
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    data.variables.base64Pattern = Base64Pattern;
-
-    data.code += `        
-    if (!(typeof value === 'string' && value.match(base64Pattern)))
-      return typeCheck ? Failed : ctx.logError({
-          message: 'Value must be base64 encoded string',
-          errorType: 'invalid-data-type'
-      });`;
-    return data;
-  }
-}
-
-module.exports = {Base64Factory};

package/lib/factories/BooleanFactory.d.ts

@@ -1,12 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace BooleanFactory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: boolean;
-    }
-}
-
-export class BooleanFactory extends AnyFactory {
-    schema: BooleanFactory.ITypeSchema;
-}

package/lib/factories/BooleanFactory.js

@@ -1,49 +0,0 @@
-'use strict';
-const {coerceToBoolean, coalesce} = require('putil-varhelpers');
-const {AnyFactory} = require('./AnyFactory');
-
-class BooleanFactory extends AnyFactory {
-
-  normalizeCompileOptions(options) {
-    const o = super.normalizeCompileOptions(options);
-    o.strictFormat = coerceToBoolean(options.strictFormat);
-    o.coerceTypes = coerceToBoolean(options.coerceTypes);
-    return o;
-  }
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-        return coerceToBoolean(v);
-      case 'strictFormat':
-        return coerceToBoolean(v);
-    }
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    const strictFormat = coalesce(options.strictFormat, dataType.options.strictFormat);
-    data.code += `
-    if (!(typeof value === 'boolean'`;
-    if (!strictFormat)
-      data.code +=
-          ` || (value === 0 || value === 1 || value === 'false' || value === 'true')`;
-    data.code += `)
-    )
-      return typeCheck ? Failed : ctx.logError({
-          message: 'Value must be a boolean',
-          errorType: 'invalid-data-type'
-      });
-`;
-
-    data.code += `
-    if (typeCheck) return;`;
-
-    if (options.coerceTypes && !strictFormat)
-      data.code += '\n    value = value === \'false\' ? false : !!value';
-    return data;
-  }
-
-}
-
-module.exports = {BooleanFactory};

package/lib/factories/DateFactory.d.ts

@@ -1,40 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace DateFactory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: string;
-        format?: string;
-        fast?: boolean;
-    }
-    export interface IDateFormatMap {
-        date?: string,
-        datetime?: string,
-        timestamp?: string,
-        time?: string,
-        rfc2616?: string
-    }
-    export interface IOptions {
-        dateFormats?: IDateFormatMap;
-        format?: string;
-    }
-}
-
-
-export class DateFactory extends AnyFactory {
-
-    schema: DateFactory.ITypeSchema;
-    format?: string;
-    dateFormats: DateFactory.IDateFormatMap;
-
-    TIMESTAMP_PATTERN: RegExp;
-    TIMESTAMP_STRICT_PATTERN: RegExp;
-    DATETIME_PATTERN: RegExp;
-    DATETIME_STRICT_PATTERN: RegExp;
-    DATE_PATTERN: RegExp;
-    DATE_STRICT_PATTERN: RegExp;
-    TIME_PATTERN: RegExp;
-    TIME_STRICT_PATTERN: RegExp;
-
-    constructor(options?: DateFactory.IOptions);
-}

package/lib/factories/DateFactory.js

@@ -1,239 +0,0 @@
-'use strict';
-
-const {AnyFactory} = require('./AnyFactory');
-const {coalesce, coerceToBoolean, coerceToString} = require('putil-varhelpers');
-
-class DateFactory extends AnyFactory {
-
-  constructor(options) {
-    super();
-    this.TIMESTAMP_PATTERN =
-        /^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?(?:T?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
-    this.TIMESTAMP_STRICT_PATTERN =
-        /^(\d{4})-(0[1-9]|1[012])-([123]0|[012][1-9]|31)T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.?(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):([0-5][0-9])))$/;
-    this.DATETIME_PATTERN =
-        /^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?(?:T?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.?(\d+))?)?$/;
-    this.DATETIME_STRICT_PATTERN =
-        /^(\d{4})-(0[1-9]|1[012])-([123]0|[012][1-9]|31)T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.?(\d+))?$/;
-    this.DATE_PATTERN =
-        /^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?$/;
-    this.DATE_STRICT_PATTERN =
-        /^(\d{4})-(0[1-9]|1[012])-([123]0|[012][1-9]|31)$/;
-    this.TIME_PATTERN =
-        /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?$/;
-    this.TIME_STRICT_PATTERN =
-        /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])?(?:\.(\d+))?$/;
-    this.dateFormats = (options && options.dateFormats) || {
-      'date': 'date',
-      'datetime': 'datetime',
-      'timestamp': 'timestamp',
-      'time': 'time',
-      'rfc2616': 'rfc2616'
-    };
-    this.format = options && options.format;
-  }
-
-  normalizeCompileOptions(options) {
-    const o = super.normalizeCompileOptions(options);
-    o.strictFormat = coerceToBoolean(options.strictFormat);
-    o.coerceTypes = coerceToBoolean(options.coerceTypes);
-    o.convertDates = coerceToBoolean(options.convertDates);
-    return o;
-  }
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-        return coerceDateOrString(v);
-      case 'format':
-        if (v && !this.dateFormats[v])
-          throw new TypeError(`Unknown date format (${v})`);
-        return coerceToString(v);
-      case 'strictFormat':
-        return coerceToBoolean(v);
-      case 'fast':
-        return coerceToBoolean(v);
-    }
-  }
-
-  _generateValidationCode(type, options) {
-    const data = super._generateValidationCode(type, options);
-    const convertDates = options.convertDates;
-    const coerceTypes = options.coerceTypes || convertDates;
-    const formatName = type.get('format') || this.format || 'timestamp';
-    const format = this.dateFormats[formatName] || formatName;
-
-    const fastDateValidation = type.get('fast') && !convertDates &&
-        format !== 'rfc2616';
-    const strictFormat = coalesce(options.strictFormat, type.get('strictFormat'));
-    const matchDatePattern = this._getMatchDatePatternFn(format, strictFormat);
-    const dateItemsToISO = this._getFormatDateItemsFn('timestamp');
-    const formatDate = this._getFormatDateFn(format);
-    const formatDateItems = this._getFormatDateItemsFn(format);
-    data.code += `
-    if (!(value instanceof Date || typeof value === 'string'))
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Value must be ${formatName} formatted string or Date instance',
-            errorType: 'invalid-data-type'          
-        });`;
-    data.code += `
-    let d;
-    let m;    
-    if (typeof value === 'string') {`;
-    if (format === 'rfc2616') {
-      if (strictFormat) {
-        data.code += `                
-        d = String(value).match(/^[A-Za-z]/) && new Date(value);`;
-      } else
-        data.code += `      
-        m = matchDatePattern(value);  
-        d = new Date(m ? dateItemsToISO(m) : value);`;
-    } else
-      data.code += `       
-        m = matchDatePattern(value);
-        if (!m)
-            return typeCheck ? Failed : ctx.logError({
-                message: 'Value must be ${formatName} formatted string or Date instance',
-                errorType: 'invalid-data-type'
-            });
-        ${fastDateValidation ?
-          `return ${coerceTypes ? 'formatDateItems(m)' : 'value'};` :
-          `d = new Date(dateItemsToISO(m));
-        d = isValidDate(d) && parseInt((m[3]||'01'), 10) === d.getUTCDate() ? d : null;`}
-`;
-    data.code += `
-    } else d = value;    
-    if (!isValidDate(d))
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Value must be ${formatName} formatted string or Date instance',
-            errorType: 'invalid-data-type'
-        });`;
-
-    data.code += `    
-    if (typeCheck) return;`;
-
-    if (convertDates)
-      data.code += '\n    value = d;';
-    else if (coerceTypes) {
-      data.code += '\n    value = m ? formatDateItems(m) : formatDate(d);';
-    }
-    data.variables = {
-      ...data.variables,
-      isValidDate,
-      matchDatePattern, formatDateItems, formatDate,
-      dateItemsToISO,
-    };
-    return data;
-  }
-
-  _getFormatDateFn(format) {
-    switch (format) {
-      case 'date':
-        return (d) => {
-          const s = d.toISOString();
-          return s.substring(0, 10);
-        };
-      case 'datetime':
-        return (d) => {
-          const s = d.toISOString();
-          return s.substring(0, s.length - 1);
-        };
-      case 'time':
-        return (d) => {
-          let s = d.toISOString();
-          return s.endsWith('.000Z') ?
-              s.substring(11, s.length - 5) : s.substring(11, s.length - 1);
-        };
-      case 'timestamp':
-        return (d) => d.toISOString();
-      case 'rfc2616':
-        /* istanbul ignore next : Timezone obstructs testing */
-        return (d) => d.toString();
-    }
-  }
-
-  _getFormatDateItemsFn(format) {
-    let src = `  const v = `;
-    if (format === 'rfc2616' || format === 'date' ||
-        format === 'datetime' || format === 'timestamp') {
-      src += `
-    // Date part
-    m[1] + '-' + (m[2]||'01') + '-' + (m[3]||'01')`;
-    }
-    if (format === 'rfc2616' || format === 'datetime' ||
-        format === 'timestamp') {
-      src += ` +
-    // Time part
-    'T'`;
-    }
-    if (format === 'rfc2616' || format === 'datetime' ||
-        format === 'timestamp' || format === 'time') {
-      src += `+ (m[4] || '00') + ':' + (m[5] || '00') + ':' + (m[6] || '00') + 
-    // Millisecond
-    (m[7] ? '.' + m[7] : '')`;
-    }
-    if (format === 'rfc2616' || format === 'timestamp') {
-      src += `+
-    // Time zone
-    (m[9] ? (m[9] + (m[10] || '00') + ':' + (m[11] || '00')) : 'Z')`;
-    }
-    if (format === 'rfc2616') {
-      src += ';\n  return new Date(v).toString()';
-    } else src += ';\n  return v;';
-    return new Function('m', src);
-  }
-
-  _getMatchDatePatternFn(format, strict) {
-    if (format === 'time') {
-      return (v) => {
-        const m = v.match(strict ? this.TIME_STRICT_PATTERN : this.TIME_PATTERN);
-        return m && [v, '1970', '01', '01', ...m.slice(1)];
-      };
-    }
-    let src = `
-  return (v) => {
-    const m = v.match(pattern);
-    if (!m || (m[2] === '02' && m[3] > '29'))
-      return;
-`;
-    if (!strict) {
-      if (format === 'date')
-        src += '    m[4]=null;m[5]=null;m[6]=null;m[7]=null;\n';
-      if (format === 'date' || format === 'datetime')
-        src += '    m[8]=null;m[9]=null;m[10]=null;m[11]=null;\n';
-    }
-    src += `
-    return m;
-  }`;
-    let pattern;
-    switch (format) {
-      case 'datetime':
-        pattern = strict ? this.DATETIME_STRICT_PATTERN :
-            this.DATETIME_PATTERN;
-        break;
-      case 'date':
-        pattern = strict ? this.DATE_STRICT_PATTERN :
-            this.DATE_PATTERN;
-        break;
-      default:
-        pattern = strict ?
-            this.TIMESTAMP_STRICT_PATTERN :
-            this.TIMESTAMP_PATTERN;
-    }
-    return new Function('pattern', src)(pattern);
-  }
-
-}
-
-function isValidDate(d) {
-  return d && !isNaN(d.getTime());
-}
-
-function coerceDateOrString(v) {
-  if (v && !(typeof v === 'string' || v instanceof Date))
-    throw new TypeError(`"${v}" is not a string or Date instance`);
-  return v;
-}
-
-module.exports = {DateFactory};
-

package/lib/factories/FunctionFactory.d.ts

@@ -1,12 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace FunctionFactory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: Function;
-    }
-}
-
-export class FunctionFactory extends AnyFactory {
-    schema: FunctionFactory.ITypeSchema;
-}

package/lib/factories/FunctionFactory.js

@@ -1,28 +0,0 @@
-'use strict';
-const {AnyFactory} = require('./AnyFactory');
-
-class FunctionFactory extends AnyFactory {
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-        if (v && typeof v !== 'function')
-          throw new TypeError(`"${v}" is not a Function`);
-        return v;
-    }
-    return super.normalizeAttribute(attr, v);
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    data.code += `
-    if (typeof value !== 'function')
-      return typeCheck ? Failed : ctx.logError({
-          message: 'Value must be a function',
-          errorType: 'invalid-data-type'
-      });`;
-    return data;
-  }
-}
-
-module.exports = {FunctionFactory};

package/lib/factories/IntegerFactory.d.ts

@@ -1,14 +0,0 @@
-import {NumberFactory} from './NumberFactory';
-
-export namespace IntegerFactory {
-    export interface IOptions extends NumberFactory.IOptions {
-        format?: NumberFactory.IntegerFormatType;
-    }
-}
-
-export class IntegerFactory extends NumberFactory {
-
-    format?: NumberFactory.IntegerFormatType;
-
-    constructor(options?: IntegerFactory.IOptions);
-}

package/lib/factories/IntegerFactory.js

@@ -1,33 +0,0 @@
-'use strict';
-const {coerceToInt, mapDistinct} = require('putil-varhelpers');
-const {NumberFactory, IntegerFormats} = require('./NumberFactory');
-
-class IntegerFactory extends NumberFactory {
-
-  create(instance) {
-    instance.options.format = 'int32';
-  }
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-      case 'minimum':
-      case 'maximum':
-      case 'multipleOf':
-        return coerceToInt(v);
-      case 'enum':
-        if (!Array.isArray(v))
-          throw new TypeError(`"${v}" is not an array value.`);
-        return mapDistinct(v, coerceToInt);
-      case 'format': {
-        if (v && !IntegerFormats.includes(v))
-          throw new TypeError(`"${v}" is not a valid integer format identifier.`);
-        return v;
-      }
-    }
-    return super.normalizeAttribute(attr, v);
-  }
-
-}
-
-module.exports = {IntegerFactory};

package/lib/factories/NilFactory.d.ts

@@ -1,4 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-
-export class NilFactory extends AnyFactory {
-}

package/lib/factories/NilFactory.js

@@ -1,20 +0,0 @@
-'use strict';
-const {AnyFactory} = require('./AnyFactory');
-
-class NilFactory extends AnyFactory {
-
-  normalizeAttribute(attr, v) {
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    data.code = '    if (value === undefined) value = null;' + data.code + `
-    return typeCheck ? Failed : ctx.logError({
-        message: 'Value must be null',
-        errorType: 'invalid-data-type'
-    }); `;
-    return data;
-  }
-}
-
-module.exports = {NilFactory};

package/lib/factories/NumberFactory.d.ts

@@ -1,36 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace NumberFactory {
-    export type IntegerFormatType = 'int64' | 'bigint' | 'int32' | 'int' | 'int16' | 'int8' |
-        'uint64' | 'uint32' | 'uint16' | 'uint8' | 'long' | 'float';
-    export type FloatFormatType = 'float' | 'double';
-    export type NumberFormatType = IntegerFormatType | FloatFormatType;
-
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: number;
-        enum?: number[];
-        minimum?: number;
-        maximum?: number;
-        multipleOf?: number;
-        strictFormat?: boolean;
-    }
-
-    export interface IOptions {
-        format?: NumberFormatType;
-    }
-
-}
-
-export const NumberFormats: string[];
-export const IntegerFormats: string[];
-export const MinValues: { [format: string]: number };
-export const MaxValues: { [format: string]: number };
-
-export class NumberFactory extends AnyFactory {
-    schema: NumberFactory.ITypeSchema;
-    format?: NumberFactory.NumberFormatType;
-
-    constructor(options?: NumberFactory.IOptions);
-
-}