z-schema 6.0.1 → 7.0.0-beta.1

package/src/Report.ts

@@ -0,0 +1,337 @@
+import get from 'lodash.get';
+import { Errors } from './Errors.js';
+import * as Utils from './Utils.js';
+import { ZSchemaOptions } from './ZSchema.js';
+
+export interface SchemaError extends Error {
+  /**
+   * Implements the Error.name contract.  The value is always "z-schema validation error".
+   */
+  name: string;
+
+  /**
+   * An identifier indicating the type of error.
+   * Example: "JSON_OBJECT_VALIDATION_FAILED"
+   */
+  message: string;
+
+  /**
+   * Returns details for each error that occurred during validation.
+   * See Options.breakOnFirstError.
+   */
+  details?: SchemaErrorDetail[];
+}
+
+export interface SchemaErrorDetail {
+  /**
+   * Example: "Expected type string but found type array"
+   */
+  message: string;
+  /**
+   * An error identifier that can be used to format a custom error message.
+   * Example: "INVALID_TYPE"
+   */
+  code: string;
+  /**
+   * Format parameters that can be used to format a custom error message.
+   * Example: ["string","array"]
+   */
+  params: Array<string>;
+  /**
+   * A JSON path indicating the location of the error.
+   * Example: "#/projects/1"
+   */
+  path: string | string[];
+  /**
+   * The schema rule description, which is included for certain errors where
+   * this information is useful (e.g. to describe a constraint).
+   */
+  title?: string;
+  description?: string;
+
+  /**
+   * Returns details for sub-schemas that failed to match.  For example, if the schema
+   * uses the "oneOf" constraint to accept several alternative possibilities, each
+   * alternative will have its own inner detail object explaining why it failed to match.
+   */
+  inner?: SchemaErrorDetail[];
+
+  schemaId?: string;
+}
+
+export interface ReportOptions {
+  maxErrors?: number;
+}
+
+type TaskResult = unknown;
+type TaskFn = (...args: unknown[]) => TaskResult;
+type TaskFnArgs = Parameters<TaskFn>;
+type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
+type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
+
+export class Report {
+  errors: SchemaErrorDetail[];
+  parentReport?: Report;
+  options: ZSchemaOptions;
+  reportOptions: ReportOptions;
+  path: string[];
+  asyncTasks: AsyncTask[];
+  rootSchema?: {
+    id?: string;
+  };
+  commonErrorMessage?: string;
+  json?: unknown;
+
+  constructor(parentOrOptions, reportOptions?) {
+    this.parentReport = parentOrOptions instanceof Report ? parentOrOptions : undefined;
+
+    this.options = parentOrOptions instanceof Report ? parentOrOptions.options : parentOrOptions || {};
+
+    this.reportOptions = reportOptions || {};
+
+    this.errors = [];
+    /**
+     * @type {string[]}
+     */
+    this.path = [];
+    this.asyncTasks = [];
+
+    this.rootSchema = undefined;
+    this.commonErrorMessage = undefined;
+    this.json = undefined;
+  }
+
+  isValid(): boolean {
+    if (this.asyncTasks.length > 0) {
+      throw new Error("Async tasks pending, can't answer isValid");
+    }
+    return this.errors.length === 0;
+  }
+
+  addAsyncTask(fn, args, asyncTaskResultProcessFn) {
+    this.asyncTasks.push([fn, args, asyncTaskResultProcessFn]);
+  }
+
+  getAncestor(id) {
+    if (!this.parentReport) {
+      return undefined;
+    }
+    if (this.parentReport.getSchemaId() === id) {
+      return this.parentReport;
+    }
+    return this.parentReport.getAncestor(id);
+  }
+
+  processAsyncTasks(timeout, callback) {
+    const validationTimeout = timeout || 2000;
+    let tasksCount = this.asyncTasks.length;
+    let idx = tasksCount;
+    let timedOut = false;
+
+    const finish = () => {
+      setTimeout(() => {
+        const valid = this.errors.length === 0,
+          err = valid ? null : this.errors;
+        callback(err, valid);
+      }, 0);
+    };
+
+    function respond(asyncTaskResultProcessFn: TaskProcessFn) {
+      return function (asyncTaskResult) {
+        if (timedOut) {
+          return;
+        }
+        asyncTaskResultProcessFn(asyncTaskResult);
+        if (--tasksCount === 0) {
+          finish();
+        }
+      };
+    }
+
+    // finish if tasks are completed or there are any errors and breaking on first error was requested
+    if (tasksCount === 0 || (this.errors.length > 0 && this.options.breakOnFirstError)) {
+      finish();
+      return;
+    }
+
+    while (idx--) {
+      const [fn, fnArgs, processFn] = this.asyncTasks[idx];
+      const respondCallback = respond(processFn);
+      fn(...fnArgs, respondCallback);
+    }
+
+    setTimeout(() => {
+      if (tasksCount > 0) {
+        timedOut = true;
+        this.addError('ASYNC_TIMEOUT', [tasksCount, validationTimeout]);
+        callback(this.errors, false);
+      }
+    }, validationTimeout);
+  }
+
+  getPath(returnPathAsString) {
+    /**
+     * @type {string[]|string}
+     */
+    let path = [];
+    if (this.parentReport) {
+      path = path.concat(this.parentReport.path);
+    }
+    path = path.concat(this.path);
+
+    if (returnPathAsString !== true) {
+      // Sanitize the path segments (http://tools.ietf.org/html/rfc6901#section-4)
+      return (
+        '#/' +
+        path
+          .map(function (segment) {
+            segment = segment.toString();
+
+            if (Utils.isAbsoluteUri(segment)) {
+              return 'uri(' + segment + ')';
+            }
+
+            return segment.replace(/~/g, '~0').replace(/\//g, '~1');
+          })
+          .join('/')
+      );
+    }
+    return path;
+  }
+
+  getSchemaId() {
+    if (!this.rootSchema) {
+      return null;
+    }
+
+    // get the error path as an array
+    let path = [];
+    if (this.parentReport) {
+      path = path.concat(this.parentReport.path);
+    }
+    path = path.concat(this.path);
+
+    // try to find id in the error path
+    while (path.length > 0) {
+      const obj = get(this.rootSchema, path);
+      if (obj && obj.id) {
+        return obj.id;
+      }
+      path.pop();
+    }
+
+    // return id of the root
+    return this.rootSchema.id;
+  }
+
+  hasError(errorCode, params) {
+    let idx = this.errors.length;
+    while (idx--) {
+      if (this.errors[idx].code === errorCode) {
+        // assume match
+        let match = true;
+
+        // check the params too
+        let idx2 = this.errors[idx].params.length;
+        while (idx2--) {
+          if (this.errors[idx].params[idx2] !== params[idx2]) {
+            match = false;
+          }
+        }
+
+        // if match, return true
+        if (match) {
+          return match;
+        }
+      }
+    }
+    return false;
+  }
+
+  addError(errorCode, params, subReports?, schema?) {
+    if (!errorCode) {
+      throw new Error('No errorCode passed into addError()');
+    }
+    this.addCustomError(errorCode, Errors[errorCode], params, subReports, schema);
+  }
+
+  getJson() {
+    if (this.json) {
+      return this.json;
+    }
+    if (this.parentReport) {
+      return this.parentReport.getJson();
+    }
+    return undefined;
+  }
+
+  addCustomError(
+    errorCode: string,
+    errorMessage: string,
+    params: string[],
+    subReports?: Report[] | Report,
+    schema?: {
+      title?: string;
+      description?: string;
+    }
+  ) {
+    if (this.errors.length >= this.reportOptions.maxErrors) {
+      return;
+    }
+
+    if (!errorMessage) {
+      throw new Error('No errorMessage known for code ' + errorCode);
+    }
+
+    params = params || [];
+
+    let idx = params.length;
+    while (idx--) {
+      const whatIs = Utils.whatIs(params[idx]);
+      const param = whatIs === 'object' || whatIs === 'null' ? JSON.stringify(params[idx]) : params[idx];
+      errorMessage = errorMessage.replace('{' + idx + '}', param);
+    }
+
+    const err: SchemaErrorDetail = {
+      code: errorCode,
+      params: params,
+      message: errorMessage,
+      path: this.getPath(this.options.reportPathAsArray),
+      schemaId: this.getSchemaId(),
+    };
+
+    err[Utils.schemaSymbol] = schema;
+    err[Utils.jsonSymbol] = this.getJson();
+
+    if (schema && typeof schema === 'string') {
+      err.description = schema;
+    } else if (schema && typeof schema === 'object') {
+      if (schema.title) {
+        err.title = schema.title;
+      }
+      if (schema.description) {
+        err.description = schema.description;
+      }
+    }
+
+    if (subReports != null) {
+      if (!Array.isArray(subReports)) {
+        subReports = [subReports];
+      }
+      err.inner = [];
+      idx = subReports.length;
+      while (idx--) {
+        const subReport = subReports[idx];
+        let idx2 = subReport.errors.length;
+        while (idx2--) {
+          err.inner.push(subReport.errors[idx2]);
+        }
+      }
+      if (err.inner.length === 0) {
+        err.inner = undefined;
+      }
+    }
+
+    this.errors.push(err);
+  }
+}

package/src/SchemaCache.ts

@@ -0,0 +1,189 @@
+import isequal from 'lodash.isequal';
+import { Report } from './Report.js';
+import { compileSchema } from './SchemaCompilation.js';
+import * as SchemaValidation from './SchemaValidation.js';
+import * as Utils from './Utils.js';
+
+function decodeJSONPointer(str) {
+  // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
+  return decodeURIComponent(str).replace(/~[0-1]/g, function (x) {
+    return x === '~1' ? '/' : '~';
+  });
+}
+
+export function getRemotePath(uri) {
+  const io = uri.indexOf('#');
+  return io === -1 ? uri : uri.slice(0, io);
+}
+
+function getQueryPath(uri) {
+  const io = uri.indexOf('#');
+  const res = io === -1 ? undefined : uri.slice(io + 1);
+  // WARN: do not slice slash, #/ means take root and go down from it
+  // if (res && res[0] === "/") { res = res.slice(1); }
+  return res;
+}
+
+function findId(schema, id) {
+  // process only arrays and objects
+  if (typeof schema !== 'object' || schema === null) {
+    return;
+  }
+
+  // no id means root so return itself
+  if (!id) {
+    return schema;
+  }
+
+  if (schema.id) {
+    if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
+      return schema;
+    }
+  }
+
+  let idx, result;
+  if (Array.isArray(schema)) {
+    idx = schema.length;
+    while (idx--) {
+      result = findId(schema[idx], id);
+      if (result) {
+        return result;
+      }
+    }
+  } else {
+    const keys = Object.keys(schema);
+    idx = keys.length;
+    while (idx--) {
+      const k = keys[idx];
+      if (k.indexOf('__$') === 0) {
+        continue;
+      }
+      result = findId(schema[k], id);
+      if (result) {
+        return result;
+      }
+    }
+  }
+}
+
+/**
+ *
+ * @param {*} uri
+ * @param {*} schema
+ *
+ * @returns {void}
+ */
+export function cacheSchemaByUri(uri, schema) {
+  const remotePath = getRemotePath(uri);
+  if (remotePath) {
+    this.cache[remotePath] = schema;
+  }
+}
+
+/**
+ *
+ * @param {*} uri
+ *
+ * @returns {void}
+ */
+export function removeFromCacheByUri(uri) {
+  const remotePath = getRemotePath(uri);
+  if (remotePath) {
+    delete this.cache[remotePath];
+  }
+}
+
+/**
+ *
+ * @param {*} uri
+ *
+ * @returns {boolean}
+ */
+export function checkCacheForUri(uri) {
+  const remotePath = getRemotePath(uri);
+  return remotePath ? this.cache[remotePath] != null : false;
+}
+
+export function getSchema(report, schema) {
+  if (typeof schema === 'object') {
+    schema = getSchemaByReference.call(this, report, schema);
+  }
+  if (typeof schema === 'string') {
+    schema = getSchemaByUri.call(this, report, schema);
+  }
+  return schema;
+}
+
+export function getSchemaByReference(report, key) {
+  let i = this.referenceCache.length;
+  while (i--) {
+    if (isequal(this.referenceCache[i][0], key)) {
+      return this.referenceCache[i][1];
+    }
+  }
+  // not found
+  const schema = Utils.cloneDeep(key);
+  this.referenceCache.push([key, schema]);
+  return schema;
+}
+
+export function getSchemaByUri(report, uri, root) {
+  const remotePath = getRemotePath(uri);
+  const queryPath = getQueryPath(uri);
+  let result = remotePath ? this.cache[remotePath] : root;
+
+  if (result && remotePath) {
+    // we need to avoid compiling schemas in a recursive loop
+    const compileRemote = result !== root;
+    // now we need to compile and validate resolved schema (in case it's not already)
+    if (compileRemote) {
+      report.path.push(remotePath);
+
+      let remoteReport;
+
+      const anscestorReport = report.getAncestor(result.id);
+      if (anscestorReport) {
+        remoteReport = anscestorReport;
+      } else {
+        remoteReport = new Report(report);
+        if (compileSchema.call(this, remoteReport, result)) {
+          const savedOptions = this.options;
+          try {
+            // If custom validationOptions were provided to setRemoteReference(),
+            // use them instead of the default options
+            this.options = result.__$validationOptions || this.options;
+            SchemaValidation.validateSchema.call(this, remoteReport, result);
+          } finally {
+            this.options = savedOptions;
+          }
+        }
+      }
+      const remoteReportIsValid = remoteReport.isValid();
+      if (!remoteReportIsValid) {
+        report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
+      }
+
+      report.path.pop();
+
+      if (!remoteReportIsValid) {
+        return undefined;
+      }
+    }
+  }
+
+  if (result && queryPath) {
+    const parts = queryPath.split('/');
+    for (let idx = 0, lim = parts.length; result && idx < lim; idx++) {
+      const key = decodeJSONPointer(parts[idx]);
+      if (idx === 0) {
+        // it's an id
+        result = findId(result, key);
+      } else {
+        // it's a path behind id
+        result = result[key];
+      }
+    }
+  }
+
+  return result;
+}