funval/lib/Schema.js

A minimalist library for data validation using functions interfaces.

"use strict";

exports.__esModule = true;
exports.default = Schema;
exports.Async = Async;

var _utils = require("./utils");

var _comparison = require("./validators/comparison");

var _Error = require("./Error");

var _string = require("./validators/string");

// exported functions
function Schema(schema, error) {
  switch (typeof schema) {
    case 'string':
    case 'number':
    case 'boolean':
    case 'undefined':
    case 'symbol':
    case 'bigint':
      return (0, _comparison.Equals)(schema, error);

    case 'function':
      return schema;

    case 'object':
      if (schema === null) {
        return (0, _comparison.Equals)(schema, error);
      }

      if (schema instanceof RegExp) {
        return (0, _string.StringMatch)(schema, error);
      }

      return input => {
        if (typeof input !== 'object') {
          throw (0, _Error.toError)(error || `Expecting value to be an object: ${typeof input}`);
        }

        if (input === null) {
          throw (0, _Error.toError)(error || `Expecting value to be non-nullable`);
        }

        if (Array.isArray(schema)) {
          if (!Array.isArray(input)) {
            throw (0, _Error.toError)(error || `Expecting value to an array`);
          }

          if (schema.length !== input.length) {
            throw (0, _Error.toError)(error || `Expecting array length to be ${schema.length} (actual: ${input.length})`);
          }
        }

        const res = Array.isArray(schema) ? [] : {};
        const promises = [];
        const errors = [];

        for (const key in schema) {
          if (!Object.prototype.hasOwnProperty.call(schema, key)) continue;
          const schemaProp = schema[key];
          const inputProp = input[key];

          try {
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            const value = Schema(schemaProp)(inputProp);
            const resKey = key;

            if (!(0, _utils.isPromiseLike)(value)) {
              res[resKey] = value;
            } else {
              promises.push(value.then(value => {
                res[resKey] = value;
              }, err => {
                errors.push(...(0, _Error.getErrorPaths)(err, [key]));
              }));
            }
          } catch (e) {
            errors.push(...(0, _Error.getErrorPaths)(e, [key]));
          }
        }

        if (!promises.length) {
          if (errors.length) {
            throw (0, _Error.createValidationError)(errors, error);
          }

          return res;
        }

        return Promise.all(promises).then(() => {
          if (errors.length) {
            throw (0, _Error.createValidationError)(errors, error);
          }

          return res;
        });
      };

    default:
      throw new Error(`Unknown JavaScript type: ${typeof schema}`);
  }
}

function Async(validator) {
  return input => new Promise(resolve => resolve(validator(input)));
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Schema.ts"],"names":["Schema","schema","error","RegExp","input","Array","isArray","length","res","promises","errors","key","Object","prototype","hasOwnProperty","call","schemaProp","inputProp","value","resKey","push","then","err","e","Promise","all","Error","Async","validator","resolve"],"mappings":"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","sourcesContent":["import { AnyType, FunctionType, isPromiseLike } from './utils';\nimport { Equals } from './validators/comparison';\nimport ValidationError, {\n  createValidationError,\n  getErrorPaths,\n  ErrorPath,\n  toError,\n  ErrorLike,\n} from './Error';\nimport { Output, Input } from './Type';\nimport { StringMatch } from './validators/string';\n\nexport type SyncFunctionValidator<\n  T = AnyType,\n  I extends Array<AnyType> = [Input<T>]\n> = FunctionType<T, I>;\n\nexport type AsyncFunctionValidator<\n  T = AnyType,\n  I extends Array<AnyType> = [Input<T>]\n> = FunctionType<PromiseLike<T>, I>;\n\nexport type FunctionValidator<\n  T = AnyType,\n  I extends Array<AnyType> = [Input<T>]\n> = FunctionType<PromiseLike<T> | T, I>;\n\nexport type SchemaType<T = AnyType> = [T] extends [FunctionType]\n  ? FunctionValidator<T>\n  : [T] extends [object]\n  ? { [K in keyof T]: SchemaType<T[K]> }\n  : FunctionValidator<T> | T;\n\nexport type SyncSchemaType<T> = [T] extends [FunctionType]\n  ? SyncFunctionValidator<T>\n  : [T] extends [object]\n  ? { [K in keyof T]: SyncSchemaType<T[K]> }\n  : [T] extends [string]\n  ? SyncFunctionValidator<T> | RegExp | T\n  : SyncFunctionValidator<T> | T;\n\nexport type ValidatorOutput<T> = T extends SyncSchemaType<Output<T>>\n  ? Output<T>\n  : PromiseLike<Output<T>>;\n\nexport type SchemaValidator<\n  T,\n  I extends Array<AnyType> = [Input<T>]\n> = FunctionType<ValidatorOutput<T>, I>;\n\nexport type SchemaAsyncValidator<\n  T,\n  I extends Array<AnyType> = [Input<T>]\n> = FunctionType<PromiseLike<Output<T>>, I>;\n\n// exported functions\n\nexport default function Schema<T>(\n  schema: T,\n  error?: ErrorLike,\n): SchemaValidator<T> {\n  switch (typeof schema) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n    case 'symbol':\n    case 'bigint':\n      return (Equals(schema, error) as unknown) as SchemaValidator<T>;\n\n    case 'function':\n      return (schema as unknown) as SchemaValidator<T>;\n\n    case 'object':\n      if (schema === null) {\n        return (Equals(schema, error) as unknown) as SchemaValidator<T>;\n      }\n\n      if (schema instanceof RegExp) {\n        return (StringMatch(schema, error) as unknown) as SchemaValidator<T>;\n      }\n\n      return (input: Input<T>): ValidatorOutput<T> => {\n        if (typeof input !== 'object') {\n          throw toError(\n            error || `Expecting value to be an object: ${typeof input}`,\n          );\n        }\n\n        if (input === null) {\n          throw toError(error || `Expecting value to be non-nullable`);\n        }\n\n        if (Array.isArray(schema)) {\n          if (!Array.isArray(input)) {\n            throw toError(error || `Expecting value to an array`);\n          }\n\n          if (schema.length !== input.length) {\n            throw toError(\n              error ||\n                `Expecting array length to be ${schema.length} (actual: ${input.length})`,\n            );\n          }\n        }\n\n        const res: {\n          [K in keyof Output<T>]?: PromiseLike<Output<T>[K]> | Output<T>[K];\n        } = Array.isArray(schema) ? ([] as {}) : {};\n\n        const promises: PromiseLike<void>[] = [];\n        const errors: ErrorPath[] = [];\n\n        for (const key in schema) {\n          if (!Object.prototype.hasOwnProperty.call(schema, key)) continue;\n\n          const schemaProp = schema[key as keyof T];\n          const inputProp = input[key as keyof Input<T>];\n\n          try {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const value = Schema(schemaProp)(inputProp as any) as\n              | PromiseLike<Output<T>[keyof Output<T>]>\n              | Output<T>[keyof Output<T>];\n            const resKey = key as keyof Output<T>;\n\n            if (!isPromiseLike(value)) {\n              res[resKey] = value;\n            } else {\n              promises.push(\n                value.then(\n                  (value) => {\n                    res[resKey] = value;\n                  },\n                  (err: ValidationError) => {\n                    errors.push(...getErrorPaths(err, [key]));\n                  },\n                ),\n              );\n            }\n          } catch (e) {\n            errors.push(...getErrorPaths(e, [key]));\n          }\n        }\n\n        if (!promises.length) {\n          if (errors.length) {\n            throw createValidationError(errors, error);\n          }\n\n          return res as ValidatorOutput<T>;\n        }\n\n        return Promise.all(promises).then(() => {\n          if (errors.length) {\n            throw createValidationError(errors, error);\n          }\n\n          return res as Output<T>;\n        }) as ValidatorOutput<T>;\n      };\n\n    default:\n      throw new Error(`Unknown JavaScript type: ${typeof schema}`);\n  }\n}\n\nexport function Async<\n  V,\n  T extends FunctionValidator<V>,\n  I extends Parameters<T>[0]\n>(validator: T): FunctionType<PromiseLike<V>, [I]> {\n  return (input: I): Promise<V> =>\n    new Promise((resolve) => resolve(validator(input)));\n}\n"]}