valgen 3.2.1 → 4.0.0-alpha.3

package/lib/DataType.js

@@ -1,214 +0,0 @@
-'use strict';
-
-const promisify = require('putil-promisify');
-const objectHash = require('object-hash');
-const {coalesce} = require('putil-varhelpers');
-const ValidationError = require('./ValidationError');
-
-const Failed = Symbol.for('Failed');
-const PROPERTY_PATTERN = /^[a-zA-Z]\w+$/;
-
-/**
- *
- * @class DataType
- */
-class DataType {
-
-  constructor(library, typeName, factory) {
-    if (!typeName)
-      throw new TypeError(`You must provide type name.`);
-    if (!factory || typeof factory !== 'object')
-      throw new TypeError('Factory argument must be an object');
-    if (typeof factory.generate !== 'function')
-      throw new TypeError('Factory must contain a "generate" function');
-    Object.defineProperties(this, {
-      library: {
-        writable: false,
-        configurable: false,
-        value: library
-      },
-      factory: {
-        writable: false,
-        configurable: false,
-        value: factory
-      },
-      typeName: {
-        writable: false,
-        configurable: false,
-        value: typeName
-      }
-    });
-    this.options = {};
-    this._fnCache = {};
-  }
-
-  create(instance, schema) {
-    let proto = this;
-    while (proto.predecessors) {
-      const p = Object.getPrototypeOf(proto);
-      if (!p.predecessors)
-        break;
-      proto = p;
-    }
-    Object.setPrototypeOf(instance, proto);
-    instance.predecessors = [];
-    schema = instance.schema = this.normalizeSchema(schema);
-
-    if (schema.type) {
-      const library = this.library;
-      const stack = library._stack;
-      stack.push('type');
-      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-      for (const sch of types) {
-        if (sch === this.typeName)
-          continue;
-        const t = library.getType(sch);
-        if (!(t.factory === instance.factory)) { // noinspection ExceptionCaughtLocallyJS
-          throw new Error(`"${instance.typeName}" type can't be mixed with "${t.typeName}" type.`);
-        }
-        instance.predecessors.push(t);
-      }
-      stack.pop();
-    }
-    return instance;
-  }
-
-  normalizeSchema(schema) {
-    const normalized = {};
-    const library = this.library;
-    if (schema.type) {
-      let a = Array.isArray(schema.type) ? schema.type : [schema.type];
-      a = a.map(s => {
-        if (typeof s === 'string')
-          s = library._parseTypeName(s);
-        if (typeof s === 'string')
-          return s;
-        return library.normalizeSchema(s);
-      });
-      if (a.length <= 1) {
-        if (typeof a[0] === 'object')
-          Object.assign(schema, a[0]);
-        else
-          normalized.type = a[0];
-      } else normalized.type = a;
-    }
-    if (this.factory.normalizeAttribute) {
-      const stack = this.library._stack;
-      for (const key of Object.keys(schema)) {
-        let v = schema[key];
-        if (v === undefined || key === 'type')
-          continue;
-        /* istanbul ignore else */
-        stack.push(key);
-        v = this.factory.normalizeAttribute(key, schema[key], schema);
-        if (v !== undefined)
-          normalized[key] = v;
-        /* istanbul ignore else */
-        stack.pop();
-      }
-    }
-    return normalized;
-  }
-
-  generate(options = {}) {
-    options.throwOnError =
-        coalesce(options.throwOnError, this.library.throwOnError);
-
-    /* istanbul ignore else */
-    const preparedOptions = this.factory.normalizeCompileOptions ?
-        this.factory.normalizeCompileOptions(options) : {...options};
-    Object.keys(preparedOptions).forEach(k => {
-      if (preparedOptions[k] === undefined)
-        delete preparedOptions[k];
-    });
-
-    // Lookup for cached validator for same options
-    const cacheId = objectHash({
-      schema: this.schema,
-      defaults: this.options,
-      options: preparedOptions
-    });
-    let validate = this._fnCache[cacheId];
-    if (validate)
-      return validate;
-
-    this._fnCache[cacheId] = function() {
-      return validate.apply(this, arguments);
-    };
-
-    const fn = this.factory.generate(this, options);
-
-    const callValidate = (value, ctx) => {
-      ctx = ctx || {};
-      const _path = ctx.path = ctx.path || [];
-      ctx.errors = ctx.errors || [];
-      ctx.logError = ctx.logError || (
-          (e) => {
-            if (ctx.path.length)
-              e.path = ctx.path.slice();
-            const s = ctx.getPath();
-            if (s)
-              e.message = 'Error at "' + s + '". ' + e.message;
-            ctx.errors.push(e);
-            return Failed;
-          });
-      ctx.getPath = ctx.getPath || (() => {
-        let s = '';
-        const len = _path.length;
-        for (let i = 0; i < len; i++) {
-          const x = _path[i];
-          if (typeof x === 'number')
-            s += '[' + x + ']';
-          else if (x.match(PROPERTY_PATTERN))
-              /* istanbul ignore next */
-            s += (s ? '.' : '') + x;
-          else
-            s += '[' + x.replace(/'/g, '\\\'') + ']';
-        }
-        return s;
-      });
-
-      const v = fn(value, ctx);
-      const valid = v !== Failed;
-      if (options.throwOnError && ctx.errors.length) {
-        const ee = new ValidationError(ctx.errors[0].message);
-        // @ts-ignore
-        ee.errors = ctx.errors;
-        ee.value = value;
-        Object.assign(ee, ctx.errors[0]);
-        throw ee;
-      }
-      return ctx.errors.length ?
-          {valid, errors: ctx.errors} :
-          {valid, value: v};
-    };
-
-    validate = options.resolvePromises ?
-        async (value, ctx) => {
-          value = await promisify.deepResolve(value);
-          return callValidate(value, ctx);
-        } :
-        (value, ctx) => callValidate(value, ctx);
-    this._fnCache[cacheId] = validate;
-    validate.dataType = this;
-    return validate;
-  }
-
-  get(attr) {
-    let v;
-    v = this.schema[attr];
-    if (v !== undefined)
-      return v;
-    if (this.predecessors) {
-      let i = this.predecessors.length;
-      while (i--) {
-        v = this.predecessors[i].get(attr);
-        if (v !== undefined)
-          return v;
-      }
-    }
-  }
-
-}
-
-module.exports = {DataType, Failed};

package/lib/ObjectType.d.ts

@@ -1,5 +0,0 @@
-import {DataType} from './DataType';
-
-export class ObjectType extends DataType {
-    properties?: { [key: string]: DataType }
-}

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