z-schema 7.0.0 → 7.0.6

package/dist/FormatValidators.js

@@ -1,136 +0,0 @@
-import validator from 'validator';
-export const FormatValidators = {
-    date: function (date) {
-        if (typeof date !== 'string') {
-            return true;
-        }
-        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
-        const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
-        if (matches === null) {
-            return false;
-        }
-        // var year = matches[1];
-        // var month = matches[2];
-        // var day = matches[3];
-        if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
-            return false;
-        }
-        return true;
-    },
-    'date-time': function (dateTime) {
-        if (typeof dateTime !== 'string') {
-            return true;
-        }
-        // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
-        const s = dateTime.toLowerCase().split('t');
-        if (!FormatValidators.date(s[0])) {
-            return false;
-        }
-        const matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
-        if (matches === null) {
-            return false;
-        }
-        // var hour = matches[1];
-        // var minute = matches[2];
-        // var second = matches[3];
-        // var fraction = matches[4];
-        // var timezone = matches[5];
-        if (matches[1] > '23' || matches[2] > '59' || matches[3] > '59') {
-            return false;
-        }
-        return true;
-    },
-    email: function (email) {
-        if (typeof email !== 'string') {
-            return true;
-        }
-        return validator.isEmail(email, { require_tld: true });
-    },
-    hostname: function (hostname) {
-        if (typeof hostname !== 'string') {
-            return true;
-        }
-        /*
-                http://json-schema.org/latest/json-schema-validation.html#anchor114
-                A string instance is valid against this attribute if it is a valid
-                representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
-    
-                http://tools.ietf.org/html/rfc1034#section-3.5
-    
-                <digit> ::= any one of the ten digits 0 through 9
-                var digit = /[0-9]/;
-    
-                <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
-                var letter = /[a-zA-Z]/;
-    
-                <let-dig> ::= <letter> | <digit>
-                var letDig = /[0-9a-zA-Z]/;
-    
-                <let-dig-hyp> ::= <let-dig> | "-"
-                var letDigHyp = /[-0-9a-zA-Z]/;
-    
-                <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
-                var ldhStr = /[-0-9a-zA-Z]+/;
-    
-                <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
-                var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
-    
-                <subdomain> ::= <label> | <subdomain> "." <label>
-                var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
-    
-                <domain> ::= <subdomain> | " "
-                var domain = null;
-            */
-        const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
-        if (valid) {
-            // the sum of all label octets and label lengths is limited to 255.
-            if (hostname.length > 255) {
-                return false;
-            }
-            // Each node has a label, which is zero to 63 octets in length
-            const labels = hostname.split('.');
-            for (let i = 0; i < labels.length; i++) {
-                if (labels[i].length > 63) {
-                    return false;
-                }
-            }
-        }
-        return valid;
-    },
-    'host-name': function (hostname) {
-        return FormatValidators.hostname.call(this, hostname);
-    },
-    ipv4: function (ipv4) {
-        if (typeof ipv4 !== 'string') {
-            return true;
-        }
-        return validator.isIP(ipv4, 4);
-    },
-    ipv6: function (ipv6) {
-        if (typeof ipv6 !== 'string') {
-            return true;
-        }
-        return validator.isIP(ipv6, 6);
-    },
-    regex: function (str) {
-        try {
-            RegExp(str);
-            return true;
-        }
-        catch (_e) {
-            return false;
-        }
-    },
-    uri: function (...args) {
-        if (this.options.strictUris) {
-            return FormatValidators['strict-uri'].apply(this, args);
-        }
-        const [uri] = args;
-        // https://github.com/zaggino/z-schema/issues/18
-        // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
-        return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
-    },
-    'strict-uri': function (uri) {
-        return typeof uri !== 'string' || validator.isURL(uri);
-    },
-};

package/dist/SchemaCache.js

@@ -1,173 +0,0 @@
-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;
-}

package/dist/SchemaCompilation.js

@@ -1,259 +0,0 @@
-import { Report } from './Report.js';
-import { getSchemaByUri, checkCacheForUri, cacheSchemaByUri, removeFromCacheByUri } from './SchemaCache.js';
-import * as Utils from './Utils.js';
-function mergeReference(scope, ref) {
-    if (Utils.isAbsoluteUri(ref)) {
-        return ref;
-    }
-    let joinedScope = scope.join('');
-    const isScopeAbsolute = Utils.isAbsoluteUri(joinedScope);
-    const isScopeRelative = Utils.isRelativeUri(joinedScope);
-    const isRefRelative = Utils.isRelativeUri(ref);
-    let toRemove;
-    if (isScopeAbsolute && isRefRelative) {
-        toRemove = joinedScope.match(/\/[^/]*$/);
-        if (toRemove) {
-            joinedScope = joinedScope.slice(0, toRemove.index + 1);
-        }
-    }
-    else if (isScopeRelative && isRefRelative) {
-        joinedScope = '';
-    }
-    else {
-        toRemove = joinedScope.match(/[^#/]+$/);
-        if (toRemove) {
-            joinedScope = joinedScope.slice(0, toRemove.index);
-        }
-    }
-    let res = joinedScope + ref;
-    res = res.replace(/##/, '#');
-    return res;
-}
-function collectReferences(obj, results, scope, path) {
-    results = results || [];
-    scope = scope || [];
-    path = path || [];
-    if (typeof obj !== 'object' || obj === null) {
-        return results;
-    }
-    if (typeof obj.id === 'string') {
-        scope.push(obj.id);
-    }
-    if (typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined') {
-        results.push({
-            ref: mergeReference(scope, obj.$ref),
-            key: '$ref',
-            obj: obj,
-            path: path.slice(0),
-        });
-    }
-    if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
-        results.push({
-            ref: mergeReference(scope, obj.$schema),
-            key: '$schema',
-            obj: obj,
-            path: path.slice(0),
-        });
-    }
-    let idx;
-    if (Array.isArray(obj)) {
-        idx = obj.length;
-        while (idx--) {
-            path.push(idx.toString());
-            collectReferences(obj[idx], results, scope, path);
-            path.pop();
-        }
-    }
-    else {
-        const keys = Object.keys(obj);
-        idx = keys.length;
-        while (idx--) {
-            // do not recurse through resolved references and other z-schema props
-            if (keys[idx].indexOf('__$') === 0) {
-                continue;
-            }
-            path.push(keys[idx]);
-            collectReferences(obj[keys[idx]], results, scope, path);
-            path.pop();
-        }
-    }
-    if (typeof obj.id === 'string') {
-        scope.pop();
-    }
-    return results;
-}
-const compileArrayOfSchemasLoop = function (mainReport, arr) {
-    let idx = arr.length, compiledCount = 0;
-    while (idx--) {
-        // try to compile each schema separately
-        const report = new Report(mainReport);
-        const isValid = compileSchema.call(this, report, arr[idx]);
-        if (isValid) {
-            compiledCount++;
-        }
-        // copy errors to report
-        mainReport.errors = mainReport.errors.concat(report.errors);
-    }
-    return compiledCount;
-};
-function findId(arr, id) {
-    let idx = arr.length;
-    while (idx--) {
-        if (arr[idx].id === id) {
-            return arr[idx];
-        }
-    }
-    return null;
-}
-const compileArrayOfSchemas = function (report, arr) {
-    let compiled = 0, lastLoopCompiled;
-    do {
-        // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
-        let idx = report.errors.length;
-        while (idx--) {
-            if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
-                report.errors.splice(idx, 1);
-            }
-        }
-        // remember how many were compiled in the last loop
-        lastLoopCompiled = compiled;
-        // count how many are compiled now
-        compiled = compileArrayOfSchemasLoop.call(this, report, arr);
-        // fix __$missingReferences if possible
-        idx = arr.length;
-        while (idx--) {
-            const sch = arr[idx];
-            if (sch.__$missingReferences) {
-                let idx2 = sch.__$missingReferences.length;
-                while (idx2--) {
-                    const refObj = sch.__$missingReferences[idx2];
-                    const response = findId(arr, refObj.ref);
-                    if (response) {
-                        // this might create circular references
-                        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-                        // it's resolved now so delete it
-                        sch.__$missingReferences.splice(idx2, 1);
-                    }
-                }
-                if (sch.__$missingReferences.length === 0) {
-                    delete sch.__$missingReferences;
-                }
-            }
-        }
-        // keep repeating if not all compiled and at least one more was compiled in the last loop
-    } while (compiled !== arr.length && compiled !== lastLoopCompiled);
-    return report.isValid();
-};
-export function compileSchema(report, schema) {
-    report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
-    // if schema is a string, assume it's a uri
-    if (typeof schema === 'string') {
-        const loadedSchema = getSchemaByUri.call(this, report, schema);
-        if (!loadedSchema) {
-            report.addError('SCHEMA_NOT_REACHABLE', [schema]);
-            return false;
-        }
-        schema = loadedSchema;
-    }
-    // if schema is an array, assume it's an array of schemas
-    if (Array.isArray(schema)) {
-        return compileArrayOfSchemas.call(this, report, schema);
-    }
-    // if we have an id than it should be cached already (if this instance has compiled it)
-    if (schema.__$compiled && schema.id && checkCacheForUri.call(this, schema.id) === false) {
-        schema.__$compiled = undefined;
-    }
-    // do not re-compile schemas
-    if (schema.__$compiled) {
-        return true;
-    }
-    if (schema.id && typeof schema.id === 'string') {
-        // add this to our schemaCache (before compilation in case we have references including id)
-        cacheSchemaByUri.call(this, schema.id, schema);
-    }
-    // this method can be called recursively, so we need to remember our root
-    let isRoot = false;
-    if (!report.rootSchema) {
-        report.rootSchema = schema;
-        isRoot = true;
-    }
-    // delete all __$missingReferences from previous compilation attempts
-    const isValidExceptReferences = report.isValid();
-    delete schema.__$missingReferences;
-    // collect all references that need to be resolved - $ref and $schema
-    const refs = collectReferences.call(this, schema);
-    let idx = refs.length;
-    while (idx--) {
-        // resolve all the collected references into __xxxResolved pointer
-        const refObj = refs[idx];
-        let response = getSchemaByUri.call(this, report, refObj.ref, schema);
-        // we can try to use custom schemaReader if available
-        if (!response) {
-            const schemaReader = this.getSchemaReader();
-            if (schemaReader) {
-                // it's supposed to return a valid schema
-                const s = schemaReader(refObj.ref);
-                if (s) {
-                    // it needs to have the id
-                    s.id = refObj.ref;
-                    // try to compile the schema
-                    const subreport = new Report(report);
-                    if (!compileSchema.call(this, subreport, s)) {
-                        // copy errors to report
-                        report.errors = report.errors.concat(subreport.errors);
-                    }
-                    else {
-                        response = getSchemaByUri.call(this, report, refObj.ref, schema);
-                    }
-                }
-            }
-        }
-        if (!response) {
-            const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
-            const isAbsolute = Utils.isAbsoluteUri(refObj.ref);
-            let isDownloaded = false;
-            const ignoreUnresolvableRemotes = this.options.ignoreUnresolvableReferences === true;
-            if (isAbsolute) {
-                // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
-                // and set through setRemoteReference method
-                isDownloaded = checkCacheForUri.call(this, refObj.ref);
-            }
-            if (hasNotValid) {
-                // already has REMOTE_NOT_VALID error for this one
-            }
-            else if (ignoreUnresolvableRemotes && isAbsolute) {
-                // ignoreUnresolvableRemotes is on and remote isAbsolute
-            }
-            else if (isDownloaded) {
-                // remote is downloaded, so no UNRESOLVABLE_REFERENCE
-            }
-            else {
-                Array.prototype.push.apply(report.path, refObj.path);
-                report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
-                report.path = report.path.slice(0, -refObj.path.length);
-                // pusblish unresolved references out
-                if (isValidExceptReferences) {
-                    schema.__$missingReferences = schema.__$missingReferences || [];
-                    schema.__$missingReferences.push(refObj);
-                }
-            }
-        }
-        // this might create circular references
-        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-    }
-    const isValid = report.isValid();
-    if (isValid) {
-        schema.__$compiled = true;
-    }
-    else {
-        if (schema.id && typeof schema.id === 'string') {
-            // remove this schema from schemaCache because it failed to compile
-            removeFromCacheByUri.call(this, schema.id);
-        }
-    }
-    // we don't need the root pointer anymore
-    if (isRoot) {
-        report.rootSchema = undefined;
-    }
-    return isValid;
-}