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

package/dist/lib/__tests__/bundle.test.js

@@ -3,14 +3,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_path_1 = __importDefault(require("node:path"));
+const path_1 = __importDefault(require("path"));
 const vitest_1 = require("vitest");
 const __1 = require("..");
-(0, vitest_1.describe)('bundle', () => {
-    (0, vitest_1.it)('handles circular reference with description', async () => {
+(0, vitest_1.describe)("bundle", () => {
+    (0, vitest_1.it)("handles circular reference with description", async () => {
         const refParser = new __1.$RefParser();
-        const pathOrUrlOrSchema = node_path_1.default.resolve('lib', '__tests__', 'spec', 'circular-ref-with-description.json');
+        const pathOrUrlOrSchema = path_1.default.resolve("lib", "__tests__", "spec", "circular-ref-with-description.json");
         const schema = await refParser.bundle({ pathOrUrlOrSchema });
         (0, vitest_1.expect)(schema).not.toBeUndefined();
     });
+    (0, vitest_1.it)("bundles multiple references to the same file correctly", async () => {
+        const refParser = new __1.$RefParser();
+        const pathOrUrlOrSchema = path_1.default.resolve("lib", "__tests__", "spec", "multiple-refs.json");
+        const schema = (await refParser.bundle({ pathOrUrlOrSchema }));
+        // First reference should be fully resolved (no $ref)
+        (0, vitest_1.expect)(schema.paths["/test1/{pathId}"].get.parameters[0].name).toBe("pathId");
+        (0, vitest_1.expect)(schema.paths["/test1/{pathId}"].get.parameters[0].schema.type).toBe("string");
+        (0, vitest_1.expect)(schema.paths["/test1/{pathId}"].get.parameters[0].schema.format).toBe("uuid");
+        (0, vitest_1.expect)(schema.paths["/test1/{pathId}"].get.parameters[0].$ref).toBeUndefined();
+        // Second reference should be remapped to point to the first reference
+        (0, vitest_1.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
+        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
+        (0, vitest_1.expect)(secondParam.$ref).toBeDefined();
+        (0, vitest_1.expect)(firstParam).toEqual({
+            name: "pathId",
+            in: "path",
+            required: true,
+            schema: {
+                type: "string",
+                format: "uuid",
+                description: "Unique identifier for the path",
+            },
+        });
+    });
 });

package/dist/lib/__tests__/index.test.js

@@ -6,38 +6,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
 const vitest_1 = require("vitest");
 const index_1 = require("../index");
-(0, vitest_1.describe)('getResolvedInput', () => {
-    (0, vitest_1.it)('handles url', async () => {
-        const pathOrUrlOrSchema = 'https://foo.com';
+(0, vitest_1.describe)("getResolvedInput", () => {
+    (0, vitest_1.it)("handles url", async () => {
+        const pathOrUrlOrSchema = "https://foo.com";
         const resolvedInput = await (0, index_1.getResolvedInput)({ pathOrUrlOrSchema });
-        (0, vitest_1.expect)(resolvedInput.type).toBe('url');
+        (0, vitest_1.expect)(resolvedInput.type).toBe("url");
         (0, vitest_1.expect)(resolvedInput.schema).toBeUndefined();
-        (0, vitest_1.expect)(resolvedInput.path).toBe('https://foo.com/');
+        (0, vitest_1.expect)(resolvedInput.path).toBe("https://foo.com/");
     });
-    (0, vitest_1.it)('handles file', async () => {
-        const pathOrUrlOrSchema = './path/to/openapi.json';
+    (0, vitest_1.it)("handles file", async () => {
+        const pathOrUrlOrSchema = "./path/to/openapi.json";
         const resolvedInput = await (0, index_1.getResolvedInput)({ pathOrUrlOrSchema });
-        (0, vitest_1.expect)(resolvedInput.type).toBe('file');
+        (0, vitest_1.expect)(resolvedInput.type).toBe("file");
         (0, vitest_1.expect)(resolvedInput.schema).toBeUndefined();
-        (0, vitest_1.expect)(resolvedInput.path).toBe(node_path_1.default.resolve('./path/to/openapi.json'));
+        (0, vitest_1.expect)(node_path_1.default.normalize(resolvedInput.path).toLowerCase()).toBe(node_path_1.default.normalize(node_path_1.default.resolve("./path/to/openapi.json")).toLowerCase());
     });
-    (0, vitest_1.it)('handles raw spec', async () => {
+    (0, vitest_1.it)("handles raw spec", async () => {
         const pathOrUrlOrSchema = {
             info: {
-                version: '1.0.0',
+                version: "1.0.0",
             },
-            openapi: '3.1.0',
+            openapi: "3.1.0",
             paths: {},
         };
         const resolvedInput = await (0, index_1.getResolvedInput)({ pathOrUrlOrSchema });
-        (0, vitest_1.expect)(resolvedInput.type).toBe('json');
+        (0, vitest_1.expect)(resolvedInput.type).toBe("json");
         (0, vitest_1.expect)(resolvedInput.schema).toEqual({
             info: {
-                version: '1.0.0',
+                version: "1.0.0",
             },
-            openapi: '3.1.0',
+            openapi: "3.1.0",
             paths: {},
         });
-        (0, vitest_1.expect)(resolvedInput.path).toBe('');
+        (0, vitest_1.expect)(resolvedInput.path).toBe("");
     });
 });

package/dist/lib/__tests__/pointer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/pointer.test.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const __1 = require("..");
+const path_1 = __importDefault(require("path"));
+(0, vitest_1.describe)("pointer", () => {
+    (0, vitest_1.it)("inlines internal JSON Pointer refs under #/paths/ for OpenAPI bundling", async () => {
+        const refParser = new __1.$RefParser();
+        const pathOrUrlOrSchema = path_1.default.resolve("lib", "__tests__", "spec", "openapi-paths-ref.json");
+        const schema = (await refParser.bundle({ pathOrUrlOrSchema }));
+        // The GET endpoint should have its schema defined inline
+        const getSchema = schema.paths["/foo"].get.responses["200"].content["application/json"].schema;
+        (0, vitest_1.expect)(getSchema.$ref).toBeUndefined();
+        (0, vitest_1.expect)(getSchema.type).toBe("object");
+        (0, vitest_1.expect)(getSchema.properties.bar.type).toBe("string");
+        // 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;
+        (0, vitest_1.expect)(postSchema.$ref).toBeUndefined();
+        (0, vitest_1.expect)(postSchema.type).toBe("object");
+        (0, vitest_1.expect)(postSchema.properties.bar.type).toBe("string");
+        // Both schemas should be identical objects
+        (0, vitest_1.expect)(postSchema).toEqual(getSchema);
+    });
+});

package/dist/lib/bundle.js

@@ -74,9 +74,10 @@ const inventory$Ref = ({ $refKey, $refParent, $refs, indirections, inventory, op
     const external = file !== $refs._root$Ref.path;
     const extended = ref_js_1.default.isExtended$Ref($ref);
     indirections += pointer.indirections;
+    // Check if this exact location (parent + key + pathFromRoot) has already been inventoried
     const existingEntry = findInInventory(inventory, $refParent, $refKey);
-    if (existingEntry) {
-        // This $Ref has already been inventoried, so we don't need to process it again
+    if (existingEntry && existingEntry.pathFromRoot === pathFromRoot) {
+        // This exact location has already been inventoried, so we don't need to process it again
         if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
             removeFromInventory(inventory, existingEntry);
         }
@@ -248,7 +249,7 @@ function remap(inventory) {
     let file, hash, pathFromRoot;
     for (const entry of inventory) {
         // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
-        if (!entry.external) {
+        if (!entry.external && !entry.hash?.startsWith("#/paths/")) {
             // This $ref already resolves to the main JSON Schema file
             entry.$ref.$ref = entry.hash;
         }
@@ -312,7 +313,7 @@ const bundle = (parser, options) => {
     const inventory = [];
     crawl({
         parent: parser,
-        key: 'schema',
+        key: "schema",
         path: parser.$refs._root$Ref.path + "#",
         pathFromRoot: "#",
         indirections: 0,

package/lib/__tests__/bundle.test.ts

@@ -1,14 +1,48 @@
-import path from 'node:path';
+import path from "path";
 
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it } from "vitest";
 
-import { $RefParser } from '..';
+import { $RefParser } from "..";
 
-describe('bundle', () => {
-  it('handles circular reference with description', async () => {
+describe("bundle", () => {
+  it("handles circular reference with description", async () => {
     const refParser = new $RefParser();
-    const pathOrUrlOrSchema = path.resolve('lib', '__tests__', 'spec', 'circular-ref-with-description.json');
+    const pathOrUrlOrSchema = path.resolve("lib", "__tests__", "spec", "circular-ref-with-description.json");
     const schema = await refParser.bundle({ pathOrUrlOrSchema });
     expect(schema).not.toBeUndefined();
   });
+
+  it("bundles multiple references to the same file correctly", async () => {
+    const refParser = new $RefParser();
+    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
+    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({
+      name: "pathId",
+      in: "path",
+      required: true,
+      schema: {
+        type: "string",
+        format: "uuid",
+        description: "Unique identifier for the path",
+      },
+    });
+  });
 });

package/lib/__tests__/index.test.ts

@@ -1,43 +1,45 @@
-import path from 'node:path';
+import path from "node:path";
 
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it } from "vitest";
 
-import { getResolvedInput } from '../index';
+import { getResolvedInput } from "../index";
 
-describe('getResolvedInput', () => {
-  it('handles url', async () => {
-    const pathOrUrlOrSchema =  'https://foo.com';
+describe("getResolvedInput", () => {
+  it("handles url", async () => {
+    const pathOrUrlOrSchema = "https://foo.com";
     const resolvedInput = await getResolvedInput({ pathOrUrlOrSchema });
-    expect(resolvedInput.type).toBe('url');
+    expect(resolvedInput.type).toBe("url");
     expect(resolvedInput.schema).toBeUndefined();
-    expect(resolvedInput.path).toBe('https://foo.com/');
+    expect(resolvedInput.path).toBe("https://foo.com/");
   });
 
-  it('handles file', async () => {
-    const pathOrUrlOrSchema =  './path/to/openapi.json';
+  it("handles file", async () => {
+    const pathOrUrlOrSchema = "./path/to/openapi.json";
     const resolvedInput = await getResolvedInput({ pathOrUrlOrSchema });
-    expect(resolvedInput.type).toBe('file');
+    expect(resolvedInput.type).toBe("file");
     expect(resolvedInput.schema).toBeUndefined();
-    expect(resolvedInput.path).toBe(path.resolve('./path/to/openapi.json'));
+    expect(path.normalize(resolvedInput.path).toLowerCase()).toBe(
+      path.normalize(path.resolve("./path/to/openapi.json")).toLowerCase(),
+    );
   });
 
-  it('handles raw spec', async () => {
-    const pathOrUrlOrSchema =  {
+  it("handles raw spec", async () => {
+    const pathOrUrlOrSchema = {
       info: {
-        version: '1.0.0',
+        version: "1.0.0",
       },
-      openapi: '3.1.0',
+      openapi: "3.1.0",
       paths: {},
     };
     const resolvedInput = await getResolvedInput({ pathOrUrlOrSchema });
-    expect(resolvedInput.type).toBe('json');
+    expect(resolvedInput.type).toBe("json");
     expect(resolvedInput.schema).toEqual({
       info: {
-        version: '1.0.0',
+        version: "1.0.0",
       },
-      openapi: '3.1.0',
+      openapi: "3.1.0",
       paths: {},
     });
-    expect(resolvedInput.path).toBe('');
+    expect(resolvedInput.path).toBe("");
   });
 });

package/lib/__tests__/pointer.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { $RefParser } from "..";
+import path from "path";
+
+describe("pointer", () => {
+  it("inlines internal JSON Pointer refs under #/paths/ for OpenAPI bundling", async () => {
+    const refParser = new $RefParser();
+    const pathOrUrlOrSchema = path.resolve("lib", "__tests__", "spec", "openapi-paths-ref.json");
+    const schema = (await refParser.bundle({ pathOrUrlOrSchema })) as any;
+
+    // The GET endpoint should have its schema defined inline
+    const getSchema = schema.paths["/foo"].get.responses["200"].content["application/json"].schema;
+    expect(getSchema.$ref).toBeUndefined();
+    expect(getSchema.type).toBe("object");
+    expect(getSchema.properties.bar.type).toBe("string");
+
+    // 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");
+
+    // Both schemas should be identical objects
+    expect(postSchema).toEqual(getSchema);
+  });
+});

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

@@ -0,0 +1,34 @@
+{
+  "paths": {
+    "/test1/{pathId}": {
+      "get": {
+        "summary": "First endpoint using the same pathId schema",
+        "parameters": [
+          {
+            "$ref": "path-parameter.json#/pathId"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Test 1 response"
+          }
+        }
+      }
+    },
+    "/test2/{pathId}": {
+      "get": {
+        "summary": "Second endpoint using the same pathId schema",
+        "parameters": [
+          {
+            "$ref": "path-parameter.json#/pathId"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Test 2 response"
+          }
+        }
+      }
+    }
+  }
+}

package/lib/__tests__/spec/openapi-paths-ref.json

@@ -0,0 +1,46 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "Sample API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/foo": {
+      "get": {
+        "summary": "Get foo",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "bar": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "summary": "Create foo",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/paths/~1foo/get/responses/200/content/application~1json/schema"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

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

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

package/lib/bundle.ts

@@ -94,9 +94,10 @@ const inventory$Ref = <S extends object = JSONSchema>({
   const extended = $Ref.isExtended$Ref($ref);
   indirections += pointer.indirections;
 
+  // Check if this exact location (parent + key + pathFromRoot) has already been inventoried
   const existingEntry = findInInventory(inventory, $refParent, $refKey);
-  if (existingEntry) {
-    // This $Ref has already been inventoried, so we don't need to process it again
+  if (existingEntry && existingEntry.pathFromRoot === pathFromRoot) {
+    // This exact location has already been inventoried, so we don't need to process it again
     if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
       removeFromInventory(inventory, existingEntry);
     } else {
@@ -172,7 +173,7 @@ const crawl = <S extends object = JSONSchema>({
   pathFromRoot: string;
 }) => {
   const obj = key === null ? parent : parent[key as keyof typeof parent];
-  
+
   if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
     if ($Ref.isAllowed$Ref(obj)) {
       inventory$Ref({
@@ -299,7 +300,7 @@ function remap(inventory: InventoryEntry[]) {
   for (const entry of inventory) {
     // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
 
-    if (!entry.external) {
+    if (!entry.external && !entry.hash?.startsWith("#/paths/")) {
       // This $ref already resolves to the main JSON Schema file
       entry.$ref.$ref = entry.hash;
     } else if (entry.file === file && entry.hash === hash) {
@@ -359,17 +360,13 @@ function removeFromInventory(inventory: InventoryEntry[], entry: any) {
  * @param parser
  * @param options
  */
-export const bundle = (
-  parser: $RefParser,
-  options: ParserOptions,
-) => {
+export const bundle = (parser: $RefParser, options: ParserOptions) => {
   // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
-
   // Build an inventory of all $ref pointers in the JSON Schema
   const inventory: InventoryEntry[] = [];
   crawl<JSONSchema>({
     parent: parser,
-    key: 'schema',
+    key: "schema",
     path: parser.$refs._root$Ref.path + "#",
     pathFromRoot: "#",
     indirections: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hey-api/json-schema-ref-parser",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "homepage": "https://heyapi.dev/",
   "repository": {
@@ -42,6 +42,7 @@
   ],
   "scripts": {
     "build": "rimraf dist && tsc",
+    "dev": "rimraf dist && tsc --watch",
     "lint": "eslint lib",
     "prepublishOnly": "yarn build",
     "prettier": "prettier --write \"**/*.+(js|jsx|ts|tsx|har||json|css|md)\"",