z-schema 9.0.1 → 10.0.0

package/src/json-validation.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaAll, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ValidateOptions, ZSchemaBase } from './z-schema-base.js';
 
 import { getFormatValidators } from './format-validators.js';
@@ -24,7 +24,7 @@ const shouldSkipValidate = function (options: ValidateOptions, errors: any) {
 
 type JsonValidatorFn = (this: ZSchemaBase, report: Report, schema: JsonSchema, json: unknown) => void;
 
-export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
+export const JsonValidators: Record<keyof JsonSchemaAll, JsonValidatorFn> = {
   id: () => {},
   $ref: () => {},
   $schema: () => {},
@@ -63,8 +63,20 @@ export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
       }
     }
   },
-  exclusiveMaximum: function () {
-    // covered in maximum
+  exclusiveMaximum: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+    // In draft-06+, exclusiveMaximum is a standalone number
+    if (typeof schema.exclusiveMaximum === 'number') {
+      if (shouldSkipValidate(this.validateOptions, ['MAXIMUM_EXCLUSIVE'])) {
+        return;
+      }
+      if (typeof json !== 'number') {
+        return;
+      }
+      if (json >= schema.exclusiveMaximum) {
+        report.addError('MAXIMUM_EXCLUSIVE', [json, schema.exclusiveMaximum], undefined, schema, 'exclusiveMaximum');
+      }
+    }
+    // In draft-04, exclusiveMaximum is a boolean handled inside the `maximum` validator
   },
   minimum: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.2
@@ -84,8 +96,20 @@ export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
       }
     }
   },
-  exclusiveMinimum: function () {
-    // covered in minimum
+  exclusiveMinimum: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+    // In draft-06+, exclusiveMinimum is a standalone number
+    if (typeof schema.exclusiveMinimum === 'number') {
+      if (shouldSkipValidate(this.validateOptions, ['MINIMUM_EXCLUSIVE'])) {
+        return;
+      }
+      if (typeof json !== 'number') {
+        return;
+      }
+      if (json <= schema.exclusiveMinimum) {
+        report.addError('MINIMUM_EXCLUSIVE', [json, schema.exclusiveMinimum], undefined, schema, 'exclusiveMinimum');
+      }
+    }
+    // In draft-04, exclusiveMinimum is a boolean handled inside the `minimum` validator
   },
   maxLength: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
@@ -276,7 +300,11 @@ export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
       // for each regex in "pp", remove all elements of "s" which this regex matches.
       let idx = pp.length;
       while (idx--) {
-        const regExp = RegExp(pp[idx]);
+        const result = compileSchemaRegex(pp[idx]);
+        if (!result.ok) {
+          continue;
+        }
+        const regExp = result.value;
         let idx2 = s.length;
         while (idx2--) {
           if (regExp.test(s[idx2]) === true) {
@@ -596,6 +624,134 @@ export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
       report.addError('UNKNOWN_FORMAT', [schema.format!], undefined, schema, 'format');
     }
   },
+  // draft-06 additions
+  $id: () => {
+    // TODO: implement
+  },
+  const: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+    const constValue = (schema as JsonSchemaAll).const;
+    if (areEqual(json, constValue) === false) {
+      report.addError('CONST', [JSON.stringify(constValue)], undefined, schema, undefined);
+    }
+  },
+  contains: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+    if (shouldSkipValidate(this.validateOptions, ['CONTAINS'])) {
+      return;
+    }
+
+    if (!Array.isArray(json)) {
+      return;
+    }
+
+    const containsSchema = (schema as JsonSchemaAll).contains;
+    if (containsSchema === undefined) {
+      return;
+    }
+
+    const subReports: Report[] = [];
+    let idx = json.length;
+    while (idx--) {
+      const subReport = new Report(report);
+      subReports.push(subReport);
+      validate.call(this, subReport, containsSchema as any, json[idx]);
+    }
+
+    const asyncTasksBefore = report.asyncTasks.length;
+    for (const subReport of subReports) {
+      report.asyncTasks.push(...subReport.asyncTasks);
+    }
+    const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+
+    const addContainsErrorIfNeeded = () => {
+      let hasValidItem = false;
+      for (const subReport of subReports) {
+        if (subReport.errors.length === 0) {
+          hasValidItem = true;
+          break;
+        }
+      }
+      if (!hasValidItem) {
+        report.addError('CONTAINS', undefined, subReports, schema, undefined);
+      }
+    };
+
+    if (hasAsyncTasks) {
+      const pathBeforeAsync = shallowClone(report.path);
+      report.addAsyncTask(
+        (callback) => {
+          setTimeout(() => callback(null), 0);
+        },
+        [] as any,
+        () => {
+          const backup = report.path;
+          report.path = pathBeforeAsync;
+          addContainsErrorIfNeeded();
+          report.path = backup;
+        }
+      );
+      return;
+    }
+
+    addContainsErrorIfNeeded();
+  },
+  examples: () => {
+    // TODO: implement
+  },
+  propertyNames: function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+    if (shouldSkipValidate(this.validateOptions, ['PROPERTY_NAMES'])) {
+      return;
+    }
+
+    if (!isObject(json)) {
+      return;
+    }
+
+    const propertyNamesSchema = (schema as JsonSchemaAll).propertyNames;
+    if (propertyNamesSchema === undefined) {
+      return;
+    }
+
+    const keys = Object.keys(json);
+    const subReports: Report[] = [];
+    for (const key of keys) {
+      const subReport = new Report(report);
+      subReports.push(subReport);
+      validate.call(this, subReport, propertyNamesSchema as any, key);
+    }
+
+    const asyncTasksBefore = report.asyncTasks.length;
+    for (const subReport of subReports) {
+      report.asyncTasks.push(...subReport.asyncTasks);
+    }
+    const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+
+    const addPropertyNameErrors = () => {
+      for (let idx = 0; idx < keys.length; idx++) {
+        if (subReports[idx].errors.length > 0) {
+          report.addError('PROPERTY_NAMES', [keys[idx]], subReports[idx], schema, undefined);
+        }
+      }
+    };
+
+    if (hasAsyncTasks) {
+      const pathBeforeAsync = shallowClone(report.path);
+      report.addAsyncTask(
+        (callback) => {
+          setTimeout(() => callback(null), 0);
+        },
+        [] as any,
+        () => {
+          const backup = report.path;
+          report.path = pathBeforeAsync;
+          addPropertyNameErrors();
+          report.path = backup;
+        }
+      );
+      return;
+    }
+
+    addPropertyNameErrors();
+  },
 };
 
 const recurseArray = function (this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: Array<unknown>) {
@@ -623,7 +779,7 @@ const recurseArray = function (this: ZSchemaBase, report: Report, schema: JsonSc
         }
       }
     }
-  } else if (typeof schema.items === 'object') {
+  } else if (typeof schema.items === 'object' || typeof schema.items === 'boolean') {
     // If items is a schema, then the child instance must be valid against this schema,
     // regardless of its index, and regardless of the value of "additionalItems".
     while (idx--) {
@@ -673,7 +829,8 @@ const recurseObject = function (this: ZSchemaBase, report: Report, schema: JsonS
     let idx2 = pp.length;
     while (idx2--) {
       const regexString = pp[idx2];
-      if (RegExp(regexString).test(m) === true) {
+      const result = compileSchemaRegex(regexString);
+      if (result.ok && result.value.test(m) === true) {
         s.push(schema.patternProperties![regexString]);
       }
     }
@@ -710,13 +867,26 @@ const recurseObject = function (this: ZSchemaBase, report: Report, schema: JsonS
   }
 };
 
-export function validate(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown): boolean {
+export function validate(
+  this: ZSchemaBase,
+  report: Report,
+  schema: boolean | JsonSchemaInternal,
+  json: unknown
+): boolean {
   report.commonErrorMessage = 'JSON_OBJECT_VALIDATION_FAILED';
 
+  if (schema === true) {
+    return true;
+  }
+
+  if (schema === false) {
+    report.addError('SCHEMA_IS_FALSE', [], undefined, schema);
+    return false;
+  }
+
   // check if schema is an object
-  const to = whatIs(schema);
-  if (to !== 'object') {
-    report.addError('SCHEMA_NOT_AN_OBJECT', [to], undefined, schema);
+  if (!isObject(schema)) {
+    report.addError('SCHEMA_NOT_AN_OBJECT', [whatIs(schema)], undefined, schema);
     return false;
   }
 

package/src/report.ts

@@ -1,5 +1,5 @@
 import type { ErrorCode, ErrorParam } from './errors.js';
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ValidateCallback, ValidateOptions } from './z-schema-base.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 
@@ -7,7 +7,7 @@ import { Errors, getValidateError } from './errors.js';
 import { get } from './utils/json.js';
 import { jsonSymbol, schemaSymbol } from './utils/symbols.js';
 import { isAbsoluteUri } from './utils/uri.js';
-import { whatIs } from './utils/what-is.js';
+import { isObject } from './utils/what-is.js';
 
 export interface SchemaErrorDetail {
   /**
@@ -261,7 +261,7 @@ export class Report {
     errCode: ErrorCode,
     errParams?: ErrorParam[],
     subReports?: Report | Report[],
-    schema?: JsonSchema,
+    schema?: JsonSchema | boolean,
     keyword?: keyof JsonSchema
   ) {
     if (!errCode) {
@@ -286,7 +286,7 @@ export class Report {
     errorMessage: string,
     params?: ErrorParam[],
     subReports?: Report | Report[],
-    schema?: JsonSchema,
+    schema?: JsonSchema | boolean,
     keyword?: keyof JsonSchema
   ) {
     if (typeof this.reportOptions.maxErrors === 'number' && this.errors.length >= this.reportOptions.maxErrors) {
@@ -301,8 +301,7 @@ export class Report {
 
     let idx = params.length;
     while (idx--) {
-      const paramType = whatIs(params[idx]);
-      const param = paramType === 'object' || paramType === 'null' ? JSON.stringify(params[idx]) : params[idx];
+      const param = params[idx] === null || isObject(params[idx]) ? JSON.stringify(params[idx]) : params[idx];
       errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
     }
 

package/src/schema-cache.ts

@@ -1,7 +1,7 @@
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 
-import { findId } from './json-schema.js';
+import { findId, getId } from './json-schema.js';
 import { Report } from './report.js';
 import { deepClone } from './utils/clone.js';
 import { decodeJSONPointer } from './utils/json.js';
@@ -63,7 +63,9 @@ export class SchemaCache {
       return this.cache[path];
     }
     const asClone = (s: JsonSchema) => {
-      s.id ??= path;
+      if (!s.id || (!isAbsoluteUri(s.id) && isAbsoluteUri(path))) {
+        s.id = path;
+      }
       return deepClone(s);
     };
     found = SchemaCache.global_cache[path];
@@ -74,10 +76,30 @@ export class SchemaCache {
   }
 
   getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal) {
+    if (root && !isAbsoluteUri(uri)) {
+      let rootId = getId(root);
+      if ((!rootId || !isAbsoluteUri(rootId)) && typeof root.id === 'string' && isAbsoluteUri(root.id)) {
+        rootId = root.id;
+      }
+      if (rootId && isAbsoluteUri(rootId)) {
+        const hashIndex = rootId.indexOf('#');
+        const rootBase = hashIndex === -1 ? rootId : rootId.slice(0, hashIndex);
+        try {
+          uri = new URL(uri, rootBase).toString();
+        } catch {
+          // keep original uri when URL construction fails
+        }
+      }
+    }
+
     const remotePath = getRemotePath(uri);
     const queryPath = getQueryPath(uri);
     let result = remotePath ? this.fromCache(remotePath) : root;
 
+    if (result && remotePath && isAbsoluteUri(remotePath) && (!result.id || !isAbsoluteUri(result.id))) {
+      result.id = remotePath;
+    }
+
     if (result && remotePath) {
       // we need to avoid compiling schemas in a recursive loop
       const compileRemote = result !== root;

package/src/schema-compiler.ts

@@ -1,6 +1,7 @@
-import type { JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 
+import { getId } from './json-schema.js';
 import { Report } from './report.js';
 import { getRemotePath, isAbsoluteUri } from './utils/uri.js';
 import { getSchemaReader } from './z-schema-reader.js';
@@ -15,29 +16,34 @@ interface Id {
 
 export const collectIds = (obj: JsonSchemaInternal) => {
   const ids: Id[] = [];
+  const doNotCollectIdsFrom = ['enum', 'const', 'default', 'examples'];
   function walk(node: any, scope: Id[]) {
     if (typeof node !== 'object' || node == null) return;
 
     let addedScope = false;
 
-    if (node.id && typeof node.id === 'string') {
-      let type: Id['type'] = isAbsoluteUri(node.id) ? 'absolute' : 'relative';
+    const nodeId = getId(node as JsonSchemaInternal);
+    if (typeof nodeId === 'string') {
+      let type: Id['type'] = isAbsoluteUri(nodeId) ? 'absolute' : 'relative';
       if (scope.length === 0) {
         type = 'root';
       }
       const id: Id = {
-        id: node.id,
+        id: nodeId,
         type,
         obj: node,
       };
-      if (type === 'absolute' || (type === 'root' && isAbsoluteUri(node.id))) {
-        id.absoluteUri = node.id;
+      if (type === 'absolute' || (type === 'root' && isAbsoluteUri(nodeId))) {
+        id.absoluteUri = nodeId;
+      } else if (type === 'root' && typeof node.id === 'string' && isAbsoluteUri(node.id) && node.id !== nodeId) {
+        id.absoluteUri = resolveIdScope(node.id, nodeId);
       } else if (type === 'relative') {
         id.absoluteParent = scope
           .filter((x) => x.type === 'absolute' || (x.type === 'root' && x.absoluteUri))
           .slice(-1)[0];
         if (id.absoluteParent) {
-          id.absoluteUri = id.absoluteParent.id.split('/').slice(0, -1).concat(id.id).join('/');
+          const parentUri = id.absoluteParent.absoluteUri || id.absoluteParent.id;
+          id.absoluteUri = parentUri.split('/').slice(0, -1).concat(id.id).join('/');
         }
       }
       ids.push(id);
@@ -51,7 +57,7 @@ export const collectIds = (obj: JsonSchemaInternal) => {
       }
     } else {
       for (const key of Object.keys(node)) {
-        if (key.indexOf('__$') === 0) continue;
+        if (key.indexOf('__$') === 0 || doNotCollectIdsFrom.includes(key)) continue;
         walk(node[key], scope);
       }
     }
@@ -71,7 +77,7 @@ export interface Reference {
   path: Array<string | number>;
 }
 
-const doNotCollectReferencesFrom = ['enum'];
+const doNotCollectReferencesFrom = ['enum', 'const', 'default', 'examples'];
 
 export const collectReferences = (
   obj: JsonSchemaInternal,
@@ -90,9 +96,15 @@ export const collectReferences = (
   const hasRef = typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined';
   let addedScope = false;
   const isRootScope = scope.length === 0;
-  if (typeof obj.id === 'string' && (isRootScope || !hasRef)) {
+  const objId = getId(obj);
+  let scopeId = objId;
+  if (typeof obj.id === 'string' && isAbsoluteUri(obj.id) && (!scopeId || !isAbsoluteUri(scopeId))) {
+    scopeId = obj.id;
+  }
+
+  if (typeof scopeId === 'string' && (isRootScope || !hasRef)) {
     const base = scope.length > 0 ? scope[scope.length - 1] : undefined;
-    scope.push(resolveIdScope(base, obj.id));
+    scope.push(resolveIdScope(base, scopeId));
     addedScope = true;
   }
 
@@ -227,6 +239,8 @@ export class SchemaCompiler {
         schema.forEach((s) => this.collectAndCacheIds(s));
       }
       return this.compileArrayOfSchemas(report, schema);
+    } else if (typeof schema === 'boolean') {
+      return true;
     } else {
       if (!options?.noCache) {
         this.collectAndCacheIds(schema);