valgen 3.2.0 → 4.0.0-alpha.2

package/lib/ObjectType.js

@@ -1,78 +0,0 @@
-'use strict';
-
-const {DataType} = require('./DataType');
-
-const PROPERTY_NAME_PATTERN = /^([^?!]+)([?|!])?$/;
-const REQUIRED_PROPERTY_PATTERN = /^([^?!]+)([?|!])?$/;
-
-/**
- *
- * @class ObjectType
- */
-class ObjectType extends DataType {
-
-  create(instance, schema) {
-    instance = super.create(instance, schema);
-    if (schema.properties) {
-      instance.properties = {};
-      const library = this.library;
-      const stack = library._stack;
-      stack.push('properties');
-      for (const [k, p] of Object.entries(schema.properties)) {
-        const m = k.match(REQUIRED_PROPERTY_PATTERN);
-        stack.push(m[1]);
-        const sch = library.normalizeSchema(p);
-        const t = library.getType(sch);
-        t.propertyName = m[1];
-        if (m[2] === '!')
-          t.required = true;
-        else if (m[2] === '?')
-          t.required = false;
-        else if (typeof p === 'object' && p.required != null)
-          t.required = p.required;
-        if (typeof t.required === 'string')
-          t.required = t.required.split(/\s*,\s*/);
-        instance.properties[m[1]] = t;
-      }
-      stack.pop();
-    }
-    return instance;
-  }
-
-  get(attr) {
-    if (attr.startsWith('properties.') && this.properties) {
-      const p = this.properties[attr.substring(11)];
-      if (p)
-        return p;
-    }
-    return super.get(attr);
-  }
-
-  normalizeSchema(schema) {
-    const normalized = super.normalizeSchema(schema);
-    const properties = normalized.properties;
-    if (properties) {
-      const stack = this.library._stack;
-      stack.push('properties');
-      normalized.properties = {};
-      for (const [k, sch] of Object.entries(properties)) {
-        const m = k.match(PROPERTY_NAME_PATTERN);
-        stack.push(k);
-        const v = this.library.normalizeSchema(sch);
-        if (v !== undefined) {
-          normalized.properties[m[1]] = v;
-          if (m[2] === '!')
-            v.required = true;
-          if (m[2] === '?')
-            v.required = false;
-        }
-        stack.pop();
-      }
-      stack.pop();
-    }
-    return normalized;
-  }
-
-}
-
-module.exports = {ObjectType};

package/lib/SchemaError.d.ts

@@ -1,3 +0,0 @@
-export class SchemaError extends Error {
-    constructor(msg: string | Error, schemaStack: string[]);
-}

package/lib/SchemaError.js

@@ -1,17 +0,0 @@
-class SchemaError extends Error {
-  constructor(msg, schemaStack) {
-    super(
-        (schemaStack ? 'Schema error at ' + schemaStack.join('.') + '. ' :
-            /* istanbul ignore next */ '') +
-        (msg instanceof Error ? msg.message :
-            /* istanbul ignore next */ msg));
-    /* istanbul ignore else */
-    if (schemaStack)
-      this.schemaStack = schemaStack;
-    /* istanbul ignore else */
-    if (msg instanceof Error)
-      this.stack = msg.stack;
-  }
-}
-
-module.exports = {SchemaError};

package/lib/UnionType.d.ts

@@ -1,5 +0,0 @@
-import {DataType} from './DataType';
-
-export class UnionType extends DataType {
-    anyOf?: DataType[];
-}

package/lib/UnionType.js

@@ -1,54 +0,0 @@
-'use strict';
-const merge = require('putil-merge');
-const {DataType} = require('./DataType');
-
-/**
- *
- * @class UnionType
- */
-class UnionType extends DataType {
-
-  create(instance, schema) {
-    instance = super.create(instance, schema);
-    const library = this.library;
-    const stack = library._stack;
-    stack.push('anyOf');
-
-    const additionalAttributes = merge({}, schema, {
-      filter: (o, n) => !['name', 'type', 'anyOf'].includes(n)
-    });
-    const hasAdditionalAttributes = Object.keys(additionalAttributes).length;
-    instance.anyOf = schema.anyOf.map(x => {
-      if (hasAdditionalAttributes) {
-        const sch = typeof x === 'string' ?
-            {type: x, ...additionalAttributes} : {...x, ...additionalAttributes};
-        return library.getType(sch);
-      }
-      return library.getType(x);
-    });
-
-    stack.pop();
-    return instance;
-  }
-
-  get(attr) {
-    if (attr === 'anyOf' && this.anyOf)
-      return this.anyOf;
-    return super.get(attr);
-  }
-
-  normalizeSchema(schema) {
-    const normalized = super.normalizeSchema(schema);
-    const items = normalized.items;
-    if (items) {
-      const stack = this.library._stack;
-      stack.push('items');
-      normalized.items = this.library.normalizeSchema(items);
-      stack.pop();
-    }
-    return normalized;
-  }
-
-}
-
-module.exports = {UnionType};

package/lib/Valgen.d.ts

@@ -1,88 +0,0 @@
-import {DataType} from "./DataType";
-
-export namespace Valgen {
-    export type TypeSchemaDef = string | ITypeSchema;
-    export type TypeLookupMethod = (typeName: string) => TypeSchemaDef;
-
-    export interface ITypeSchema {
-        type: string;
-
-        [key: string]: any;
-    }
-
-    export interface ITypeFactory {
-        generate: (base: DataType, options?: IGenerateOptions) => ValidateFunction;
-    }
-
-    export interface IGenerateOptions {
-        resolvePromises?: boolean;
-        strictFormat?: boolean;
-        coerceTypes?: boolean;
-        convertDates?: boolean;
-        throwOnError?: boolean
-        maxArrayErrors?: number;
-        maxObjectErrors?: number;
-        removeAdditional?: boolean | 'all';
-        removeNull?: boolean;
-        operation?: string; // 'get' | 'create' | 'update' | 'patch' | 'delete'
-    }
-
-    export type ValidateFunction = (value: any) => IValidationResult;
-
-    export interface IValidationResult {
-        valid: boolean;
-        value?: any;
-        errors?: IValidationError[];
-    }
-
-    export interface IValidationError {
-        message: string;
-        errorType?: string;
-        path?: string;
-
-        [index: string]: any;
-    }
-
-    export interface IOptions {
-        defaultType?: string;
-        throwOnError?: boolean;
-        schemaLookup?: TypeLookupMethod;
-    }
-}
-
-export class Valgen implements Valgen.IOptions {
-    protected _instances: { [name: string]: DataType };
-    protected _lookupSchemas: { [name: string]: Valgen.ITypeSchema };
-    protected _stacks: string[][];
-    private _idSeq: number;
-    defaultType: string;
-    baseTypes: { [name: string]: DataType };
-    schemaLookup?: Valgen.TypeLookupMethod;
-    schemas: { [index: string]: Valgen.TypeSchemaDef };
-    throwOnError?: boolean;
-
-    constructor(options?: Valgen.IOptions);
-
-    addSchema(name: string, schema: Valgen.TypeSchemaDef);
-
-    clearCache();
-
-    generate(schema: Valgen.TypeSchemaDef, options?: Valgen.IGenerateOptions): Valgen.ValidateFunction;
-
-    define(name: string, factory: Valgen.ITypeFactory): DataType;
-
-    normalizeSchema(schema: Valgen.TypeSchemaDef): Valgen.ITypeSchema;
-
-    getType(name: Valgen.TypeSchemaDef): DataType;
-
-    setOption(key: string, value: any): void;
-
-    protected _lookupForSchema(name: string): Valgen.TypeSchemaDef;
-
-    protected _getBaseTypeName(schema: Valgen.TypeSchemaDef): string;
-
-    protected _parseTypeName(v: string): Valgen.TypeSchemaDef;
-
-    protected get _stack(): string[];
-
-}

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