@apidevtools/json-schema-ref-parser 12.0.0 → 12.0.2

package/README.md

@@ -57,12 +57,12 @@ JavaScript objects.
 
 - Use **JSON** or **YAML** schemas — or even a mix of both!
 - Supports `$ref` pointers to external files and URLs, as well
-  as [custom sources](https://apitools.dev/json-schema-ref-parser/docs/plugins/resolvers.html) such as databases
-- Can [bundle](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#bundlepath-options-callback) multiple
+  as [custom sources](https://apidevtools.com/json-schema-ref-parser/docs/plugins/resolvers.html) such as databases
+- Can [bundle](https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundlepath-options-callback) multiple
   files into a single schema that only has _internal_ `$ref` pointers
-- Can [dereference](https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferencepath-options-callback)
+- Can [dereference](https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferencepath-options-callback)
   your schema, producing a plain-old JavaScript object that's easy to work with
-- Supports [circular references](https://apitools.dev/json-schema-ref-parser/docs/#circular-refs), nested references,
+- Supports [circular references](https://apidevtools.com/json-schema-ref-parser/docs/#circular-refs), nested references,
   back-references, and cross-references between files
 - Maintains object reference equality — `$ref` pointers to the same value always resolve to the same object
   instance
@@ -86,7 +86,7 @@ try {
 }
 ```
 
-For more detailed examples, please see the [API Documentation](https://apitools.dev/json-schema-ref-parser/docs/)
+For more detailed examples, please see the [API Documentation](https://apidevtools.com/json-schema-ref-parser/docs/)
 
 ## Polyfills
 
@@ -130,7 +130,7 @@ config.plugins.push(
 
 ## API Documentation
 
-Full API documentation is available [right here](https://apitools.dev/json-schema-ref-parser/docs/)
+Full API documentation is available [right here](https://apidevtools.com/json-schema-ref-parser/docs/)
 
 ## Contributing
 

package/dist/lib/bundle.js

@@ -80,10 +80,10 @@ function crawl(parent, key, path, pathFromRoot, indirections, inventory, $refs,
             const keys = Object.keys(obj).sort((a, b) => {
                 // Most people will expect references to be bundled into the the "definitions" property,
                 // so we always crawl that property first, if it exists.
-                if (a === "definitions") {
+                if (a === "definitions" || a === "$defs") {
                     return -1;
                 }
-                else if (b === "definitions") {
+                else if (b === "definitions" || b === "$defs") {
                     return 1;
                 }
                 else {
@@ -214,8 +214,8 @@ function remap(inventory) {
         else {
             // Determine how far each $ref is from the "definitions" property.
             // Most people will expect references to be bundled into the the "definitions" property if possible.
-            const aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
-            const bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
+            const aDefinitionsIndex = Math.max(a.pathFromRoot.lastIndexOf("/definitions"), a.pathFromRoot.lastIndexOf("/$defs"));
+            const bDefinitionsIndex = Math.max(b.pathFromRoot.lastIndexOf("/definitions"), b.pathFromRoot.lastIndexOf("/$defs"));
             if (aDefinitionsIndex !== bDefinitionsIndex) {
                 // Give higher priority to the $ref that's closer to the "definitions" property
                 return bDefinitionsIndex - aDefinitionsIndex;

package/dist/lib/dereference.js

@@ -174,24 +174,46 @@ function dereference$Ref($ref, path, pathFromRoot, parents, processedObjects, de
         //
         // If the cached object however is _not_ circular and there are additional keys alongside our
         // `$ref` pointer here we should merge them back in and return that.
-        if (cache.circular) {
+        if (!cache.circular) {
+            const refKeys = Object.keys($ref);
+            if (refKeys.length > 1) {
+                const extraKeys = {};
+                for (const key of refKeys) {
+                    if (key !== "$ref" && !(key in cache.value)) {
+                        // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
+                        extraKeys[key] = $ref[key];
+                    }
+                }
+                return {
+                    circular: cache.circular,
+                    value: Object.assign({}, cache.value, extraKeys),
+                };
+            }
             return cache;
         }
-        const refKeys = Object.keys($ref);
-        if (refKeys.length > 1) {
-            const extraKeys = {};
-            for (const key of refKeys) {
-                if (key !== "$ref" && !(key in cache.value)) {
-                    // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
-                    extraKeys[key] = $ref[key];
-                }
+        // If both our cached value and our incoming `$ref` are the same then we can return what we
+        // got out of the cache, otherwise we should re-process this value. We need to do this because
+        // the current dereference caching mechanism doesn't take into account that `$ref` are neither
+        // unique or reference the same file.
+        //
+        // For example if `schema.yaml` references `definitions/child.yaml` and
+        // `definitions/parent.yaml` references `child.yaml` then `$ref: 'child.yaml'` may get cached
+        // for `definitions/child.yaml`, resulting in `schema.yaml` being having an invalid reference
+        // to `child.yaml`.
+        //
+        // This check is not perfect and the design of the dereference caching mechanism needs a total
+        // overhaul.
+        if (typeof cache.value === "object" && "$ref" in cache.value && "$ref" in $ref) {
+            if (cache.value.$ref === $ref.$ref) {
+                return cache;
+            }
+            else {
+                // no-op
             }
-            return {
-                circular: cache.circular,
-                value: Object.assign({}, cache.value, extraKeys),
-            };
         }
-        return cache;
+        else {
+            return cache;
+        }
     }
     const pointer = $refs._resolve($refPath, path, options);
     if (pointer === null) {

package/dist/lib/pointer.js

@@ -40,7 +40,7 @@ exports.nullSymbol = void 0;
 const ref_js_1 = __importDefault(require("./ref.js"));
 const url = __importStar(require("./util/url.js"));
 const errors_js_1 = require("./util/errors.js");
-exports.nullSymbol = Symbol('null');
+exports.nullSymbol = Symbol("null");
 const slashes = /\//g;
 const tildes = /~/g;
 const escapedSlash = /~1/g;
@@ -93,9 +93,6 @@ class Pointer {
                 // The $ref path has changed, so append the remaining tokens to the path
                 this.path = Pointer.join(this.path, tokens.slice(i));
             }
-            if (typeof this.value === "object" && this.value !== null && !isRootPath(pathFromRoot) && "$ref" in this.value) {
-                return this;
-            }
             const token = tokens[i];
             if (this.value[token] === undefined || (this.value[token] === null && i === tokens.length - 1)) {
                 // one final case is if the entry itself includes slashes, and was parsed out as a token - we can join the remaining tokens and try again

package/dist/vite.config.js

@@ -14,5 +14,6 @@ exports.default = (0, config_1.defineConfig)({
         passWithNoTests: true,
         reporters: ["verbose"],
         coverage: { reporter: ["lcov", "html", "text"] },
+        snapshotSerializers: ["./test/utils/serializeJson.ts"],
     },
 });

package/lib/bundle.ts

@@ -76,9 +76,9 @@ function crawl<S extends object = JSONSchema, O extends ParserOptions<S> = Parse
       const keys = Object.keys(obj).sort((a, b) => {
         // Most people will expect references to be bundled into the the "definitions" property,
         // so we always crawl that property first, if it exists.
-        if (a === "definitions") {
+        if (a === "definitions" || a === "$defs") {
           return -1;
-        } else if (b === "definitions") {
+        } else if (b === "definitions" || b === "$defs") {
           return 1;
         } else {
           // Otherwise, crawl the keys based on their length.
@@ -216,8 +216,14 @@ function remap(inventory: InventoryEntry[]) {
     } else {
       // Determine how far each $ref is from the "definitions" property.
       // Most people will expect references to be bundled into the the "definitions" property if possible.
-      const aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
-      const bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
+      const aDefinitionsIndex = Math.max(
+        a.pathFromRoot.lastIndexOf("/definitions"),
+        a.pathFromRoot.lastIndexOf("/$defs"),
+      );
+      const bDefinitionsIndex = Math.max(
+        b.pathFromRoot.lastIndexOf("/definitions"),
+        b.pathFromRoot.lastIndexOf("/$defs"),
+      );
 
       if (aDefinitionsIndex !== bDefinitionsIndex) {
         // Give higher priority to the $ref that's closer to the "definitions" property

package/lib/dereference.ts

@@ -220,26 +220,46 @@ function dereference$Ref<S extends object = JSONSchema, O extends ParserOptions<
     //
     // If the cached object however is _not_ circular and there are additional keys alongside our
     // `$ref` pointer here we should merge them back in and return that.
-    if (cache.circular) {
+    if (!cache.circular) {
+      const refKeys = Object.keys($ref);
+      if (refKeys.length > 1) {
+        const extraKeys = {};
+        for (const key of refKeys) {
+          if (key !== "$ref" && !(key in cache.value)) {
+            // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
+            extraKeys[key] = $ref[key];
+          }
+        }
+        return {
+          circular: cache.circular,
+          value: Object.assign({}, cache.value, extraKeys),
+        };
+      }
+
       return cache;
     }
 
-    const refKeys = Object.keys($ref);
-    if (refKeys.length > 1) {
-      const extraKeys = {};
-      for (const key of refKeys) {
-        if (key !== "$ref" && !(key in cache.value)) {
-          // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
-          extraKeys[key] = $ref[key];
-        }
+    // If both our cached value and our incoming `$ref` are the same then we can return what we
+    // got out of the cache, otherwise we should re-process this value. We need to do this because
+    // the current dereference caching mechanism doesn't take into account that `$ref` are neither
+    // unique or reference the same file.
+    //
+    // For example if `schema.yaml` references `definitions/child.yaml` and
+    // `definitions/parent.yaml` references `child.yaml` then `$ref: 'child.yaml'` may get cached
+    // for `definitions/child.yaml`, resulting in `schema.yaml` being having an invalid reference
+    // to `child.yaml`.
+    //
+    // This check is not perfect and the design of the dereference caching mechanism needs a total
+    // overhaul.
+    if (typeof cache.value === "object" && "$ref" in cache.value && "$ref" in $ref) {
+      if (cache.value.$ref === $ref.$ref) {
+        return cache;
+      } else {
+        // no-op
       }
-      return {
-        circular: cache.circular,
-        value: Object.assign({}, cache.value, extraKeys),
-      };
+    } else {
+      return cache;
     }
-
-    return cache;
   }
 
   const pointer = $refs._resolve($refPath, path, options);

package/lib/index.ts

@@ -192,12 +192,7 @@ export class $RefParser<S extends object = JSONSchema, O extends ParserOptions<S
   public resolve(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
   public resolve(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
   public resolve(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-  public resolve(
-    path: string,
-    schema: S | string | unknown,
-    options: O,
-    callback: $RefsCallback<S, O>,
-  ): Promise<void>;
+  public resolve(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
   async resolve() {
     const args = normalizeArgs<S, O>(arguments);
 

package/lib/pointer.ts

@@ -5,7 +5,7 @@ import * as url from "./util/url.js";
 import { JSONParserError, InvalidPointerError, MissingPointerError, isHandledError } from "./util/errors.js";
 import type { JSONSchema } from "./types";
 
-export const nullSymbol = Symbol('null');
+export const nullSymbol = Symbol("null");
 
 const slashes = /\//g;
 const tildes = /~/g;
@@ -101,10 +101,6 @@ class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = Parser
         this.path = Pointer.join(this.path, tokens.slice(i));
       }
 
-      if (typeof this.value === "object" && this.value !== null && !isRootPath(pathFromRoot) && "$ref" in this.value) {
-        return this;
-      }
-
       const token = tokens[i];
 
       if (this.value[token] === undefined || (this.value[token] === null && i === tokens.length - 1)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apidevtools/json-schema-ref-parser",
-  "version": "12.0.0",
+  "version": "12.0.2",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "scripts": {
     "prepublishOnly": "yarn build",