valgen 3.2.1 → 4.0.0-alpha.2

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

package/lib/factories/ObjectFactory.js

@@ -1,326 +0,0 @@
-'use strict';
-
-const {coalesce, coerceToString, coerceToInt, coerceToBoolean} = require('putil-varhelpers');
-const {AnyFactory} = require('./AnyFactory');
-
-class ObjectFactory extends AnyFactory {
-
-  normalizeCompileOptions(options) {
-    const o = super.normalizeCompileOptions(options);
-    o.coerceTypes = coerceToBoolean(options.coerceTypes);
-    o.removeAdditional = coerceToBoolean(options.removeAdditional);
-    o.removeNull = coerceToBoolean(options.removeNull);
-    o.maxObjectErrors = coerceToInt(options.maxObjectErrors);
-    o.operation = coerceToString(options.operation);
-    return o;
-  }
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'discriminator':
-        return coerceToString(v);
-      case 'discriminatorValue':
-      case 'additionalProperties':
-        return v;
-      case 'minProperties':
-      case 'maxProperties':
-        return coerceToInt(v);
-      case 'isTypeOf':
-        if (v && typeof v !== 'function')
-          throw new TypeError('Value must be a Function.');
-        return v;
-      case 'properties':
-        return v;
-    }
-    return super.normalizeAttribute(attr, v);
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    const maxErrors = data.variables.maxErrors = options.maxObjectErrors || 0;
-    const propOptions = maxErrors > 1 ? {
-      ...options,
-      throwOnError: false
-    } : options;
-
-    // Merge all properties together
-    const properties = {};
-    const mergeProperties = (dt) => {
-      if (dt.predecessors) {
-        for (const t of dt.predecessors) {
-          mergeProperties(t);
-        }
-      }
-      if (dt.properties) {
-        for (const [k, p] of Object.entries(dt.properties)) {
-          properties[k] = p;
-        }
-      }
-    };
-    mergeProperties(dataType);
-
-    const propertyKeys = (properties && Object.keys(properties)) || [];
-    let propFns;
-    let rxproperties;
-    if (propertyKeys.length) {
-      data.variables.propertyKeys = propertyKeys;
-      propFns = data.variables.properties = {};
-      rxproperties = data.variables.rxproperties = [];
-      for (const k of propertyKeys) {
-        const property = properties[k];
-        const required = property.required != null ? property.required :
-            (dataType.options.required != null ?
-                dataType.options.required : true);
-        const fn = property.generate(propOptions);
-        const m = k.match(/^\/(.*)\/$/);
-        const regexp = m && new RegExp(m[1]);
-        propFns[k] = {
-          property,
-          fn,
-          required,
-          regexp
-        };
-        if (regexp)
-          rxproperties.push(propFns[k]);
-      }
-    }
-
-    const discriminator = data.variables.discriminator =
-        dataType.get('discriminator');
-    if (discriminator)
-      data.variables.discriminatorValue =
-          dataType.get('discriminatorValue') || dataType.name;
-
-    const isTypeOf = dataType.get('isTypeOf');
-    if (isTypeOf)
-      data.variables.isTypeOf = isTypeOf;
-
-    const library = dataType.library;
-
-    let additionalProperties = coalesce(
-        dataType.get('additionalProperties'),
-        dataType.options.additionalProperties, true);
-    additionalProperties = !propertyKeys.length ||
-        (!options.removeAdditional && additionalProperties);
-
-    if (typeof additionalProperties !== 'boolean')
-      additionalProperties =
-          library.getType(additionalProperties)
-              .generate({...propOptions, strictFormat: true});
-
-    data.variables.additionalProperties = additionalProperties;
-    data.variables.operation = options.operation;
-    data.variables.removeNull = options.removeNull;
-    const minProperties = dataType.get('minProperties');
-    const maxProperties = dataType.get('maxProperties');
-
-    const needResult = options.coerceTypes ||
-        options.removeAdditional || options.removeNull;
-
-    data.code += `
-    if (typeof value !== 'object' || Array.isArray(value)) {        
-        return typeCheck ? Failed : 
-            ctx.logError({
-                message: 'Value must be an object',
-                errorType: 'invalid-data-type'
-            }
-        );
-    }`;
-
-    if (isTypeOf)
-      data.code += `
-    if (!isTypeOf(value, dataType)) {        
-        return typeCheck ? Failed : 
-            ctx.logError({
-                message: 'Value does not match to'+
-                    (name ? 'to "' + name + '"' : ''),
-                errorType: 'invalid-data-type'
-            });
-    }`;
-
-    if (discriminator) {
-      data.code += `
-    if (value[discriminator] !== discriminatorValue) {        
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Value is not a type of "' + discriminatorValue + '"',
-            errorType: 'invalid-data',            
-            discriminatorValue,
-            actual: value[discriminator],
-        });        
-    }
-    if (typeCheck) return 1;`;
-    }
-
-    if (!additionalProperties || minProperties || maxProperties || propFns)
-      data.code += `    
-    const valueKeys = Object.keys(value);`;
-
-    if (!discriminator && propFns) {
-      data.code += `
-    if (typeCheck) {
-      let matchedCount = 0;
-      const xctx = {...ctx};     
-      for (let i = 0; i < ${propertyKeys.length}; i++) {
-        const k = propertyKeys[i];
-        const p = properties[k];
-        const regexp = p.regexp;       
-        if (regexp) {
-          xctx.name = k;
-          const len = valueKeys.length;
-          let h = 0;
-          for (let j = 0; j < len; j ++) {
-            if (valueKeys[j].match(regexp) && 
-                p.fn(value[valueKeys[j]], xctx).valid)
-              h++;
-          }
-          matchedCount += (h / len);    
-          continue;
-        } else if (value.hasOwnProperty(k)) {
-          xctx.name = k;
-          if (p.fn(value[k], xctx).valid)
-            matchedCount++;
-        } else
-          if (p.required && (!Array.isArray(p.required) || p.required.includes(operation))) 
-            return Failed;               
-      }      
-      return matchedCount / ${propertyKeys.length};  
-    }
-    `;
-    }
-
-    data.code += `    
-    if (typeCheck) return;
-    let numErrors = 0;
-    ${needResult ? 'const result = {};' : ''}`;
-
-    if (minProperties) {
-      data.code += `
-    if (valueKeys.length < ${minProperties}) {        
-        return ctx.logError({
-            message: 'Minimum accepted properties is ${minProperties}, actual ' + valueKeys.length, 
-            errorType: 'invalid-value-length',
-            min: ${minProperties},
-            actual: valueKeys.length
-        });
-    }`;
-    }
-    if (maxProperties)
-      data.code += `
-    if (valueKeys.length > ${maxProperties}) {        
-        return ctx.logError({
-            message: 'Maximum allowed properties is ${maxProperties}, actual ' + valueKeys.length, 
-            errorType: 'invalid-value-length',
-            max: ${maxProperties},
-            actual: valueKeys.length
-        });
-    }`;
-
-    if (!propFns && additionalProperties === true) {
-      data.code += `
-    ${needResult ? 'return value;' : 'return;'}`;
-    }
-
-    // Iterate over value properties than iterate over type properties
-    if (propFns) {
-      data.code += `                  
-    const _logError = (...args) => {
-      numErrors++;
-      return ctx.logError(...args);
-    };
-                
-    const xprops = Object.assign({}, properties);
-    let keysLen = valueKeys.length;
-    const xctx = {...ctx, logError: _logError}
-    const path = ctx.path;
-    for (let i = 0; i < keysLen; i++) {
-      const k = valueKeys[i];
-      const p = properties[k] || (
-          rxproperties.length &&
-          rxproperties.find(x=> k.match(x.regexp)))      
-      let vv;                           
-      if (p) {          
-          delete xprops[k];
-          xctx.name = k;
-          path.push(k);
-          vv = p.fn(value[k], xctx);
-          ${maxErrors > 1 ? 'if (numErrors >= maxErrors) return Failed;' : ''}
-          if (!vv.valid) vv = Failed;${needResult ? ' else vv = vv.value;' : ''};
-          path.pop();
-      }`;
-
-      if (additionalProperties) {
-        if (typeof additionalProperties === 'function') {
-          data.code += ` else {
-          path.push(k);
-          xctx.name = k;         
-          xctx.typeCheck = true;
-          vv = additionalProperties(value[k], {...xctx, typeCheck: true});
-          xctx.typeCheck = undefined;
-          if (!vv.valid) vv = Failed;${needResult ? 'else vv = vv.value;' : ''}        
-          path.pop();            
-      }`;
-        } else if (needResult)
-          data.code += ' else vv = value[k]';
-      } else if (!options.removeAdditional)
-        data.code += ' else vv = Failed;';
-
-      data.code += `
-      if (!p && vv === Failed) {
-          path.push(k);                 
-          ctx.logError({
-                  message: 'Additional property "' + k + '" is not allowed.',
-                  errorType: 'no-additional-allowed'
-              }
-          );
-          ${propFns && maxErrors > 1 ?
-          'if (++numErrors >= maxErrors) return Failed;' : 'return Failed;'}
-          path.pop();
-      }`;
-
-      if (needResult)
-        data.code += `        
-      if (vv !== undefined && vv !== Failed && (vv != null || !removeNull)) result[k] = vv;`;
-      data.code += `
-    }
-      
-    const keys = Object.keys(xprops);
-    keysLen = keys.length;
-    for (let i = 0; i < keysLen; i++) {
-      const k = keys[i];
-      const p = xprops[k];
-      if (p.regexp)
-        continue;
-      let vv = value[k];
-      path.push(k);         
-      if (!removeNull && vv == null && 
-          p.required && (!Array.isArray(p.required) || p.required.includes(operation))
-      ) {                 
-         ctx.logError({
-                  message: 'Value required.',
-                  errorType: 'value-required'
-              }
-         );         
-         ${maxErrors > 1 ?
-          'if (++numErrors >= maxErrors) return Failed;' : 'return Failed;'}
-      }         
-      xctx.name = k;
-      vv = p.fn(vv, xctx);
-      if (!vv.valid) {
-        ${maxErrors > 1 ?
-          'if (numErrors >= maxErrors) return Failed;' :
-          'return Failed;'}
-      }${needResult ? `
-      vv = vv.value;
-      if (vv !== undefined && (vv != null || !removeNull)) result[k] = vv;` : ''}
-      path.pop();                    
-    }
-      `;
-    }
-    if (needResult)
-      data.code += '\n    value = !numErrors ? result: undefined;';
-
-    return data;
-  }
-}
-
-module.exports = {ObjectFactory};

package/lib/factories/StringFactory.d.ts

@@ -1,16 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace StringFactory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: string;
-        enum?: string[];
-        pattern?: string;
-        minLength?: number;
-        maxLength?: number;
-    }
-}
-
-export class StringFactory extends AnyFactory {
-    schema: StringFactory.ITypeSchema;
-}

package/lib/factories/StringFactory.js

@@ -1,94 +0,0 @@
-'use strict';
-const {
-  coalesce, coerceToBoolean, coerceToString, coerceToInt, mapDistinct
-} = require('putil-varhelpers');
-const {AnyFactory} = require('./AnyFactory');
-
-class StringFactory 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':
-      case 'pattern':
-        return coerceToString(v);
-      case 'enum':
-        if (!Array.isArray(v))
-          throw new TypeError(`"${v}" is not an array value.`);
-        return mapDistinct(v, coerceToString);
-      case 'minLength':
-      case 'maxLength':
-        return coerceToInt(v);
-    }
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    const strictFormat = coalesce(options.strictFormat,
-        dataType.get('strictFormat'), dataType.options.strictFormat);
-    const pattern = coalesce(dataType.get('pattern'), dataType.options.pattern);
-    if (pattern)
-      data.variables.pattern = new RegExp(pattern);
-    const minLength = coalesce(dataType.get('minLength'), dataType.options.minLength);
-    const maxLength = coalesce(dataType.get('maxLength'), dataType.options.maxLength);
-
-    data.code += `
-    if (!(typeof value === 'string'`;
-    if (!strictFormat)
-      data.code +=
-          ` || typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint'`;
-
-    data.code += `)
-    ) {
-      return typeCheck ? Failed : ctx.logError({
-            message: 'Value must be a string',
-            errorType: 'invalid-data-type'
-      });
-    }  
-    const v = ''+ value;`;
-
-    if (pattern)
-      data.code += `
-    if (!v.match(pattern))
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Value does not match required format',
-            errorType: 'invalid-value-format'
-        });`;
-
-    data.code += `    
-    if (typeCheck) return;`;
-
-    if (minLength != null)
-      data.code += `
-    if (v.length < ${minLength}) {       
-        return ctx.logError({
-            message: 'Minimum accepted length is ${minLength}, actual ' + v.length, 
-            errorType: 'invalid-value-length',
-            min: ${minLength},                
-            actual: v.length
-        });
-    }`;
-
-    if (maxLength)
-      data.code += `
-    if (v.length > ${maxLength})
-        return ctx.logError({
-            message: 'Maximum accepted length is ${maxLength}, actual ' + v.length,  
-            errorType: 'invalid-value-length',
-            max: ${maxLength},               
-            actual: v.length
-        });`;
-
-    if (options.coerceTypes)
-      data.code += '\n    value = v;';
-    return data;
-  }
-}
-
-module.exports = {StringFactory};

package/lib/factories/UnionFactory.d.ts

@@ -1,13 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace UnionFactory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        anyOf?: Array<string | Valgen.ITypeSchema>;
-    }
-}
-
-export class UnionFactory extends AnyFactory {
-    schema: UnionFactory.ITypeSchema;
-    anyOf?: AnyFactory[];
-}