@hey-api/json-schema-ref-parser 1.0.1 → 1.0.3

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.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;

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

@@ -1,9 +1,11 @@
 import type { FileInfo } from "../types/index.js";
-export declare const sendRequest: ({ init, redirects, url, }: {
+export declare const sendRequest: ({ init, redirects, timeout, url, }: {
     init?: RequestInit;
     redirects?: string[];
+    timeout?: number;
     url: URL | string;
 }) => Promise<{
+    init?: RequestInit;
     response: Response;
 }>;
 export declare const urlResolver: {

package/dist/lib/resolvers/url.js

@@ -4,53 +4,57 @@ 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 = [], url, }) => {
+const sendRequest = async ({ init, redirects = [], timeout = 60000, url, }) => {
     url = new URL(url);
     redirects.push(url.href);
-    try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-        }, 60000);
-        const response = await fetch(url, {
-            signal: controller.signal,
-            ...init,
-        });
-        clearTimeout(timeoutId);
-        if (response.status >= 400) {
-            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,
+        ...init,
+    });
+    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,
-                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)({
+            init,
+            redirects,
+            timeout,
+            url: (0, url_js_1.resolve)(url.href, response.headers.location),
+        });
     }
+    return { init, response };
 };
 exports.sendRequest = sendRequest;
 exports.urlResolver = {
     handler: async (file, arrayBuffer) => {
         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 { init, response } = await (0, exports.sendRequest)({
+                    init: {
+                        method: 'GET',
+                    },
+                    url: file.url,
+                });
+                if (response.status >= 400) {
+                    // gracefully handle HEAD method not allowed
+                    if (response.status !== 405 || init?.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;
 }

package/lib/resolvers/url.ts

@@ -6,57 +6,53 @@ import type { FileInfo } from "../types/index.js";
 export const sendRequest = async ({
   init,
   redirects = [],
+  timeout = 60_000,
   url,
 }: {
   init?: RequestInit;
   redirects?: string[];
+  timeout?: number;
   url: URL | string;
 }): Promise<{
+  init?: RequestInit;
   response: Response;
 }> => {
   url = new URL(url);
   redirects.push(url.href);
 
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, 60_000);
-    const response = await fetch(url, {
-      signal: controller.signal,
-      ...init,
-    });
-    clearTimeout(timeoutId);
+  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) {
-      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,
-        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({
+      init,
+      redirects,
+      timeout,
+      url: resolve(url.href, response.headers.location as string),
+    });
   }
+
+  return { init, response };
 }
 
 export const urlResolver = {
@@ -64,15 +60,27 @@ export const urlResolver = {
     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 { init, response } = await sendRequest({
+          init: {
+            method: 'GET',
+          },
+          url: file.url,
+        });
+
+        if (response.status >= 400) {
+          // gracefully handle HEAD method not allowed
+          if (response.status !== 405 || init?.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.1",
+  "version": "1.0.3",
   "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": {