z-schema 7.0.0 → 7.0.6

package/src/{Report.ts → report.ts}

@@ -1,7 +1,10 @@
 import get from 'lodash.get';
-import { Errors } from './Errors.js';
-import * as Utils from './Utils.js';
-import { ZSchemaOptions } from './ZSchema.js';
+import { ErrorCode, ErrorParam, Errors } from './errors.js';
+import { whatIs } from './utils/what-is.js';
+import { schemaSymbol, jsonSymbol } from './utils/symbols.js';
+import { ValidateCallback, ZSchemaOptions } from './z-schema.js';
+import { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import { isAbsoluteUri } from './utils/uri.js';
 
 export interface SchemaError extends Error {
   /**
@@ -36,12 +39,12 @@ export interface SchemaErrorDetail {
    * Format parameters that can be used to format a custom error message.
    * Example: ["string","array"]
    */
-  params: Array<string>;
+  params: ErrorParam[];
   /**
    * A JSON path indicating the location of the error.
    * Example: "#/projects/1"
    */
-  path: string | string[];
+  path: string | Array<string | number>;
   /**
    * The schema rule description, which is included for certain errors where
    * this information is useful (e.g. to describe a constraint).
@@ -70,35 +73,24 @@ type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
 type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
 
 export class Report {
-  errors: SchemaErrorDetail[];
+  asyncTasks: AsyncTask[] = [];
+  commonErrorMessage?: string;
+  errors: SchemaErrorDetail[] = [];
+  json?: unknown;
+  path: Array<number | string> = [];
+  rootSchema?: JsonSchemaInternal;
+
   parentReport?: Report;
   options: ZSchemaOptions;
   reportOptions: ReportOptions;
-  path: string[];
-  asyncTasks: AsyncTask[];
-  rootSchema?: {
-    id?: string;
-  };
-  commonErrorMessage?: string;
-  json?: unknown;
 
-  constructor(parentOrOptions, reportOptions?) {
+  constructor(zschemaOptions: ZSchemaOptions); // primary
+  constructor(parentReport: Report); // subreport
+  constructor(parentReport: Report, reportOptions: ReportOptions); // subreport with options
+  constructor(parentOrOptions: ZSchemaOptions | Report, reportOptions?: 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 {
@@ -108,11 +100,15 @@ export class Report {
     return this.errors.length === 0;
   }
 
-  addAsyncTask(fn, args, asyncTaskResultProcessFn) {
-    this.asyncTasks.push([fn, args, asyncTaskResultProcessFn]);
+  addAsyncTask<FV, FN extends (...args: any[]) => FV>(
+    fn: FN,
+    args: Parameters<FN>,
+    asyncTaskResultProcessFn: (result: ReturnType<FN>) => void
+  ) {
+    this.asyncTasks.push([fn, args, asyncTaskResultProcessFn as TaskProcessFn]);
   }
 
-  getAncestor(id) {
+  getAncestor(id: string): Report | undefined {
     if (!this.parentReport) {
       return undefined;
     }
@@ -122,7 +118,7 @@ export class Report {
     return this.parentReport.getAncestor(id);
   }
 
-  processAsyncTasks(timeout, callback) {
+  processAsyncTasks(timeout: number | undefined, callback: ValidateCallback) {
     const validationTimeout = timeout || 2000;
     let tasksCount = this.asyncTasks.length;
     let idx = tasksCount;
@@ -136,17 +132,15 @@ export class Report {
       }, 0);
     };
 
-    function respond(asyncTaskResultProcessFn: TaskProcessFn) {
-      return function (asyncTaskResult) {
-        if (timedOut) {
-          return;
-        }
-        asyncTaskResultProcessFn(asyncTaskResult);
-        if (--tasksCount === 0) {
-          finish();
-        }
-      };
-    }
+    const respond = (asyncTaskResultProcessFn: TaskProcessFn) => (asyncTaskResult: TaskResult) => {
+      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)) {
@@ -169,11 +163,8 @@ export class Report {
     }, validationTimeout);
   }
 
-  getPath(returnPathAsString) {
-    /**
-     * @type {string[]|string}
-     */
-    let path = [];
+  getPath(returnPathAsString?: boolean) {
+    let path: Array<string | number> = [];
     if (this.parentReport) {
       path = path.concat(this.parentReport.path);
     }
@@ -187,7 +178,7 @@ export class Report {
           .map(function (segment) {
             segment = segment.toString();
 
-            if (Utils.isAbsoluteUri(segment)) {
+            if (isAbsoluteUri(segment)) {
               return 'uri(' + segment + ')';
             }
 
@@ -199,13 +190,13 @@ export class Report {
     return path;
   }
 
-  getSchemaId() {
+  getSchemaId(): string | undefined {
     if (!this.rootSchema) {
-      return null;
+      return undefined;
     }
 
     // get the error path as an array
-    let path = [];
+    let path: Array<string | number> = [];
     if (this.parentReport) {
       path = path.concat(this.parentReport.path);
     }
@@ -224,17 +215,17 @@ export class Report {
     return this.rootSchema.id;
   }
 
-  hasError(errorCode, params) {
+  hasError(errCode: string, errParams: Array<any>) {
     let idx = this.errors.length;
     while (idx--) {
-      if (this.errors[idx].code === errorCode) {
+      if (this.errors[idx].code === errCode) {
         // 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]) {
+          if (this.errors[idx].params[idx2] !== errParams[idx2]) {
             match = false;
           }
         }
@@ -248,14 +239,15 @@ export class Report {
     return false;
   }
 
-  addError(errorCode, params, subReports?, schema?) {
-    if (!errorCode) {
+  addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema) {
+    if (!errCode) {
       throw new Error('No errorCode passed into addError()');
     }
-    this.addCustomError(errorCode, Errors[errorCode], params, subReports, schema);
+    this.addCustomError(errCode, Errors[errCode], errParams, subReports, schema);
   }
 
-  getJson() {
+  // this returns the root object being validated (the one passed into validator.validate)
+  getJson(): unknown {
     if (this.json) {
       return this.json;
     }
@@ -268,14 +260,11 @@ export class Report {
   addCustomError(
     errorCode: string,
     errorMessage: string,
-    params: string[],
-    subReports?: Report[] | Report,
-    schema?: {
-      title?: string;
-      description?: string;
-    }
+    params?: ErrorParam[],
+    subReports?: Report | Report[],
+    schema?: JsonSchema
   ) {
-    if (this.errors.length >= this.reportOptions.maxErrors) {
+    if (typeof this.reportOptions.maxErrors === 'number' && this.errors.length >= this.reportOptions.maxErrors) {
       return;
     }
 
@@ -287,9 +276,9 @@ export class Report {
 
     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 paramType = whatIs(params[idx]);
+      const param = paramType === 'object' || paramType === 'null' ? JSON.stringify(params[idx]) : params[idx];
+      errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
     }
 
     const err: SchemaErrorDetail = {
@@ -300,8 +289,9 @@ export class Report {
       schemaId: this.getSchemaId(),
     };
 
-    err[Utils.schemaSymbol] = schema;
-    err[Utils.jsonSymbol] = this.getJson();
+    // TODO v8: remove Symbol usage
+    (err as any)[schemaSymbol] = schema;
+    (err as any)[jsonSymbol] = this.getJson();
 
     if (schema && typeof schema === 'string') {
       err.description = schema;

package/src/schema-cache.ts

@@ -0,0 +1,122 @@
+import type { ZSchema } from './z-schema.js';
+import isequal from 'lodash.isequal';
+import { Report } from './report.js';
+import { findId, JsonSchemaInternal } from './json-schema.js';
+import { getQueryPath, getRemotePath } from './utils/uri.js';
+import { deepClone } from './utils/clone.js';
+import { decodeJSONPointer } from './utils/json.js';
+
+export type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
+export type ReferenceSchemaCacheStorage = Array<[JsonSchemaInternal, JsonSchemaInternal]>;
+
+export class SchemaCache {
+  cache: SchemaCacheStorage = {};
+  referenceCache: ReferenceSchemaCacheStorage = [];
+
+  constructor(private validator: ZSchema) {}
+
+  cacheSchemaByUri(uri: string, schema: JsonSchemaInternal) {
+    const remotePath = getRemotePath(uri);
+    if (remotePath) {
+      this.cache[remotePath] = schema;
+    }
+  }
+
+  removeFromCacheByUri(uri: string) {
+    const remotePath = getRemotePath(uri);
+    if (remotePath) {
+      delete this.cache[remotePath];
+    }
+  }
+
+  checkCacheForUri(uri: string) {
+    const remotePath = getRemotePath(uri);
+    return remotePath ? this.cache[remotePath] != null : false;
+  }
+
+  getSchema(report: Report, refOrSchema: string | JsonSchemaInternal) {
+    if (typeof refOrSchema === 'string') {
+      // ref input
+      return this.getSchemaByUri(report, refOrSchema);
+    }
+    if (typeof refOrSchema === 'object') {
+      // schema obj input
+      return this.getSchemaByReference(report, refOrSchema);
+    }
+    throw new Error(`unexpected code reached`);
+  }
+
+  getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal) {
+    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 = result.id ? report.getAncestor(result.id) : undefined;
+        if (anscestorReport) {
+          remoteReport = anscestorReport;
+        } else {
+          remoteReport = new Report(report);
+          if (this.validator.sc.compileSchema(remoteReport, result)) {
+            const savedOptions = this.validator.options;
+            try {
+              // If custom validationOptions were provided to setRemoteReference(),
+              // use them instead of the default options
+              this.validator.options = result.__$validationOptions || this.validator.options;
+              this.validator.sv.validateSchema(remoteReport, result);
+            } finally {
+              this.validator.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 as keyof typeof result] as JsonSchemaInternal | undefined;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  getSchemaByReference(report: Report, schema: JsonSchemaInternal) {
+    let i = this.referenceCache.length;
+    while (i--) {
+      if (isequal(this.referenceCache[i][0], schema)) {
+        return this.referenceCache[i][1];
+      }
+    }
+    // not found
+    const schemaClone = deepClone(schema);
+    this.referenceCache.push([schema, schemaClone]);
+    return schemaClone;
+  }
+}

package/src/schema-compiler.ts

@@ -0,0 +1,300 @@
+import type { ZSchema } from './z-schema.js';
+import { JsonSchemaInternal } from './json-schema.js';
+import { Report } from './report.js';
+import { isAbsoluteUri, isRelativeUri } from './utils/uri.js';
+
+export interface Reference {
+  ref: string;
+  key: '$ref' | '$schema';
+  obj: JsonSchemaInternal;
+  path: Array<string | number>;
+}
+
+const collectReferences = (
+  obj: JsonSchemaInternal,
+  results?: Reference[],
+  scope?: string[],
+  path?: Reference['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);
+      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 as any)[keys[idx]], results, scope, path);
+      path.pop();
+    }
+  }
+
+  if (typeof obj.id === 'string') {
+    scope.pop();
+  }
+
+  return results;
+};
+
+const mergeReference = (scope: string[], ref: string) => {
+  if (isAbsoluteUri(ref)) {
+    return ref;
+  }
+
+  let joinedScope = scope.join('');
+  const isScopeAbsolute = isAbsoluteUri(joinedScope);
+  const isScopeRelative = isRelativeUri(joinedScope);
+  const isRefRelative = 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;
+};
+
+export class SchemaCompiler {
+  constructor(private validator: ZSchema) {}
+
+  compileSchema(report: Report, schema: JsonSchemaInternal) {
+    report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
+
+    // if schema is a string, assume it's a uri
+    if (typeof schema === 'string') {
+      const loadedSchema = this.validator.scache.getSchemaByUri(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 this.compileArrayOfSchemas(report, schema);
+    }
+
+    // if we have an id than it should be cached already (if this instance has compiled it)
+    if (schema.__$compiled && schema.id && this.validator.scache.checkCacheForUri(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)
+      this.validator.scache.cacheSchemaByUri(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(schema);
+    let idx = refs.length;
+    while (idx--) {
+      // resolve all the collected references into __xxxResolved pointer
+      const refObj = refs[idx];
+      let response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+
+      // we can try to use custom schemaReader if available
+      if (!response) {
+        const schemaReader = this.validator.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 (!this.compileSchema(subreport, s)) {
+              // copy errors to report
+              report.errors = report.errors.concat(subreport.errors);
+            } else {
+              response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+            }
+          }
+        }
+      }
+
+      if (!response) {
+        const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
+        const isAbsolute = isAbsoluteUri(refObj.ref);
+        let isDownloaded = false;
+        const ignoreUnresolvableRemotes = this.validator.options.ignoreUnresolvableReferences === true;
+
+        if (isAbsolute) {
+          // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
+          // and set through setRemoteReference method
+          isDownloaded = this.validator.scache.checkCacheForUri(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 {
+          report.path.push(...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
+        this.validator.scache.removeFromCacheByUri(schema.id);
+      }
+    }
+
+    // we don't need the root pointer anymore
+    if (isRoot) {
+      report.rootSchema = undefined;
+    }
+
+    return isValid;
+  }
+
+  compileArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]) {
+    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 = this.compileArrayOfSchemasLoop(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 = arr.find((x) => x.id === 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();
+  }
+
+  compileArrayOfSchemasLoop(mainReport: Report, arr: JsonSchemaInternal[]) {
+    let idx = arr.length,
+      compiledCount = 0;
+
+    while (idx--) {
+      // try to compile each schema separately
+      const report = new Report(mainReport);
+      const isValid = this.compileSchema(report, arr[idx]);
+      if (isValid) {
+        compiledCount++;
+      }
+
+      // copy errors to report
+      mainReport.errors = mainReport.errors.concat(report.errors);
+    }
+
+    return compiledCount;
+  }
+}