valgen 3.2.1 → 4.0.0-alpha.3

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[];
-}

package/lib/factories/UnionFactory.js

@@ -1,62 +0,0 @@
-'use strict';
-const {AnyFactory} = require('./AnyFactory');
-
-class UnionFactory extends AnyFactory {
-
-  normalizeCompileOptions(options) {
-    return options;
-  }
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'anyOf':
-        if (v && !Array.isArray(v))
-          throw new TypeError('Value must be an array');
-        if (v && v.length < 2)
-          throw new TypeError('Value must contain at least 2 items');
-        return v;
-      default:
-        return v;
-    }
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = super._generateValidationCode(dataType, options);
-    const anyOf = dataType.get('anyOf');
-    data.variables.subValidators =
-        anyOf.map(t => t.generate(options));
-
-    data.code += `    
-    const len = subValidators.length;
-    let bestFn;
-    let bestRank = 0;   
-    for (let i = 0; i < len; i++) {
-      const fn = subValidators[i];
-      let rank = fn(value, {...ctx, typeCheck: true});
-      if (!rank.valid)
-        continue;
-      rank = rank.value;  
-      if (rank === undefined || rank > bestRank) {
-        bestFn = fn;
-        if (rank === 1 || rank === undefined)        
-          break;
-        bestRank = rank;  
-      }        
-    }
-
-    if (!bestFn) {      
-      return ctx.logError({
-        message: 'Value does not match any of expected types.',
-        errorType: 'no-type-matched'
-      });
-    }  
-    const vv = bestFn(value, ctx);
-    if (vv.valid)
-      return vv.value;        
-    `;
-    return data;
-  }
-
-}
-
-module.exports = {UnionFactory};

package/lib/index.d.ts

@@ -1,19 +0,0 @@
-import {Valgen} from './Valgen';
-export function vg(options?: Valgen.IOptions): Valgen;
-export default vg;
-
-export * from './Valgen';
-export * from './factories/AnyFactory';
-export * from './factories/ArrayFactory';
-export * from './factories/BooleanFactory';
-export * from './factories/DateFactory';
-export * from './factories/IntegerFactory';
-export * from './factories/NilFactory';
-export * from './factories/NumberFactory';
-export * from './factories/ObjectFactory';
-export * from './factories/StringFactory';
-export * from './factories/UnionFactory';
-export * from './factories/FunctionFactory';
-export * from './factories/Base64Factory';
-
-declare module "vg";

package/lib/index.js

@@ -1,37 +0,0 @@
-const {Valgen} = require('./Valgen');
-const {AnyFactory} = require('./factories/AnyFactory');
-const {ArrayFactory} = require('./factories/ArrayFactory');
-const {BooleanFactory} = require('./factories/BooleanFactory');
-const {DateFactory} = require('./factories/DateFactory');
-const {IntegerFactory} = require('./factories/IntegerFactory');
-const {NilFactory} = require('./factories/NilFactory');
-const {NumberFactory} = require('./factories/NumberFactory');
-const {ObjectFactory} = require('./factories/ObjectFactory');
-const {StringFactory} = require('./factories/StringFactory');
-const {UnionFactory} = require('./factories/UnionFactory');
-const {Base64Factory} = require('./factories/Base64Factory');
-const {FunctionFactory} = require('./factories/FunctionFactory');
-
-function vg(options) {
-  return new Valgen(options);
-}
-
-module.exports = vg;
-module.exports.__esModule = true;
-module.exports.default = vg;
-
-Object.assign(vg, {
-  Valgen,
-  AnyFactory,
-  ArrayFactory,
-  BooleanFactory,
-  DateFactory,
-  IntegerFactory,
-  NilFactory,
-  NumberFactory,
-  ObjectFactory,
-  StringFactory,
-  UnionFactory,
-  Base64Factory,
-  FunctionFactory
-});