z-schema 12.1.1 → 12.3.1

package/src/schema-compiler.ts

@@ -1,21 +1,21 @@
 import type { JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 
-import { getId, isInternalKey, NON_SCHEMA_KEYWORDS } from './json-schema.js';
+import { getId, isInternalKey, NON_SCHEMA_KEYWORDS_SET } from './json-schema.js';
 import { Report } from './report.js';
 import { DEFAULT_MAX_RECURSION_DEPTH } from './utils/constants.js';
 import { getRemotePath, isAbsoluteUri } from './utils/uri.js';
 import { getSchemaReader } from './z-schema-reader.js';
 
-const UNSAFE_TARGETS = [
+const UNSAFE_TARGETS = new Set<Record<string, unknown>>([
   Object.prototype as unknown as Record<string, unknown>,
   Function.prototype as unknown as Record<string, unknown>,
   Array.prototype as unknown as Record<string, unknown>,
-];
+]);
 
 /** Returns true if `obj` is a built-in prototype that must not be mutated. */
 function isUnsafeTarget(obj: Record<string, unknown>): boolean {
-  return UNSAFE_TARGETS.includes(obj);
+  return UNSAFE_TARGETS.has(obj);
 }
 
 /** Safely assign a property on `obj`, refusing prototype-polluting keys. */
@@ -47,10 +47,77 @@ interface Id {
   absoluteUri?: string;
 }
 
+const resolveReference = (base: string | undefined, ref: string) => {
+  if (isAbsoluteUri(ref)) {
+    return ref;
+  }
+
+  const baseStr = base ?? '';
+
+  if (ref.startsWith('#')) {
+    const hashIndex = baseStr.indexOf('#');
+    const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
+    return baseNoFrag + ref;
+  }
+
+  if (!baseStr) {
+    return ref;
+  }
+
+  const hashIndex = baseStr.indexOf('#');
+  const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
+
+  if (isAbsoluteUri(baseNoFrag)) {
+    try {
+      return new URL(ref, baseNoFrag).toString();
+    } catch {
+      // fall back to manual resolution below
+    }
+  }
+
+  let baseDir = baseNoFrag;
+  if (!baseDir.endsWith('/')) {
+    const lastSlash = baseDir.lastIndexOf('/');
+    baseDir = lastSlash === -1 ? '' : baseDir.slice(0, lastSlash + 1);
+  }
+  return baseDir + ref;
+};
+
+const isSimpleIdentifier = (id: string) =>
+  !id.startsWith('#') && !id.includes('/') && !id.includes('.') && !id.includes('#');
+
+const resolveIdScope = (base: string | undefined, id: string) => {
+  if (isAbsoluteUri(id)) {
+    return id;
+  }
+
+  const baseStr = base ?? '';
+
+  // Treat simple identifiers (no '/', '.', or '#') as same-document fragment ids
+  if (isSimpleIdentifier(id)) {
+    const hashIndex = baseStr.indexOf('#');
+    const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
+    return `${baseNoFrag}#${id}`;
+  }
+
+  return resolveReference(base, id);
+};
+
+const resolveSchemaScopeId = (base: string | undefined, schema: JsonSchemaInternal, id: string) => {
+  if (typeof schema.$id === 'string') {
+    return resolveReference(base, id);
+  }
+  return resolveIdScope(base, id);
+};
+
 export const collectIds = (obj: JsonSchemaInternal, maxDepth = DEFAULT_MAX_RECURSION_DEPTH) => {
   const ids: Id[] = [];
   function walk(node: any, scope: Id[], _depth = 0) {
-    if (typeof node !== 'object' || node == null) return;
+    if (typeof node !== 'object' || node == null) {
+      return;
+    }
+
+    const schemaNode = node as JsonSchemaInternal;
 
     if (_depth >= maxDepth) {
       throw new Error(
@@ -61,7 +128,7 @@ export const collectIds = (obj: JsonSchemaInternal, maxDepth = DEFAULT_MAX_RECUR
 
     let addedScope = false;
 
-    const nodeId = getId(node as JsonSchemaInternal);
+    const nodeId = getId(schemaNode);
     if (typeof nodeId === 'string') {
       let type: Id['type'] = isAbsoluteUri(nodeId) ? 'absolute' : 'relative';
       if (scope.length === 0) {
@@ -70,19 +137,30 @@ export const collectIds = (obj: JsonSchemaInternal, maxDepth = DEFAULT_MAX_RECUR
       const id: Id = {
         id: nodeId,
         type,
-        obj: node,
+        obj: schemaNode,
       };
       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 = resolveSchemaScopeId(node.id, node as JsonSchemaInternal, nodeId);
+      } else if (
+        type === 'root' &&
+        typeof schemaNode.id === 'string' &&
+        isAbsoluteUri(schemaNode.id) &&
+        schemaNode.id !== nodeId
+      ) {
+        id.absoluteUri = resolveSchemaScopeId(schemaNode.id, schemaNode, nodeId);
       } else if (type === 'relative') {
-        id.absoluteParent = scope
-          .filter((x) => x.type === 'absolute' || (x.type === 'root' && x.absoluteUri))
-          .slice(-1)[0];
+        let absoluteParent: Id | undefined;
+        for (let i = scope.length - 1; i >= 0; i--) {
+          const sc = scope[i];
+          if (sc.type === 'absolute' || (sc.type === 'root' && sc.absoluteUri)) {
+            absoluteParent = sc;
+            break;
+          }
+        }
+        id.absoluteParent = absoluteParent;
         if (id.absoluteParent) {
           const parentUri = id.absoluteParent.absoluteUri || id.absoluteParent.id;
-          id.absoluteUri = resolveSchemaScopeId(parentUri, node as JsonSchemaInternal, id.id);
+          id.absoluteUri = resolveSchemaScopeId(parentUri, schemaNode, id.id);
         }
       }
       ids.push(id);
@@ -95,9 +173,11 @@ export const collectIds = (obj: JsonSchemaInternal, maxDepth = DEFAULT_MAX_RECUR
         walk(item, scope, _depth + 1);
       }
     } else {
-      for (const key of Object.keys(node)) {
-        if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key as any)) continue;
-        walk(node[key], scope, _depth + 1);
+      for (const key of Object.keys(schemaNode)) {
+        if (isInternalKey(key) || NON_SCHEMA_KEYWORDS_SET.has(key)) {
+          continue;
+        }
+        walk((schemaNode as Record<string, unknown>)[key], scope, _depth + 1);
       }
     }
 
@@ -125,10 +205,10 @@ export const collectReferences = (
   maxDepth = DEFAULT_MAX_RECURSION_DEPTH,
   _depth = 0
 ) => {
-  results = results || [];
-  scope = scope || [];
-  path = path || [];
-  options = options || {};
+  results ||= [];
+  scope ||= [];
+  path ||= [];
+  options ||= {};
 
   if (typeof obj !== 'object' || obj === null) {
     return results;
@@ -141,7 +221,7 @@ export const collectReferences = (
     );
   }
 
-  const hasRef = typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined';
+  const hasRef = typeof obj.$ref === 'string' && obj.__$refResolved === undefined;
   let addedScope = false;
   const isRootScope = scope.length === 0;
   const objId = getId(obj);
@@ -151,40 +231,40 @@ export const collectReferences = (
   }
 
   if (typeof scopeId === 'string' && (isRootScope || !hasRef || options.useRefObjectScope === true)) {
-    const base = scope.length > 0 ? scope[scope.length - 1] : undefined;
+    const base = scope.length > 0 ? scope.at(-1) : undefined;
     scope.push(resolveSchemaScopeId(base, obj, scopeId));
     addedScope = true;
   }
 
   if (hasRef) {
     results.push({
-      ref: resolveReference(scope[scope.length - 1], obj.$ref!),
+      ref: resolveReference(scope.at(-1), obj.$ref!),
       key: '$ref',
-      obj: obj,
+      obj,
       path: path.slice(0),
     });
   }
-  if (typeof obj.$recursiveRef === 'string' && typeof obj.__$recursiveRefResolved === 'undefined') {
+  if (typeof obj.$recursiveRef === 'string' && obj.__$recursiveRefResolved === undefined) {
     results.push({
-      ref: resolveReference(scope[scope.length - 1], obj.$recursiveRef),
+      ref: resolveReference(scope.at(-1), obj.$recursiveRef),
       key: '$recursiveRef',
-      obj: obj,
+      obj,
       path: path.slice(0),
     });
   }
-  if (typeof obj.$dynamicRef === 'string' && typeof obj.__$dynamicRefResolved === 'undefined') {
+  if (typeof obj.$dynamicRef === 'string' && obj.__$dynamicRefResolved === undefined) {
     results.push({
-      ref: resolveReference(scope[scope.length - 1], obj.$dynamicRef),
+      ref: resolveReference(scope.at(-1), obj.$dynamicRef),
       key: '$dynamicRef',
-      obj: obj,
+      obj,
       path: path.slice(0),
     });
   }
-  if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
+  if (typeof obj.$schema === 'string' && obj.__$schemaResolved === undefined) {
     results.push({
-      ref: resolveReference(scope[scope.length - 1], obj.$schema),
+      ref: resolveReference(scope.at(-1), obj.$schema),
       key: '$schema',
-      obj: obj,
+      obj,
       path: path.slice(0),
     });
   }
@@ -192,18 +272,26 @@ export const collectReferences = (
   if (Array.isArray(obj)) {
     for (let i = 0; i < obj.length; i++) {
       path.push(i);
-      collectReferences(obj[i], results, scope, path, options, maxDepth, _depth + 1);
+      collectReferences(obj[i] as JsonSchemaInternal, results, scope, path, options, maxDepth, _depth + 1);
       path.pop();
     }
   } else {
     const keys = Object.keys(obj);
     for (const key of keys) {
       // do not recurse through resolved references and other z-schema props
-      if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key as any)) {
+      if (isInternalKey(key) || NON_SCHEMA_KEYWORDS_SET.has(key)) {
         continue;
       }
       path.push(key);
-      collectReferences((obj as any)[key], results, scope, path, options, maxDepth, _depth + 1);
+      collectReferences(
+        (obj as Record<string, JsonSchemaInternal>)[key],
+        results,
+        scope,
+        path,
+        options,
+        maxDepth,
+        _depth + 1
+      );
       path.pop();
     }
   }
@@ -215,70 +303,12 @@ export const collectReferences = (
   return results;
 };
 
-const resolveReference = (base: string | undefined, ref: string) => {
-  if (isAbsoluteUri(ref)) {
-    return ref;
-  }
-
-  const baseStr = base ?? '';
-
-  if (ref[0] === '#') {
-    const hashIndex = baseStr.indexOf('#');
-    const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
-    return baseNoFrag + ref;
-  }
-
-  if (!baseStr) {
-    return ref;
-  }
-
-  const hashIndex = baseStr.indexOf('#');
-  const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
-
-  if (isAbsoluteUri(baseNoFrag)) {
-    try {
-      return new URL(ref, baseNoFrag).toString();
-    } catch {
-      // fall back to manual resolution below
-    }
-  }
-
-  let baseDir = baseNoFrag;
-  if (!baseDir.endsWith('/')) {
-    const lastSlash = baseDir.lastIndexOf('/');
-    baseDir = lastSlash === -1 ? '' : baseDir.slice(0, lastSlash + 1);
-  }
-  return baseDir + ref;
-};
-
-const isSimpleIdentifier = (id: string) => id[0] !== '#' && !id.includes('/') && !id.includes('.') && !id.includes('#');
-
-const resolveIdScope = (base: string | undefined, id: string) => {
-  if (isAbsoluteUri(id)) {
-    return id;
-  }
-
-  const baseStr = base ?? '';
-
-  // Treat simple identifiers (no '/', '.', or '#') as same-document fragment ids
-  if (isSimpleIdentifier(id)) {
-    const hashIndex = baseStr.indexOf('#');
-    const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
-    return baseNoFrag + '#' + id;
-  }
-
-  return resolveReference(base, id);
-};
+export class SchemaCompiler {
+  private readonly validator: ZSchemaBase;
 
-const resolveSchemaScopeId = (base: string | undefined, schema: JsonSchemaInternal, id: string) => {
-  if (typeof schema.$id === 'string') {
-    return resolveReference(base, id);
+  constructor(validator: ZSchemaBase) {
+    this.validator = validator;
   }
-  return resolveIdScope(base, id);
-};
-
-export class SchemaCompiler {
-  constructor(private validator: ZSchemaBase) {}
 
   collectAndCacheIds(schema: JsonSchemaInternal) {
     const ids = collectIds(schema, this.validator.options.maxRecursionDepth);
@@ -303,7 +333,7 @@ export class SchemaCompiler {
     // if schema is a string, assume it's a uri
     if (typeof schema === 'string') {
       const loadedSchema = this.validator.scache.getSchemaByUri(report, schema);
-      if (typeof loadedSchema === 'undefined') {
+      if (loadedSchema === undefined) {
         report.addError('SCHEMA_NOT_REACHABLE', [schema]);
         return false;
       }
@@ -313,15 +343,16 @@ export class SchemaCompiler {
     // if schema is an array, assume it's an array of schemas
     if (Array.isArray(schema)) {
       if (!options?.noCache) {
-        schema.forEach((s) => this.collectAndCacheIds(s));
+        for (let i = 0; i < schema.length; i++) {
+          this.collectAndCacheIds(schema[i]);
+        }
       }
       return this.compileArrayOfSchemas(report, schema);
     } else if (typeof schema === 'boolean') {
       return true;
-    } else {
-      if (!options?.noCache) {
-        this.collectAndCacheIds(schema);
-      }
+    }
+    if (!options?.noCache) {
+      this.collectAndCacheIds(schema);
     }
 
     const canMutateSchemaObject =
@@ -334,7 +365,7 @@ export class SchemaCompiler {
       canMutateSchemaObject &&
       schema.__$compiled &&
       schema.id &&
-      this.validator.scache.checkCacheForUri(schema.id) === false
+      !this.validator.scache.checkCacheForUri(schema.id)
     ) {
       schema.__$compiled = undefined;
     }
@@ -383,7 +414,7 @@ export class SchemaCompiler {
       let response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
 
       // we can try to use custom schemaReader if available
-      if (typeof response === 'undefined') {
+      if (response === undefined) {
         const schemaReader = getSchemaReader();
         if (schemaReader) {
           const remotePath = getRemotePath(refObj.ref);
@@ -395,17 +426,19 @@ export class SchemaCompiler {
             (s as JsonSchemaInternal).id = remotePath;
             // 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 {
+            if (this.compileSchema(subreport, s)) {
               response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+            } else {
+              // copy errors to report
+              for (let i = 0; i < subreport.errors.length; i++) {
+                report.errors.push(subreport.errors[i]);
+              }
             }
           }
         }
       }
 
-      if (typeof response === 'undefined') {
+      if (response === undefined) {
         const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
         const isAbsolute = isAbsoluteUri(refObj.ref);
         let isDownloaded = false;
@@ -424,9 +457,12 @@ export class SchemaCompiler {
         } else if (isDownloaded) {
           // remote is downloaded, so no UNRESOLVABLE_REFERENCE
         } else {
-          report.path.push(...refObj.path);
+          const pathLen = refObj.path.length;
+          for (let i = 0; i < pathLen; i++) {
+            report.path.push(refObj.path[i]);
+          }
           report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
-          report.path = report.path.slice(0, -refObj.path.length);
+          report.path.length -= pathLen;
 
           // publish unresolved references out
           if (
@@ -434,7 +470,7 @@ export class SchemaCompiler {
             canMutateSchemaObject &&
             !isUnsafeTarget(schema as unknown as Record<string, unknown>)
           ) {
-            schema.__$missingReferences = schema.__$missingReferences || [];
+            schema.__$missingReferences ||= [];
             schema.__$missingReferences.push(refObj);
           }
         }
@@ -469,7 +505,13 @@ export class SchemaCompiler {
 
     do {
       // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
-      report.errors = report.errors.filter((e) => e.code !== 'UNRESOLVABLE_REFERENCE');
+      let wi = 0;
+      for (let ri = 0; ri < report.errors.length; ri++) {
+        if (report.errors[ri].code !== 'UNRESOLVABLE_REFERENCE') {
+          report.errors[wi++] = report.errors[ri];
+        }
+      }
+      report.errors.length = wi;
 
       // remember how many were compiled in the last loop
       lastLoopCompiled = compiled;
@@ -478,11 +520,20 @@ export class SchemaCompiler {
       compiled = this.compileArrayOfSchemasLoop(report, arr);
 
       // fix __$missingReferences if possible
+      // Keep the FIRST schema per id to match the prior `arr.find(x => x.id === ref)`
+      // semantics (first match wins) when an array contains duplicate ids.
+      const idMap = new Map<string, JsonSchemaInternal>();
+      for (let i = 0; i < arr.length; i++) {
+        const schemaId = arr[i].id;
+        if (schemaId && !idMap.has(schemaId)) {
+          idMap.set(schemaId, arr[i]);
+        }
+      }
       for (const sch of arr) {
         if (sch.__$missingReferences) {
           for (let idx2 = sch.__$missingReferences.length - 1; idx2 >= 0; idx2--) {
             const refObj = sch.__$missingReferences[idx2];
-            const response = arr.find((x) => x.id === refObj.ref);
+            const response = idMap.get(refObj.ref);
             if (response) {
               // this might create circular references
               safeSetProperty(refObj.obj as unknown as Record<string, unknown>, `__${refObj.key}Resolved`, response);
@@ -514,7 +565,9 @@ export class SchemaCompiler {
       }
 
       // copy errors to report
-      mainReport.errors = mainReport.errors.concat(report.errors);
+      for (let i = 0; i < report.errors.length; i++) {
+        mainReport.errors.push(report.errors[i]);
+      }
     }
 
     return compiledCount;