z-schema 6.0.2 → 7.0.0-beta.1

package/dist/Report.js

@@ -0,0 +1,220 @@
+import get from 'lodash.get';
+import { Errors } from './Errors.js';
+import * as Utils from './Utils.js';
+export class Report {
+    errors;
+    parentReport;
+    options;
+    reportOptions;
+    path;
+    asyncTasks;
+    rootSchema;
+    commonErrorMessage;
+    json;
+    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() {
+        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) {
+            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, errorMessage, params, subReports, schema) {
+        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 = {
+            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 → dist}/SchemaCache.js

@@ -1,69 +1,64 @@
-"use strict";
-
-var isequal             = require("lodash.isequal");
-var Report              = require("./Report");
-var SchemaCompilation   = require("./SchemaCompilation");
-var SchemaValidation    = require("./SchemaValidation");
-var Utils               = require("./Utils");
-
+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" ? "/" : "~";
+        return x === '~1' ? '/' : '~';
     });
 }
-
-function getRemotePath(uri) {
-    var io = uri.indexOf("#");
+export function getRemotePath(uri) {
+    const io = uri.indexOf('#');
     return io === -1 ? uri : uri.slice(0, io);
 }
-
 function getQueryPath(uri) {
-    var io = uri.indexOf("#");
-    var res = io === -1 ? undefined : uri.slice(io + 1);
+    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) {
+    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) {
+        if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
             return schema;
         }
     }
-
-    var idx, result;
+    let idx, result;
     if (Array.isArray(schema)) {
         idx = schema.length;
         while (idx--) {
             result = findId(schema[idx], id);
-            if (result) { return result; }
+            if (result) {
+                return result;
+            }
         }
-    } else {
-        var keys = Object.keys(schema);
+    }
+    else {
+        const keys = Object.keys(schema);
         idx = keys.length;
         while (idx--) {
-            var k = keys[idx];
-            if (k.indexOf("__$") === 0) {
+            const k = keys[idx];
+            if (k.indexOf('__$') === 0) {
                 continue;
             }
             result = findId(schema[k], id);
-            if (result) { return result; }
+            if (result) {
+                return result;
+            }
         }
     }
 }
-
 /**
  *
  * @param {*} uri
@@ -71,118 +66,108 @@ function findId(schema, id) {
  *
  * @returns {void}
  */
-exports.cacheSchemaByUri = function (uri, schema) {
-    var remotePath = getRemotePath(uri);
+export function cacheSchemaByUri(uri, schema) {
+    const remotePath = getRemotePath(uri);
     if (remotePath) {
         this.cache[remotePath] = schema;
     }
-};
-
+}
 /**
  *
  * @param {*} uri
  *
  * @returns {void}
  */
-exports.removeFromCacheByUri = function (uri) {
-    var remotePath = getRemotePath(uri);
+export function removeFromCacheByUri(uri) {
+    const remotePath = getRemotePath(uri);
     if (remotePath) {
         delete this.cache[remotePath];
     }
-};
-
+}
 /**
  *
  * @param {*} uri
  *
  * @returns {boolean}
  */
-exports.checkCacheForUri = function (uri) {
-    var remotePath = getRemotePath(uri);
+export function checkCacheForUri(uri) {
+    const remotePath = getRemotePath(uri);
     return remotePath ? this.cache[remotePath] != null : false;
-};
-
-exports.getSchema = function (report, schema) {
-    if (typeof schema === "object") {
-        schema = exports.getSchemaByReference.call(this, report, schema);
+}
+export function getSchema(report, schema) {
+    if (typeof schema === 'object') {
+        schema = getSchemaByReference.call(this, report, schema);
     }
-    if (typeof schema === "string") {
-        schema = exports.getSchemaByUri.call(this, report, schema);
+    if (typeof schema === 'string') {
+        schema = getSchemaByUri.call(this, report, schema);
     }
     return schema;
-};
-
-exports.getSchemaByReference = function (report, key) {
-    var i = this.referenceCache.length;
+}
+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
-    var schema = Utils.cloneDeep(key);
+    const schema = Utils.cloneDeep(key);
     this.referenceCache.push([key, schema]);
     return schema;
-};
-
-exports.getSchemaByUri = function (report, uri, root) {
-    var remotePath = getRemotePath(uri),
-        queryPath = getQueryPath(uri),
-        result = remotePath ? this.cache[remotePath] : root;
-
+}
+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
-        var compileRemote = result !== root;
+        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);
-
-            var remoteReport;
-
-            var anscestorReport = report.getAncestor(result.id);
+            let remoteReport;
+            const anscestorReport = report.getAncestor(result.id);
             if (anscestorReport) {
                 remoteReport = anscestorReport;
-            } else {
+            }
+            else {
                 remoteReport = new Report(report);
-                if (SchemaCompilation.compileSchema.call(this, remoteReport, result)) {
-                    var savedOptions = this.options;
+                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 {
+                    }
+                    finally {
                         this.options = savedOptions;
                     }
                 }
             }
-            var remoteReportIsValid = remoteReport.isValid();
+            const remoteReportIsValid = remoteReport.isValid();
             if (!remoteReportIsValid) {
-                report.addError("REMOTE_NOT_VALID", [uri], remoteReport);
+                report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
             }
-
             report.path.pop();
-
             if (!remoteReportIsValid) {
                 return undefined;
             }
         }
     }
-
     if (result && queryPath) {
-        var parts = queryPath.split("/");
-        for (var idx = 0, lim = parts.length; result && idx < lim; idx++) {
-            var key = decodeJSONPointer(parts[idx]);
-            if (idx === 0) { // it's an id
+        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
+            }
+            else {
+                // it's a path behind id
                 result = result[key];
             }
         }
     }
-
     return result;
-};
-
-exports.getRemotePath = getRemotePath;
+}