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

package/README.md

@@ -15,9 +15,9 @@
 Install using [npm](https://docs.npmjs.com/about-npm/):
 
 ```bash
-npm install @apidevtools/json-schema-ref-parser
-yarn add @apidevtools/json-schema-ref-parser
-bun add @apidevtools/json-schema-ref-parser
+npm install @hey-api/json-schema-ref-parser
+yarn add @hey-api/json-schema-ref-parser
+bun add @hey-api/json-schema-ref-parser
 ```
 
 ## The Problem:
@@ -69,21 +69,61 @@ JavaScript objects.
 ## Example
 
 ```javascript
-import $RefParser from "@apidevtools/json-schema-ref-parser";
+import { $RefParser } from "@hey-api/json-schema-ref-parser";
 
 try {
-  await $RefParser.dereference(mySchema);
-  // note - by default, mySchema is modified in place, and the returned value is a reference to the same object
-  console.log(mySchema.definitions.person.properties.firstName);
-
-  // if you want to avoid modifying the original schema, you can disable the `mutateInputSchema` option
-  let clonedSchema = await $RefParser.dereference(mySchema, { mutateInputSchema: false });
-  console.log(clonedSchema.definitions.person.properties.firstName);
+  const parser = new $RefParser();
+  await parser.dereference({ pathOrUrlOrSchema: mySchema });
+  console.log(parser.schema.definitions.person.properties.firstName);
 } catch (err) {
   console.error(err);
 }
 ```
 
+### New in this fork (@hey-api)
+
+- **Multiple inputs with `bundleMany`**: Merge and bundle several OpenAPI/JSON Schema inputs (files, URLs, or raw objects) into a single schema. Components are prefixed to avoid name collisions, paths are namespaced on conflict, and `$ref`s are rewritten accordingly.
+
+```javascript
+import { $RefParser } from "@hey-api/json-schema-ref-parser";
+
+const parser = new $RefParser();
+const merged = await parser.bundleMany({
+  pathOrUrlOrSchemas: [
+    "./specs/a.yaml",
+    "https://example.com/b.yaml",
+    { openapi: "3.1.0", info: { title: "Inline" }, paths: {} },
+  ],
+});
+
+// merged.components.* will contain prefixed names like a_<name>, b_<name>, etc.
+```
+
+- **Dereference hooks**: Fine-tune dereferencing with `excludedPathMatcher(path) => boolean` to skip subpaths and `onDereference(path, value, parent, parentPropName)` to observe replacements.
+
+```javascript
+const parser = new $RefParser();
+parser.options.dereference.excludedPathMatcher = (p) => p.includes("/example/");
+parser.options.dereference.onDereference = (p, v) => {
+  // inspect p / v as needed
+};
+await parser.dereference({ pathOrUrlOrSchema: "./openapi.yaml" });
+```
+
+- **Smart input resolution**: You can pass a file path, URL, or raw schema object. If a raw schema includes `$id`, it is used as the base URL for resolving relative `$ref`s.
+
+```javascript
+await new $RefParser().bundle({
+  pathOrUrlOrSchema: {
+    $id: "https://api.example.com/openapi.json",
+    openapi: "3.1.0",
+    paths: {
+      "/ping": { get: { responses: { 200: { description: "ok" } } } },
+    },
+  },
+});
+```
+
 ## Polyfills
 
 If you are using Node.js < 18, you'll need a polyfill for `fetch`,

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

@@ -17,19 +17,16 @@ const __1 = require("..");
         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
+        // 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
-        (0, vitest_1.expect)(secondParam.$ref).toBeDefined();
-        (0, vitest_1.expect)(firstParam).toEqual({
+        // The $ref should match the output structure in file_context_0
+        (0, vitest_1.expect)(firstParam.$ref).toBe("#/components/parameters/path-parameter_pathId");
+        (0, vitest_1.expect)(secondParam.$ref).toBe("#/components/parameters/path-parameter_pathId");
+        // The referenced parameter should exist and match the expected structure
+        (0, vitest_1.expect)(schema.components).toBeDefined();
+        (0, vitest_1.expect)(schema.components.parameters).toBeDefined();
+        (0, vitest_1.expect)(schema.components.parameters["path-parameter_pathId"]).toEqual({
             name: "pathId",
             in: "path",
             required: true,

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

@@ -11,6 +11,7 @@ const path_1 = __importDefault(require("path"));
         const refParser = new __1.$RefParser();
         const pathOrUrlOrSchema = path_1.default.resolve("lib", "__tests__", "spec", "openapi-paths-ref.json");
         const schema = (await refParser.bundle({ pathOrUrlOrSchema }));
+        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;
         (0, vitest_1.expect)(getSchema.$ref).toBeUndefined();
@@ -18,10 +19,10 @@ const path_1 = __importDefault(require("path"));
         (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");
+        (0, vitest_1.expect)(postSchema.$ref).toBe("#/paths/~1foo/get/responses/200/content/application~1json/schema");
+        (0, vitest_1.expect)(postSchema.type).toBeUndefined();
+        (0, vitest_1.expect)(postSchema.properties?.bar?.type).toBeUndefined();
         // Both schemas should be identical objects
-        (0, vitest_1.expect)(postSchema).toEqual(getSchema);
+        (0, vitest_1.expect)(postSchema).not.toBe(getSchema);
     });
 });

package/dist/lib/bundle.d.ts

@@ -13,6 +13,7 @@ export interface InventoryEntry {
     parent: any;
     pathFromRoot: any;
     value: any;
+    originalContainerType?: "schemas" | "parameters" | "requestBodies" | "responses" | "headers";
 }
 /**
  * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that