valgen 3.2.1 → 4.0.0-alpha.3

package/lib/Valgen.js

@@ -1,289 +0,0 @@
-const {DataType} = require('./DataType');
-const {ObjectType} = require('./ObjectType');
-const {ArrayType} = require('./ArrayType');
-const {UnionType} = require('./UnionType');
-const {AnyFactory} = require('./factories/AnyFactory');
-const {BooleanFactory} = require('./factories/BooleanFactory');
-const {NumberFactory} = require('./factories/NumberFactory');
-const {IntegerFactory} = require('./factories/IntegerFactory');
-const {StringFactory} = require('./factories/StringFactory');
-const {ArrayFactory} = require('./factories/ArrayFactory');
-const {ObjectFactory} = require('./factories/ObjectFactory');
-const {UnionFactory} = require('./factories/UnionFactory');
-const {DateFactory} = require('./factories/DateFactory');
-const {NilFactory} = require('./factories/NilFactory');
-const {FunctionFactory} = require('./factories/FunctionFactory');
-const {Base64Factory} = require('./factories/Base64Factory');
-const {SchemaError} = require('./SchemaError');
-
-const SQUARE_BRACKETS_PATTERN = /^\[([^\]]+)]$/;
-
-class Valgen {
-
-  constructor(options = {}) {
-    this._instances = {};
-    this._lookupSchemas = {};
-    this._stacks = [];
-    this._idSeq = 0;
-    this.baseTypes = {};
-    this.defaultType = options.defaultType;
-    this.schemaLookup = options.schemaLookup;
-    this.schemas = {};
-    this.throwOnError = options.throwOnError;
-    this.baseTypes.object = new ObjectType(this, 'object', new ObjectFactory());
-    this.baseTypes.array = new ArrayType(this, 'array', new ArrayFactory());
-    this.baseTypes.union = new UnionType(this, 'union', new UnionFactory());
-    this.define('any', new AnyFactory());
-    this.define('boolean', new BooleanFactory());
-    this.define('number', new NumberFactory());
-    this.define('string', new StringFactory());
-    this.define('integer', new IntegerFactory());
-    this.define('nil', new NilFactory());
-    this.define('function', new FunctionFactory());
-    this.define('base64', new Base64Factory());
-    this.define('datetime', new DateFactory({
-      dateFormats: {},
-      format: 'datetime'
-    }));
-    this.define('date', new DateFactory({
-      dateFormats: {},
-      format: 'date'
-    }));
-    this.define('time', new DateFactory({
-      dateFormats: {},
-      format: 'time'
-    }));
-  }
-
-  addSchema(name, schema) {
-    if (arguments.length <= 1) {
-      if (typeof name !== 'object')
-        throw new TypeError(`You must provide object instance as first argument.`);
-      schema = name;
-      name = schema.name;
-    } else if (typeof schema === 'string')
-      schema = this._parseTypeName(schema);
-    else {
-      if (typeof schema !== 'object')
-        throw new TypeError(`Second argument must be an object or string.`);
-      schema = {...schema, name};
-    }
-
-    if (!(name && typeof name === 'string'))
-      throw new Error('You must provide type name');
-
-    if (this.schemas[schema.name])
-      throw new Error(`Schema "${schema.name}" already defined.`);
-
-    this.schemas[name] = schema;
-  }
-
-  clearCache() {
-    this._instances = {};
-    this._lookupSchemas = {};
-    Object.keys(this.baseTypes).forEach(k => this.baseTypes[k]._fnCache = {});
-  }
-
-  define(typeName, factory) {
-    if (!factory)
-      delete this.baseTypes[typeName];
-    return this.baseTypes[typeName] = new DataType(this, typeName, factory);
-  }
-
-  generate(schema, options = {}) {
-    return this.getType(schema)
-        .generate(options);
-  }
-  
-  normalizeSchema(schema) {
-    const baseTypeName = this._getBaseTypeName(schema);
-    const baseType = this.baseTypes[baseTypeName];
-    if (!baseType)
-      throw new Error(`Unable to determine base type.`);
-
-    if (typeof schema === 'string') {
-      schema = this._parseTypeName(schema);
-    } else schema = {...schema};
-
-    if (typeof schema === 'string')
-      schema = {type: schema};
-    else {
-      if (schema.type) {
-        if (Array.isArray(schema.type)) {
-          schema.type = schema.type.map(t => {
-            if (typeof t === 'string')
-              return this._parseTypeName(t);
-            return this.normalizeSchema(t);
-          });
-          if (schema.type.length <= 1)
-            schema.type = schema.type[0];
-        } else {
-          const x = this.normalizeSchema(schema.type);
-          if (x !== schema.type) {
-            Object.assign(schema, x);
-          }
-        }
-      }
-      if (!schema.type)
-        schema.type = baseTypeName;
-    }
-
-    return baseType.normalizeSchema(schema);
-  }
-
-  getType(schemaOrName) {
-    if (!schemaOrName)
-      throw new TypeError('Invalid argument');
-
-    if (schemaOrName instanceof DataType)
-      return schemaOrName;
-
-    let name;
-    let cacheId;
-    let schema;
-    let baseType;
-    if (typeof schemaOrName === 'string') {
-      schema = this._parseTypeName(schemaOrName);
-      if (typeof schema === 'string') {
-        name = schema;
-        // Return previously cached type
-        const t = this._instances[name];
-        if (t) return t;
-
-        // Check if it is an internal type
-        baseType = this.baseTypes[name];
-        if (!baseType) {
-          // Lookup for schema by name
-          schema = this.schemas[name] || this._lookupForSchema(name);
-          if (!schema || schema === name)
-            throw new TypeError(`Unknown type schema "${name}"`);
-          if (typeof schema === 'string')
-            schema = {name, type: schema};
-        }
-
-      } else
-        name = schema.name;
-      cacheId = name;
-    } else {
-      schema = schemaOrName;
-      name = schema.name;
-    }
-
-    const stack = [name || '(anonymous)'];
-    this._stacks.push(stack);
-    try {
-      if (!baseType) {
-        const baseTypeName = this._getBaseTypeName(schema);
-        baseType = this.baseTypes[baseTypeName];
-      }
-      const instance = {id: ++this._idSeq, name};
-      if (cacheId)
-        this._instances[cacheId] = instance;
-      baseType.create(instance, schema);
-      if (baseType.factory.create)
-        baseType.factory.create(instance);
-      return instance;
-    } catch (e) {
-      delete this._instances[name];
-      if (e instanceof SchemaError)
-        throw e;
-      throw new SchemaError(e, stack);
-    } finally {
-      this._stacks.pop();
-    }
-  }
-
-  setOption(key, v) {
-    const m = key.match(/^([^.]+)(?:\.(.+))?$/);
-    if (m) {
-      const t = this.baseTypes[m[1]];
-      if (!t)
-        return;
-      if (v === undefined)
-        delete t.options[m[2]];
-      else
-        t.options[m[2]] = v;
-    }
-  }
-
-  _lookupForSchema(name) {
-    let schema = this.schemas[name] || this._lookupSchemas[name];
-    if (schema)
-      return schema;
-    schema = this.schemaLookup && this.schemaLookup(name);
-    if (schema)
-      return this._lookupSchemas[name] = schema;
-  }
-
-  _getBaseTypeName(schema) {
-    const stack = [];
-    const getTypeName = (schema) => {
-      if (typeof schema === 'string')
-        schema = this._parseTypeName(schema);
-
-      if (typeof schema === 'string') {
-        if (stack.includes(schema))
-          throw new Error('Circular reference detected');
-        const t = this.baseTypes[schema] || this._instances[schema];
-        if (t)
-          return t.typeName;
-        const sch = this._lookupForSchema(schema);
-        if (!sch || sch === schema)
-          throw new Error(`Unknown type "${schema}"`);
-        stack.push(schema);
-        return getTypeName(sch);
-      }
-      let h = (Array.isArray(schema.type) ? schema.type[0] : schema.type);
-      if (!h) {
-        if (schema.items)
-          h = 'array';
-        else if (schema.properties)
-          h = 'object';
-        else if (schema.anyOf)
-          h = 'union';
-        else h = this.defaultType || 'any';
-      }
-      return getTypeName(h);
-    };
-    return getTypeName(schema);
-  }
-
-  _parseTypeName(v) {
-    let m = v.match(SQUARE_BRACKETS_PATTERN);
-    if (m)
-      v = m[1];
-    if (v.includes(',')) {
-      return {
-        type: v.split(/\s*,\s*/).map(x => this._parseTypeName(x))
-      };
-    }
-    if (v.includes('|')) {
-      return {
-        type: 'union',
-        anyOf: v.split(/\s*\|\s*/).map(x => this._parseTypeName(x))
-      };
-    }
-    if (v.endsWith('[]')) {
-      const n = this._parseTypeName(v.substring(0, v.length - 2));
-      return {
-        type: 'array',
-        items: n
-      };
-    }
-    if (v.endsWith('{}')) {
-      const n = this._parseTypeName(v.substring(0, v.length - 2));
-      return {
-        type: 'object',
-        additionalProperties: n
-      };
-    }
-    return v;
-  }
-
-  get _stack() {
-    return this._stacks[this._stacks.length - 1];
-  }
-
-}
-
-module.exports = {Valgen};

package/lib/ValidationError.d.ts

@@ -1,2 +0,0 @@
-export class ValidationError extends Error {
-}

package/lib/ValidationError.js

@@ -1,4 +0,0 @@
-class ValidationError extends Error {
-}
-
-module.exports = ValidationError;

package/lib/factories/AnyFactory.d.ts

@@ -1,28 +0,0 @@
-import {Valgen} from "../Valgen";
-import {DataType} from "../DataType";
-
-export namespace AnyFactory {
-    export interface FunctionData {
-        code: string;
-        variables?: {
-            [index: string]: any;
-        };
-    }
-    export interface TypeSchema extends Valgen.ITypeSchema {
-        default?: any;
-    }
-}
-
-export class AnyFactory implements Valgen.ITypeFactory {
-
-    schema: AnyFactory.TypeSchema;
-    options: any;
-
-    generate(type: DataType, options?: Valgen.IGenerateOptions): Valgen.ValidateFunction;
-
-    normalizeAttribute: (attr: string, value: any) => any;
-
-    normalizeCompileOptions(options?: Valgen.IGenerateOptions): Valgen.IGenerateOptions;
-
-    protected _generateValidationCode(dataType: DataType, options: Valgen.IGenerateOptions): AnyFactory.FunctionData;
-}

package/lib/factories/AnyFactory.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const {coerceToBoolean, coerceToString} = require('putil-varhelpers');
-
-const Failed = Symbol.for('Failed');
-
-/**
- *
- * @class AnyFactory
- */
-class AnyFactory {
-
-  normalizeCompileOptions(options) {
-    return {
-      displayName: coerceToString(options.displayName),
-      resolvePromises: coerceToBoolean(options.resolvePromises),
-      throwOnError: coerceToBoolean(options.throwOnError)
-    };
-  }
-
-  normalizeAttribute(attr, v) {
-    switch (attr) {
-      case 'default':
-        return v;
-    }
-  }
-
-  generate(dataType, options) {
-    const defaultValue = dataType.get('default');
-    const varNames = ['dataType', 'Failed', 'defaultValue'];
-    const varValues = [dataType, Failed, defaultValue];
-    const o = this._generateValidationCode(dataType, options);
-    /* istanbul ignore else */
-    if (o.variables)
-      for (const n of Object.keys(o.variables)) {
-        varNames.push(n);
-        varValues.push(o.variables[n]);
-      }
-    const code = `return (value, ctx) => {
-  ${defaultValue !== undefined ?
-        'if (value == null) value = defaultValue;' : ''}             
-  ${o.code}
-  return value;
-}`;
-    return new Function(...varNames, code)(...varValues);
-  }
-
-  _generateValidationCode(dataType, options) {
-    const data = {code: '', variables: {}};
-    data.variables.name = options.displayName || dataType.name;
-
-    data.code += `
-    if (value == null) return value;
-    const typeCheck = ctx && ctx.typeCheck;
-    `;
-
-    const enumValues = dataType.get('enum');
-    if (enumValues) {
-      data.variables.enums = new Set(enumValues);
-      data.code += `
-    if (!enums.has(value))
-        return typeCheck ? Failed : ctx.logError({
-            message: 'Value must be a one of the enumerated values.',
-            errorType: 'invalid-enum-value'            
-        });`;
-    }
-
-    return data;
-  }
-
-}
-
-module.exports = {AnyFactory};

package/lib/factories/ArrayFactory.d.ts

@@ -1,16 +0,0 @@
-import {AnyFactory} from './AnyFactory';
-import {Valgen} from '../Valgen';
-
-export namespace ArrayFactory {
-    export interface ITypeSchema extends Valgen.ITypeSchema {
-        default?: any[];
-        items?: string | Valgen.ITypeSchema;
-        minItems?: number;
-        maxItems?: number;
-    }
-}
-
-
-export class ArrayFactory extends AnyFactory {
-    schema: ArrayFactory.ITypeSchema;
-}

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