@hey-api/json-schema-ref-parser 1.0.2 → 1.0.4

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+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 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';
+        const resolvedInput = await (0, index_1.getResolvedInput)({ pathOrUrlOrSchema });
+        (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.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.schema).toBeUndefined();
+        (0, vitest_1.expect)(resolvedInput.path).toBe(node_path_1.default.resolve('./path/to/openapi.json'));
+    });
+    (0, vitest_1.it)('handles raw spec', async () => {
+        const pathOrUrlOrSchema = {
+            info: {
+                version: '1.0.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.schema).toEqual({
+            info: {
+                version: '1.0.0',
+            },
+            openapi: '3.1.0',
+            paths: {},
+        });
+        (0, vitest_1.expect)(resolvedInput.path).toBe('');
+    });
+});

package/dist/lib/index.d.ts

@@ -37,8 +37,9 @@ export declare class $RefParser {
      *
      * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
      */
-    bundle({ arrayBuffer, pathOrUrlOrSchema, resolvedInput, }: {
+    bundle({ arrayBuffer, fetch, pathOrUrlOrSchema, resolvedInput, }: {
         arrayBuffer?: ArrayBuffer;
+        fetch?: RequestInit;
         pathOrUrlOrSchema: JSONSchema | string | unknown;
         resolvedInput?: ResolvedInput;
     }): Promise<JSONSchema>;
@@ -51,7 +52,8 @@ export declare class $RefParser {
      *
      * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
      */
-    dereference({ pathOrUrlOrSchema, }: {
+    dereference({ fetch, pathOrUrlOrSchema, }: {
+        fetch?: RequestInit;
         pathOrUrlOrSchema: JSONSchema | string | unknown;
     }): Promise<JSONSchema>;
     /**
@@ -62,8 +64,9 @@ export declare class $RefParser {
      * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
      * @returns - The returned promise resolves with the parsed JSON schema object.
      */
-    parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput: _resolvedInput, }: {
+    parse({ arrayBuffer, fetch, pathOrUrlOrSchema, resolvedInput: _resolvedInput, }: {
         arrayBuffer?: ArrayBuffer;
+        fetch?: RequestInit;
         pathOrUrlOrSchema: JSONSchema | string | unknown;
         resolvedInput?: ResolvedInput;
     }): Promise<{

package/dist/lib/index.js

@@ -63,7 +63,7 @@ const getResolvedInput = ({ pathOrUrlOrSchema, }) => {
     // So we're being generous here and doing the conversion automatically.
     // This is not intended to be a 100% bulletproof solution.
     // If it doesn't work for your use-case, then use a URL instead.
-    if (url.isFileSystemPath(resolvedInput.path)) {
+    if (resolvedInput.path && url.isFileSystemPath(resolvedInput.path)) {
         resolvedInput.path = url.fromFileSystemPath(resolvedInput.path);
         resolvedInput.type = 'file';
     }
@@ -80,8 +80,10 @@ const getResolvedInput = ({ pathOrUrlOrSchema, }) => {
             resolvedInput.type = 'json';
         }
     }
-    // resolve the absolute path of the schema
-    resolvedInput.path = url.resolve(url.cwd(), resolvedInput.path);
+    if (resolvedInput.type !== 'json') {
+        // resolve the absolute path of the schema
+        resolvedInput.path = url.resolve(url.cwd(), resolvedInput.path);
+    }
     return resolvedInput;
 };
 exports.getResolvedInput = getResolvedInput;
@@ -116,8 +118,13 @@ class $RefParser {
      *
      * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
      */
-    async bundle({ arrayBuffer, pathOrUrlOrSchema, resolvedInput, }) {
-        await this.parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput });
+    async bundle({ arrayBuffer, fetch, pathOrUrlOrSchema, resolvedInput, }) {
+        await this.parse({
+            arrayBuffer,
+            fetch,
+            pathOrUrlOrSchema,
+            resolvedInput,
+        });
         await (0, resolve_external_js_1.resolveExternal)(this, this.options);
         const errors = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
         if (errors.length > 0) {
@@ -139,8 +146,11 @@ class $RefParser {
      *
      * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
      */
-    async dereference({ pathOrUrlOrSchema, }) {
-        await this.parse({ pathOrUrlOrSchema });
+    async dereference({ fetch, pathOrUrlOrSchema, }) {
+        await this.parse({
+            fetch,
+            pathOrUrlOrSchema,
+        });
         await (0, resolve_external_js_1.resolveExternal)(this, this.options);
         const errors = errors_js_1.JSONParserErrorGroup.getParserErrors(this);
         if (errors.length > 0) {
@@ -161,7 +171,7 @@ class $RefParser {
      * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
      * @returns - The returned promise resolves with the parsed JSON schema object.
      */
-    async parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput: _resolvedInput, }) {
+    async parse({ arrayBuffer, fetch, pathOrUrlOrSchema, resolvedInput: _resolvedInput, }) {
         const resolvedInput = _resolvedInput || (0, exports.getResolvedInput)({ pathOrUrlOrSchema });
         const { path, type } = resolvedInput;
         let { schema } = resolvedInput;
@@ -182,7 +192,11 @@ class $RefParser {
             $refAdded.pathType = type;
             try {
                 const resolver = type === 'file' ? file_js_1.fileResolver : url_js_1.urlResolver;
-                await resolver.handler(file, arrayBuffer);
+                await resolver.handler({
+                    arrayBuffer,
+                    fetch,
+                    file,
+                });
                 const parseResult = await (0, parse_js_1.parseFile)(file, this.options);
                 $refAdded.value = parseResult.result;
                 schema = parseResult.result;

package/dist/lib/resolve-external.js

@@ -131,7 +131,7 @@ async function resolve$Ref($ref, path, $refs, options) {
         let promises = [];
         if (resolvedInput.type !== 'json') {
             const resolver = resolvedInput.type === 'file' ? file_js_1.fileResolver : url_js_1.urlResolver;
-            await resolver.handler(file);
+            await resolver.handler({ file });
             const parseResult = await (0, parse_js_1.parseFile)(file, options);
             $refAdded.value = parseResult.result;
             promises = crawl(parseResult.result, `${withoutHash}#`, $refs, options, new Set(), true);

package/dist/lib/resolvers/file.d.ts

@@ -1,4 +1,6 @@
 import type { FileInfo } from "../types/index.js";
 export declare const fileResolver: {
-    handler: (file: FileInfo) => Promise<void>;
+    handler: ({ file, }: {
+        file: FileInfo;
+    }) => Promise<void>;
 };

package/dist/lib/resolvers/file.js

@@ -42,7 +42,7 @@ const ono_1 = require("@jsdevtools/ono");
 const url = __importStar(require("../util/url.js"));
 const errors_js_1 = require("../util/errors.js");
 exports.fileResolver = {
-    handler: async (file) => {
+    handler: async ({ file, }) => {
         let path;
         try {
             path = url.toFileSystemPath(file.url);

package/dist/lib/resolvers/url.d.ts

@@ -1,12 +1,17 @@
 import type { FileInfo } from "../types/index.js";
-export declare const sendRequest: ({ init, redirects, timeout, url, }: {
-    init?: RequestInit;
+export declare const sendRequest: ({ fetchOptions, redirects, timeout, url, }: {
+    fetchOptions?: RequestInit;
     redirects?: string[];
     timeout?: number;
     url: URL | string;
 }) => Promise<{
+    fetchOptions?: RequestInit;
     response: Response;
 }>;
 export declare const urlResolver: {
-    handler: (file: FileInfo, arrayBuffer?: ArrayBuffer) => Promise<void>;
+    handler: ({ arrayBuffer, fetch: _fetch, file, }: {
+        arrayBuffer?: ArrayBuffer;
+        fetch?: RequestInit;
+        file: FileInfo;
+    }) => Promise<void>;
 };

package/dist/lib/resolvers/url.js

@@ -4,58 +4,58 @@ exports.urlResolver = exports.sendRequest = void 0;
 const ono_1 = require("@jsdevtools/ono");
 const url_js_1 = require("../util/url.js");
 const errors_js_1 = require("../util/errors.js");
-const sendRequest = async ({ init, redirects = [], timeout = 60000, url, }) => {
+const sendRequest = async ({ fetchOptions, redirects = [], timeout = 60000, url, }) => {
     url = new URL(url);
     redirects.push(url.href);
-    try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-        }, timeout);
-        const response = await fetch(url, {
-            signal: controller.signal,
-            ...init,
-        });
-        clearTimeout(timeoutId);
-        if (response.status >= 400) {
-            // gracefully handle HEAD method not allowed
-            if (response.status === 405 && init?.method === 'HEAD') {
-                return { response };
-            }
-            throw (0, ono_1.ono)({ status: response.status }, `HTTP ERROR ${response.status}`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeout);
+    const response = await fetch(url, {
+        signal: controller.signal,
+        ...fetchOptions,
+    });
+    clearTimeout(timeoutId);
+    if (response.status >= 300 && response.status <= 399) {
+        if (redirects.length > 5) {
+            throw new errors_js_1.ResolverError((0, ono_1.ono)({ status: response.status }, `Error requesting ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`));
         }
-        if (response.status >= 300) {
-            if (redirects.length > 5) {
-                throw new errors_js_1.ResolverError((0, ono_1.ono)({ status: response.status }, `Error requesting ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`));
-            }
-            if (!("location" in response.headers) || !response.headers.location) {
-                throw (0, ono_1.ono)({ status: response.status }, `HTTP ${response.status} redirect with no location header`);
-            }
-            return (0, exports.sendRequest)({
-                init,
-                redirects,
-                timeout,
-                url: (0, url_js_1.resolve)(url.href, response.headers.location),
-            });
+        if (!("location" in response.headers) || !response.headers.location) {
+            throw (0, ono_1.ono)({ status: response.status }, `HTTP ${response.status} redirect with no location header`);
         }
-        return { response };
-    }
-    catch (error) {
-        throw new errors_js_1.ResolverError((0, ono_1.ono)(error, `Error requesting ${url.href}`), url.href);
+        return (0, exports.sendRequest)({
+            fetchOptions,
+            redirects,
+            timeout,
+            url: (0, url_js_1.resolve)(url.href, response.headers.location),
+        });
     }
+    return { fetchOptions, response };
 };
 exports.sendRequest = sendRequest;
 exports.urlResolver = {
-    handler: async (file, arrayBuffer) => {
+    handler: async ({ arrayBuffer, fetch: _fetch, file, }) => {
         let data = arrayBuffer;
         if (!data) {
-            const { response } = await (0, exports.sendRequest)({
-                init: {
-                    method: 'GET',
-                },
-                url: file.url,
-            });
-            data = response.body ? await response.arrayBuffer() : new ArrayBuffer(0);
+            try {
+                const { fetchOptions, response } = await (0, exports.sendRequest)({
+                    fetchOptions: {
+                        method: 'GET',
+                        ..._fetch,
+                    },
+                    url: file.url,
+                });
+                if (response.status >= 400) {
+                    // gracefully handle HEAD method not allowed
+                    if (response.status !== 405 || fetchOptions?.method !== 'HEAD') {
+                        throw (0, ono_1.ono)({ status: response.status }, `HTTP ERROR ${response.status}`);
+                    }
+                    data = response.body ? await response.arrayBuffer() : new ArrayBuffer(0);
+                }
+            }
+            catch (error) {
+                throw new errors_js_1.ResolverError((0, ono_1.ono)(error, `Error requesting ${file.url}`), file.url);
+            }
         }
         file.data = Buffer.from(data);
     },

package/dist/vite.config.js

@@ -4,15 +4,16 @@ const config_1 = require("vitest/config");
 const isBrowser = process.env.BROWSER === "true";
 exports.default = (0, config_1.defineConfig)({
     test: {
-        environment: isBrowser ? "jsdom" : "node",
+        coverage: { reporter: ["lcov", "html", "text"] },
         dir: "test",
+        environment: isBrowser ? "jsdom" : "node",
         exclude: ["**/__IGNORED__/**"],
-        watch: false,
-        globalSetup: isBrowser ? ["./test/fixtures/server.ts"] : undefined,
-        testTimeout: 5000,
         globals: true,
+        globalSetup: isBrowser ? ["./test/fixtures/server.ts"] : undefined,
+        include: ['./lib/**/*.test.ts'],
         passWithNoTests: true,
         reporters: ["verbose"],
-        coverage: { reporter: ["lcov", "html", "text"] },
+        testTimeout: 5000,
+        watch: false,
     },
 });

package/lib/__tests__/index.test.ts

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

package/lib/index.ts

@@ -38,7 +38,7 @@ export const getResolvedInput = ({
   // So we're being generous here and doing the conversion automatically.
   // This is not intended to be a 100% bulletproof solution.
   // If it doesn't work for your use-case, then use a URL instead.
-  if (url.isFileSystemPath(resolvedInput.path)) {
+  if (resolvedInput.path && url.isFileSystemPath(resolvedInput.path)) {
     resolvedInput.path = url.fromFileSystemPath(resolvedInput.path);
     resolvedInput.type = 'file';
   } else if (!resolvedInput.path && pathOrUrlOrSchema && typeof pathOrUrlOrSchema === 'object') {
@@ -54,8 +54,10 @@ export const getResolvedInput = ({
     }
   }
 
-  // resolve the absolute path of the schema
-  resolvedInput.path = url.resolve(url.cwd(), resolvedInput.path);
+  if (resolvedInput.type !== 'json') {
+    // resolve the absolute path of the schema
+    resolvedInput.path = url.resolve(url.cwd(), resolvedInput.path);
+  }
 
   return resolvedInput;
 }
@@ -92,14 +94,21 @@ export class $RefParser {
    */
   public async bundle({
     arrayBuffer,
+    fetch,
     pathOrUrlOrSchema,
     resolvedInput,
   }: {
     arrayBuffer?: ArrayBuffer;
+    fetch?: RequestInit;
     pathOrUrlOrSchema: JSONSchema | string | unknown;
     resolvedInput?: ResolvedInput;
   }): Promise<JSONSchema> {
-    await this.parse({ arrayBuffer, pathOrUrlOrSchema, resolvedInput });
+    await this.parse({
+      arrayBuffer,
+      fetch,
+      pathOrUrlOrSchema,
+      resolvedInput,
+    });
     await resolveExternal(this, this.options);
     const errors = JSONParserErrorGroup.getParserErrors(this);
     if (errors.length > 0) {
@@ -123,11 +132,16 @@ export class $RefParser {
    * @param pathOrUrlOrSchema A JSON Schema object, or the file path or URL of a JSON Schema file.
    */
   public async dereference({
+    fetch,
     pathOrUrlOrSchema,
   }: {
+    fetch?: RequestInit;
     pathOrUrlOrSchema: JSONSchema | string | unknown;
   }): Promise<JSONSchema> {
-    await this.parse({ pathOrUrlOrSchema });
+    await this.parse({
+      fetch,
+      pathOrUrlOrSchema,
+    });
     await resolveExternal(this, this.options);
     const errors = JSONParserErrorGroup.getParserErrors(this);
     if (errors.length > 0) {
@@ -151,10 +165,12 @@ export class $RefParser {
    */
   public async parse({
     arrayBuffer,
+    fetch,
     pathOrUrlOrSchema,
     resolvedInput: _resolvedInput,
   }: {
     arrayBuffer?: ArrayBuffer;
+    fetch?: RequestInit;
     pathOrUrlOrSchema: JSONSchema | string | unknown;
     resolvedInput?: ResolvedInput;
   }): Promise<{ schema: JSONSchema }> {
@@ -180,7 +196,11 @@ export class $RefParser {
       $refAdded.pathType = type;
       try {
         const resolver = type === 'file' ? fileResolver : urlResolver;
-        await resolver.handler(file, arrayBuffer);
+        await resolver.handler({
+          arrayBuffer,
+          fetch,
+          file,
+        });
         const parseResult = await parseFile(file, this.options);
         $refAdded.value = parseResult.result;
         schema = parseResult.result;

package/lib/resolve-external.ts

@@ -124,7 +124,7 @@ async function resolve$Ref<S extends object = JSONSchema>(
 
     if (resolvedInput.type !== 'json') {
       const resolver = resolvedInput.type === 'file' ? fileResolver : urlResolver;
-      await resolver.handler(file);
+      await resolver.handler({ file });
       const parseResult = await parseFile(file, options);
       $refAdded.value = parseResult.result;
       promises = crawl(parseResult.result, `${withoutHash}#`, $refs, options, new Set(), true);

package/lib/resolvers/file.ts

@@ -5,7 +5,11 @@ import { ResolverError } from "../util/errors.js";
 import type { FileInfo } from "../types/index.js";
 
 export const fileResolver = {
-  handler: async (file: FileInfo): Promise<void> => {
+  handler: async ({
+    file,
+  }: {
+    file: FileInfo;
+  }): Promise<void> => {
     let path: string | undefined;
 
     try {

package/lib/resolvers/url.ts

@@ -4,83 +4,92 @@ import { ResolverError } from "../util/errors.js";
 import type { FileInfo } from "../types/index.js";
 
 export const sendRequest = async ({
-  init,
+  fetchOptions,
   redirects = [],
   timeout = 60_000,
   url,
 }: {
-  init?: RequestInit;
+  fetchOptions?: RequestInit;
   redirects?: string[];
   timeout?: number;
   url: URL | string;
 }): Promise<{
+  fetchOptions?: RequestInit;
   response: Response;
 }> => {
   url = new URL(url);
   redirects.push(url.href);
 
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, timeout);
-    const response = await fetch(url, {
-      signal: controller.signal,
-      ...init,
-    });
-    clearTimeout(timeoutId);
-
-    if (response.status >= 400) {
-      // gracefully handle HEAD method not allowed
-      if (response.status === 405 && init?.method === 'HEAD') {
-        return { response };
-      }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  const response = await fetch(url, {
+    signal: controller.signal,
+    ...fetchOptions,
+  });
+  clearTimeout(timeoutId);
 
-      throw ono({ status: response.status }, `HTTP ERROR ${response.status}`);
+  if (response.status >= 300 && response.status <= 399) {
+    if (redirects.length > 5) {
+      throw new ResolverError(
+        ono(
+          { status: response.status },
+          `Error requesting ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`,
+        ),
+      );
     }
-    
-    if (response.status >= 300) {
-      if (redirects.length > 5) {
-        throw new ResolverError(
-          ono(
-            { status: response.status },
-            `Error requesting ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`,
-          ),
-        );
-      }
-      
-      if (!("location" in response.headers) || !response.headers.location) {
-        throw ono({ status: response.status }, `HTTP ${response.status} redirect with no location header`);
-      }
-      
-      return sendRequest({
-        init,
-        redirects,
-        timeout,
-        url: resolve(url.href, response.headers.location as string),
-      });
+
+    if (!("location" in response.headers) || !response.headers.location) {
+      throw ono({ status: response.status }, `HTTP ${response.status} redirect with no location header`);
     }
 
-    return { response };
-  } catch (error: any) {
-    throw new ResolverError(ono(error, `Error requesting ${url.href}`), url.href);
+    return sendRequest({
+      fetchOptions,
+      redirects,
+      timeout,
+      url: resolve(url.href, response.headers.location as string),
+    });
   }
+
+  return { fetchOptions, response };
 }
 
 export const urlResolver = {
-  handler: async (file: FileInfo, arrayBuffer?: ArrayBuffer): Promise<void> => {
+  handler: async ({
+    arrayBuffer,
+    fetch: _fetch,
+    file,
+  }: {
+    arrayBuffer?: ArrayBuffer;
+    fetch?: RequestInit;
+    file: FileInfo;
+  }): Promise<void> => {
     let data = arrayBuffer;
 
     if (!data) {
-      const { response } = await sendRequest({
-        init: {
-          method: 'GET',
-        },
-        url: file.url,
-      });
-      data = response.body ? await response.arrayBuffer() : new ArrayBuffer(0)
+      try {
+        const { fetchOptions, response } = await sendRequest({
+          fetchOptions: {
+            method: 'GET',
+            ..._fetch,
+          },
+          url: file.url,
+        });
+
+        if (response.status >= 400) {
+          // gracefully handle HEAD method not allowed
+          if (response.status !== 405 || fetchOptions?.method !== 'HEAD') {
+            throw ono({ status: response.status }, `HTTP ERROR ${response.status}`);
+          }
+
+          data = response.body ? await response.arrayBuffer() : new ArrayBuffer(0)
+        }
+      } catch (error: any) {
+        throw new ResolverError(ono(error, `Error requesting ${file.url}`), file.url);
+      }
     }
 
-    file.data = Buffer.from(data);
+    file.data = Buffer.from(data!);
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hey-api/json-schema-ref-parser",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Parse, Resolve, and Dereference JSON Schema $ref pointers",
   "homepage": "https://heyapi.dev/",
   "repository": {
@@ -48,8 +48,8 @@
     "test:browser": "cross-env BROWSER=\"true\" yarn test",
     "test:node": "yarn test",
     "test:update": "vitest -u",
-    "test:watch": "vitest -w",
-    "test": "vitest --coverage",
+    "test:watch": "vitest watch --config vitest.config.unit.ts",
+    "test": "vitest run --config vitest.config.unit.ts",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {