valgen 3.2.1 → 4.0.0-alpha.3

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);
-
-}

package/lib/factories/NumberFactory.js

@@ -1,178 +0,0 @@
-'use strict';
-const {coerceToBoolean, coerceToNumber, coalesce, mapDistinct} = require('putil-varhelpers');
-const {AnyFactory} = require('./AnyFactory');
-
-const MinValues = {
-  int64: null,
-  bigint: null,
-  int32: -2147483648,
-  int: -9007199254740991,
-  int16: -32768,
-  int8: -128,
-  long: 0,
-  uint64: 0,
-  uint32: 0,
-  uint16: 0,
-  uint8: 0
-};
-
-const MaxValues = {
-  int64: null,
-  bigint: null,
-  int32: 2147483647,
-  int: 9007199254740991,
-  int16: 32767,
-  int8: 127,
-  long: null,
-  uint64: null,
-  uint32: 4294967295,
-  uint16: 65535,
-  uint8: 255
-};
-
-const IntegerFormats = ['int64', 'bigint', 'int32', 'int', 'int16', 'int8',
-  'uint64', 'uint32', 'uint16', 'uint8', 'long'];
-const NumberFormats = [...IntegerFormats, 'float', 'double'];
-
-class NumberFactory extends AnyFactory {
-
-  constructor(options) {
-    super();
-    this.format = options && options.format;
-  }
-
-  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':
-      case 'minimum':
-      case 'maximum':
-      case 'multipleOf':
-        return coerceToNumber(v);
-      case 'enum':
-        if (!Array.isArray(v))
-          throw new TypeError(`"${v}" is not an array value.`);
-        return mapDistinct(v, coerceToNumber);
-      case 'format': {
-        if (v && !NumberFormats.includes(v))
-          throw new TypeError(`"${v}" is not a valid number format identifier.`);
-        return v;
-      }
-      case 'strictFormat':
-        return coerceToBoolean(v);
-    }
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    const format = coalesce(dataType.get('format'), dataType.options.format, this.format);
-    const bigFormat = ['bigint', 'int64', 'uint64', 'long'].includes(format);
-    /* istanbul ignore next */
-    if (bigFormat && !global.BigInt)
-      throw new Error('Your JavaScript version does not support BigInt values');
-    const intFormat = IntegerFormats.includes(format);
-
-    const strictFormat = coalesce(options.strictFormat,
-        dataType.get('strictFormat'), dataType.options.strictFormat);
-    let minimum = coalesce(dataType.get('minimum'), dataType.options.minimum,
-        MinValues[format]);
-    let maximum = coalesce(dataType.get('maximum'), dataType.options.maximum,
-        MaxValues[format]);
-    const multipleOf = coalesce(dataType.get('multipleOf'), dataType.options.multipleOf);
-
-    data.variables.errorMsg1 = 'Value must be ' +
-        (intFormat ? 'an integer' : 'a number') +
-        (strictFormat ? '' : ' or ' +
-            (intFormat ? 'integer' : 'number') +
-            ' formatted string');
-
-    data.code += `
-    if (!((typeof value === 'number' || typeof value === 'bigint')`;
-    if (!strictFormat)
-      data.code += ` || (typeof value === 'string' && value)`;
-    data.code += `)
-    ) 
-      return typeCheck ? Failed : ctx.logError({
-          message: errorMsg1,
-          errorType: 'invalid-data-type'
-      });
-`;
-
-    data.code += `
-    let n;
-    try {
-        n = ${bigFormat ? 'BigInt(value)' : 'Number(value)'};
-    } catch (e) {
-        return typeCheck ? Failed : ctx.logError({
-            message: errorMsg1,
-            errorType: 'invalid-data-type'
-        });
-    }
-
-    if (!(typeof n === 'bigint' || !isNaN(n))) {
-        return typeCheck ? Failed : ctx.logError({
-            message: errorMsg1,
-            errorType: 'invalid-data-type'
-        });
-    }
-`;
-    if (intFormat)
-      data.code += `
-    if (typeof n === 'number' && (n - Math.floor(n) > 0)) {
-        return typeCheck ? Failed : ctx.logError({
-            message: errorMsg1,
-            errorType: 'invalid-data-type'
-        });
-    }
-`;
-
-    data.code += `    
-    if (typeCheck) return;`;
-
-    if (multipleOf)
-      data.code += `
-    const c = typeof n === 'bigint' ?
-        n / BigInt(${multipleOf}) * BigInt(${multipleOf}) :
-        Math.trunc(n / ${multipleOf}) * ${multipleOf};
-    if (n !== c)
-        return ctx.logError({
-            message: 'Numeric value must be multiple of ${multipleOf}',
-            errorType: 'invalid-value'
-        });`;
-    if (minimum != null)
-      data.code += `
-    if (n < ${minimum})
-        return ctx.logError({
-            message: 'Minimum accepted value is ${minimum}, actual ' + n,
-            errorType: 'range-error',
-            min: ${minimum},
-            actual: n
-        });`;
-    if (maximum)
-      data.code += `
-    if (n > ${maximum})
-        return ctx.logError({
-            message: 'Maximum accepted value is ${maximum}, actual ' + n,
-            errorType: 'range-error',
-            max: ${maximum},
-            actual: n
-        });`;
-    if (options.coerceTypes)
-      data.code += '\n    value = n;';
-    return data;
-  }
-}
-
-module.exports = {
-  NumberFactory,
-  NumberFormats,
-  IntegerFormats,
-  MinValues,
-  MaxValues
-};

package/lib/factories/ObjectFactory.d.ts

@@ -1,38 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-import {DataType} from '../DataType';
-
-export namespace ObjectFactory {
-    export interface IPropertySchema extends Valgen.ITypeSchema {
-        required?: boolean;
-    }
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        discriminator?: string;
-        discriminatorValue?: any;
-        additionalProperties?: boolean;
-        minProperties?: number;
-        maxProperties?: number;
-        isTypeOf: (value: any, t: ObjectFactory) => boolean;
-        properties: {
-            [index: string]: IPropertySchema;
-        };
-    }
-    export interface IOptions {
-        required?: boolean;
-        additionalProperties?: boolean;
-    }
-}
-
-export class ObjectFactory extends AnyFactory {
-    schema: ObjectFactory.ITypeSchema;
-    options: {
-        required?: boolean;
-        additionalProperties?: boolean;
-    };
-    properties: {
-        [index: string]: DataType;
-    };
-
-    constructor(options?: ObjectFactory.IOptions);
-
-}