@hey-api/json-schema-ref-parser 1.0.8 → 1.1.0

package/dist/lib/index.js

@@ -53,9 +53,9 @@ const getResolvedInput = ({ pathOrUrlOrSchema, }) => {
         throw (0, ono_1.ono)(`Expected a file path, URL, or object. Got ${pathOrUrlOrSchema}`);
     }
     const resolvedInput = {
-        path: typeof pathOrUrlOrSchema === 'string' ? pathOrUrlOrSchema : '',
+        path: typeof pathOrUrlOrSchema === "string" ? pathOrUrlOrSchema : "",
         schema: undefined,
-        type: 'url',
+        type: "url",
     };
     // If the path is a filesystem path, then convert it to a URL.
     // NOTE: According to the JSON Reference spec, these should already be URLs,
@@ -65,22 +65,22 @@ const getResolvedInput = ({ pathOrUrlOrSchema, }) => {
     // If it doesn't work for your use-case, then use a URL instead.
     if (resolvedInput.path && url.isFileSystemPath(resolvedInput.path)) {
         resolvedInput.path = url.fromFileSystemPath(resolvedInput.path);
-        resolvedInput.type = 'file';
+        resolvedInput.type = "file";
     }
-    else if (!resolvedInput.path && pathOrUrlOrSchema && typeof pathOrUrlOrSchema === 'object') {
+    else if (!resolvedInput.path && pathOrUrlOrSchema && typeof pathOrUrlOrSchema === "object") {
         if ("$id" in pathOrUrlOrSchema && pathOrUrlOrSchema.$id) {
             // when schema id has defined an URL should use that hostname to request the references,
             // instead of using the current page URL
             const { hostname, protocol } = new URL(pathOrUrlOrSchema.$id);
             resolvedInput.path = `${protocol}//${hostname}:${protocol === "https:" ? 443 : 80}`;
-            resolvedInput.type = 'url';
+            resolvedInput.type = "url";
         }
         else {
             resolvedInput.schema = pathOrUrlOrSchema;
-            resolvedInput.type = 'json';
+            resolvedInput.type = "json";
         }
     }
-    if (resolvedInput.type !== 'json') {
+    if (resolvedInput.type !== "json") {
         // resolve the absolute path of the schema
         resolvedInput.path = url.resolve(url.cwd(), resolvedInput.path);
     }
@@ -181,17 +181,17 @@ class $RefParser {
         if (schema) {
             // immediately add a new $Ref with the schema object as value
             const $ref = this.$refs._add(path);
-            $ref.pathType = url.isFileSystemPath(path) ? 'file' : 'http';
+            $ref.pathType = url.isFileSystemPath(path) ? "file" : "http";
             $ref.value = schema;
         }
-        else if (type !== 'json') {
+        else if (type !== "json") {
             const file = (0, parse_js_1.newFile)(path);
             // Add a new $Ref for this file, even though we don't have the value yet.
             // This ensures that we don't simultaneously read & parse the same file multiple times
             const $refAdded = this.$refs._add(file.url);
             $refAdded.pathType = type;
             try {
-                const resolver = type === 'file' ? file_js_1.fileResolver : url_js_1.urlResolver;
+                const resolver = type === "file" ? file_js_1.fileResolver : url_js_1.urlResolver;
                 await resolver.handler({
                     arrayBuffer,
                     fetch,
@@ -208,7 +208,7 @@ class $RefParser {
                 throw err;
             }
         }
-        if (schema === null || typeof schema !== 'object' || Buffer.isBuffer(schema)) {
+        if (schema === null || typeof schema !== "object" || Buffer.isBuffer(schema)) {
             throw ono_1.ono.syntax(`"${this.$refs._root$Ref.path || schema}" is not a valid JSON Schema`);
         }
         this.schema = schema;

package/lib/__tests__/bundle.test.ts

@@ -17,24 +17,18 @@ describe("bundle", () => {
     const pathOrUrlOrSchema = path.resolve("lib", "__tests__", "spec", "multiple-refs.json");
     const schema = (await refParser.bundle({ pathOrUrlOrSchema })) as any;
 
-    // First reference should be fully resolved (no $ref)
-    expect(schema.paths["/test1/{pathId}"].get.parameters[0].name).toBe("pathId");
-    expect(schema.paths["/test1/{pathId}"].get.parameters[0].schema.type).toBe("string");
-    expect(schema.paths["/test1/{pathId}"].get.parameters[0].schema.format).toBe("uuid");
-    expect(schema.paths["/test1/{pathId}"].get.parameters[0].$ref).toBeUndefined();
-
-    // Second reference should be remapped to point to the first reference
-    expect(schema.paths["/test2/{pathId}"].get.parameters[0].$ref).toBe(
-      "#/paths/~1test1~1%7BpathId%7D/get/parameters/0",
-    );
-
-    // Both should effectively resolve to the same data
+    // Both parameters should now be $ref to the same internal definition
     const firstParam = schema.paths["/test1/{pathId}"].get.parameters[0];
     const secondParam = schema.paths["/test2/{pathId}"].get.parameters[0];
 
-    // The second parameter should resolve to the same data as the first
-    expect(secondParam.$ref).toBeDefined();
-    expect(firstParam).toEqual({
+    // The $ref should match the output structure in file_context_0
+    expect(firstParam.$ref).toBe("#/components/parameters/path-parameter_pathId");
+    expect(secondParam.$ref).toBe("#/components/parameters/path-parameter_pathId");
+
+    // The referenced parameter should exist and match the expected structure
+    expect(schema.components).toBeDefined();
+    expect(schema.components.parameters).toBeDefined();
+    expect(schema.components.parameters["path-parameter_pathId"]).toEqual({
       name: "pathId",
       in: "path",
       required: true,

package/lib/__tests__/pointer.test.ts

@@ -7,6 +7,7 @@ describe("pointer", () => {
     const refParser = new $RefParser();
     const pathOrUrlOrSchema = path.resolve("lib", "__tests__", "spec", "openapi-paths-ref.json");
     const schema = (await refParser.bundle({ pathOrUrlOrSchema })) as any;
+    console.log(JSON.stringify(schema, null, 2));
 
     // The GET endpoint should have its schema defined inline
     const getSchema = schema.paths["/foo"].get.responses["200"].content["application/json"].schema;
@@ -16,11 +17,11 @@ describe("pointer", () => {
 
     // The POST endpoint should have its schema inlined (copied) instead of a $ref
     const postSchema = schema.paths["/foo"].post.responses["200"].content["application/json"].schema;
-    expect(postSchema.$ref).toBeUndefined();
-    expect(postSchema.type).toBe("object");
-    expect(postSchema.properties.bar.type).toBe("string");
+    expect(postSchema.$ref).toBe("#/paths/~1foo/get/responses/200/content/application~1json/schema");
+    expect(postSchema.type).toBeUndefined();
+    expect(postSchema.properties?.bar?.type).toBeUndefined();
 
     // Both schemas should be identical objects
-    expect(postSchema).toEqual(getSchema);
+    expect(postSchema).not.toBe(getSchema);
   });
 });

package/lib/__tests__/spec/multiple-refs.json

@@ -5,7 +5,7 @@
         "summary": "First endpoint using the same pathId schema",
         "parameters": [
           {
-            "$ref": "path-parameter.json#/pathId"
+            "$ref": "path-parameter.json#/components/parameters/pathId"
           }
         ],
         "responses": {
@@ -20,7 +20,7 @@
         "summary": "Second endpoint using the same pathId schema",
         "parameters": [
           {
-            "$ref": "path-parameter.json#/pathId"
+            "$ref": "path-parameter.json#/components/parameters/pathId"
           }
         ],
         "responses": {

package/lib/__tests__/spec/path-parameter.json

@@ -1,12 +1,16 @@
 {
-  "pathId": {
-    "name": "pathId",
-    "in": "path",
-    "required": true,
-    "schema": {
-      "type": "string",
-      "format": "uuid",
-      "description": "Unique identifier for the path"
+  "components": {
+    "parameters": {
+      "pathId": {
+        "name": "pathId",
+        "in": "path",
+        "required": true,
+        "schema": {
+          "type": "string",
+          "format": "uuid",
+          "description": "Unique identifier for the path"
+        }
+      }
     }
   }
 }