@hey-api/json-schema-ref-parser 1.2.4 → 1.3.0

package/{lib → src}/resolve-external.ts

@@ -1,15 +1,15 @@
-import $Ref from "./ref.js";
-import Pointer from "./pointer.js";
-import { newFile, parseFile } from "./parse.js";
-import * as url from "./util/url.js";
-import type $Refs from "./refs.js";
-import type { $RefParserOptions } from "./options.js";
-import type { JSONSchema } from "./types/index.js";
-import { getResolvedInput } from "./index.js";
-import type { $RefParser } from "./index.js";
-import { isHandledError } from "./util/errors.js";
-import { fileResolver } from "./resolvers/file.js";
-import { urlResolver } from "./resolvers/url.js";
+import type { $RefParser } from '.';
+import { getResolvedInput } from '.';
+import type { $RefParserOptions } from './options';
+import { newFile, parseFile } from './parse';
+import Pointer from './pointer';
+import $Ref from './ref';
+import type $Refs from './refs';
+import { fileResolver } from './resolvers/file';
+import { urlResolver } from './resolvers/url';
+import type { JSONSchema } from './types';
+import { isHandledError } from './util/errors';
+import * as url from './util/url';
 
 /**
  * Crawls the JSON schema, finds all external JSON references, and resolves their values.
@@ -21,54 +21,68 @@ import { urlResolver } from "./resolvers/url.js";
  * The promise resolves once all JSON references in the schema have been resolved,
  * including nested references that are contained in externally-referenced files.
  */
-export function resolveExternal(parser: $RefParser, options: $RefParserOptions) {
-  try {
-    // console.log('Resolving $ref pointers in %s', parser.$refs._root$Ref.path);
-    const promises = crawl(parser.schema, parser.$refs._root$Ref.path + "#", parser.$refs, options);
-    return Promise.all(promises);
-  } catch (e) {
-    return Promise.reject(e);
-  }
+export async function resolveExternal(parser: $RefParser, options: $RefParserOptions) {
+  const promises = crawl(parser.schema, {
+    $refs: parser.$refs,
+    options: options.parse,
+    path: `${parser.$refs._root$Ref.path}#`,
+  });
+  await Promise.all(promises);
 }
 
 /**
  * Recursively crawls the given value, and resolves any external JSON references.
  *
  * @param obj - The value to crawl. If it's not an object or array, it will be ignored.
- * @param path - The full path of `obj`, possibly with a JSON Pointer in the hash
- * @param {boolean} external - Whether `obj` was found in an external document.
- * @param $refs
- * @param options
- * @param seen - Internal.
- *
- * @returns
- * Returns an array of promises. There will be one promise for each JSON reference in `obj`.
+ * @returns An array of promises. There will be one promise for each JSON reference in `obj`.
  * If `obj` does not contain any JSON references, then the array will be empty.
  * If any of the JSON references point to files that contain additional JSON references,
  * then the corresponding promise will internally reference an array of promises.
  */
 function crawl<S extends object = JSONSchema>(
   obj: string | Buffer | S | undefined | null,
-  path: string,
-  $refs: $Refs<S>,
-  options: $RefParserOptions,
-  seen?: Set<any>,
-  external?: boolean,
-) {
-  seen ||= new Set();
-  let promises: any = [];
+  {
+    $refs,
+    external = false,
+    options,
+    path,
+    seen = new Set(),
+  }: {
+    $refs: $Refs<S>;
+    /** Whether `obj` was found in an external document. */
+    external?: boolean;
+    options: $RefParserOptions['parse'];
+    /** The full path of `obj`, possibly with a JSON Pointer in the hash. */
+    path: string;
+    seen?: Set<unknown>;
+  },
+): ReadonlyArray<Promise<unknown>> {
+  let promises: Array<Promise<unknown>> = [];
+
+  if (obj && typeof obj === 'object' && !ArrayBuffer.isView(obj) && !seen.has(obj)) {
+    seen.add(obj);
 
-  if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !seen.has(obj)) {
-    seen.add(obj); // Track previously seen objects to avoid infinite recursion
     if ($Ref.isExternal$Ref(obj)) {
-      promises.push(resolve$Ref<S>(obj, path, $refs, options));
+      promises.push(
+        resolve$Ref<S>(obj, {
+          $refs,
+          options,
+          path,
+          seen,
+        }),
+      );
     }
 
-    const keys = Object.keys(obj) as string[];
-    for (const key of keys) {
-      const keyPath = Pointer.join(path, key);
-      const value = obj[key as keyof typeof obj] as string | JSONSchema | Buffer | undefined;
-      promises = promises.concat(crawl(value, keyPath, $refs, options, seen, external));
+    for (const [key, value] of Object.entries(obj)) {
+      promises = promises.concat(
+        crawl(value, {
+          $refs,
+          external,
+          options,
+          path: Pointer.join(path, key),
+          seen,
+        }),
+      );
     }
   }
 
@@ -89,15 +103,21 @@ function crawl<S extends object = JSONSchema>(
  */
 async function resolve$Ref<S extends object = JSONSchema>(
   $ref: S,
-  path: string,
-  $refs: $Refs<S>,
-  options: $RefParserOptions,
-) {
+  {
+    $refs,
+    options,
+    path,
+    seen,
+  }: {
+    $refs: $Refs<S>;
+    options: $RefParserOptions['parse'];
+    path: string;
+    seen: Set<unknown>;
+  },
+): Promise<unknown> {
   const resolvedPath = url.resolve(path, ($ref as JSONSchema).$ref!);
   const withoutHash = url.stripHash(resolvedPath);
 
-  // $ref.$ref = url.relative($refs._root$Ref.path, resolvedPath);
-
   // If this ref points back to an input source we've already merged, avoid re-importing
   // by checking if the path (without hash) matches a known source in parser and we can serve it internally later.
   // We keep normal flow but ensure cache hit if already added.
@@ -105,7 +125,13 @@ async function resolve$Ref<S extends object = JSONSchema>(
   const ref = $refs._$refs[withoutHash];
   if (ref) {
     // We've already parsed this $ref, so crawl it to resolve its own externals
-    const promises = crawl(ref.value as S, `${withoutHash}#`, $refs, options, new Set(), true);
+    const promises = crawl(ref.value as S, {
+      $refs,
+      external: true,
+      options,
+      path: `${withoutHash}#`,
+      seen,
+    });
     return Promise.all(promises);
   }
 
@@ -121,22 +147,27 @@ async function resolve$Ref<S extends object = JSONSchema>(
 
     $refAdded.pathType = resolvedInput.type;
 
-    let promises: any = [];
+    let promises: ReadonlyArray<Promise<unknown>> = [];
 
-    if (resolvedInput.type !== "json") {
-      const resolver = resolvedInput.type === "file" ? fileResolver : urlResolver;
+    if (resolvedInput.type !== 'json') {
+      const resolver = resolvedInput.type === 'file' ? fileResolver : urlResolver;
       await resolver.handler({ file });
       const parseResult = await parseFile(file, options);
       $refAdded.value = parseResult.result;
-      promises = crawl(parseResult.result, `${withoutHash}#`, $refs, options, new Set(), true);
+      promises = crawl(parseResult.result, {
+        $refs,
+        external: true,
+        options,
+        path: `${withoutHash}#`,
+        seen,
+      });
     }
 
     return Promise.all(promises);
-  } catch (err) {
-    if (isHandledError(err)) {
-      $refAdded.value = err;
+  } catch (error) {
+    if (isHandledError(error)) {
+      $refAdded.value = error;
     }
-
-    throw err;
+    throw error;
   }
 }

package/{lib → src}/resolvers/file.ts

@@ -1,15 +1,12 @@
-import fs from "fs";
-import { ono } from "@jsdevtools/ono";
-import * as url from "../util/url.js";
-import { ResolverError } from "../util/errors.js";
-import type { FileInfo } from "../types/index.js";
+import { ono } from '@jsdevtools/ono';
+import fs from 'fs';
+
+import type { FileInfo } from '../types';
+import { ResolverError } from '../util/errors';
+import * as url from '../util/url';
 
 export const fileResolver = {
-  handler: async ({
-    file,
-  }: {
-    file: FileInfo;
-  }): Promise<void> => {
+  handler: async ({ file }: { file: FileInfo }): Promise<void> => {
     let path: string | undefined;
 
     try {

package/{lib → src}/resolvers/url.ts

@@ -1,7 +1,8 @@
-import { ono } from "@jsdevtools/ono";
-import { resolve } from "../util/url.js";
-import { ResolverError } from "../util/errors.js";
-import type { FileInfo } from "../types/index.js";
+import { ono } from '@jsdevtools/ono';
+
+import type { FileInfo } from '../types';
+import { ResolverError } from '../util/errors';
+import { resolve } from '../util/url';
 
 export const sendRequest = async ({
   fetchOptions,
@@ -35,13 +36,16 @@ export const sendRequest = async ({
       throw new ResolverError(
         ono(
           { status: response.status },
-          `Error requesting ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`,
+          `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`);
+    if (!('location' in response.headers) || !response.headers.location) {
+      throw ono(
+        { status: response.status },
+        `HTTP ${response.status} redirect with no location header`,
+      );
     }
 
     return sendRequest({
@@ -53,7 +57,7 @@ export const sendRequest = async ({
   }
 
   return { fetchOptions, response };
-}
+};
 
 export const urlResolver = {
   handler: async ({

package/{lib → src}/types/index.ts

@@ -5,7 +5,7 @@ import type {
   JSONSchema6Object,
   JSONSchema7,
   JSONSchema7Object,
-} from "json-schema";
+} from 'json-schema';
 
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
@@ -20,7 +20,14 @@ export interface Plugin {
    *
    * Unlike the `canHandle` function, the `parse` method can also be asynchronous. This might be important if your parser needs to retrieve data from a database or if it relies on an external HTTP service to return the parsed value.  You can return your asynchronous value via a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or a Node.js-style error-first callback.  Here are examples of both approaches:
    */
-  handler: (file: FileInfo) => string | Buffer | JSONSchema | Promise<{ data: Buffer }> | Promise<string | Buffer | JSONSchema>;
+  handler: (
+    file: FileInfo,
+  ) =>
+    | string
+    | Buffer
+    | JSONSchema
+    | Promise<{ data: Buffer }>
+    | Promise<string | Buffer | JSONSchema>;
   name: 'binary' | 'file' | 'http' | 'json' | 'text' | 'yaml';
 }
 

package/src/util/convert-path-to-posix.ts

@@ -0,0 +1,8 @@
+export default function convertPathToPosix(filePath: string): string {
+  // Extended-length paths on Windows should not be converted
+  if (filePath.startsWith('\\\\?\\')) {
+    return filePath;
+  }
+
+  return filePath.replaceAll('\\', '/');
+}

package/{lib → src}/util/errors.ts

@@ -1,18 +1,19 @@
-import { Ono } from "@jsdevtools/ono";
-import { getHash, stripHash, toFileSystemPath } from "./url.js";
-import type { $RefParser } from "../index.js";
-import type { JSONSchema } from "../types/index.js";
-import type $Ref from "../ref";
+import { Ono } from '@jsdevtools/ono';
+
+import type { $RefParser } from '..';
+import type $Ref from '../ref';
+import type { JSONSchema } from '../types';
+import { getHash, stripHash, toFileSystemPath } from './url';
 
 export type JSONParserErrorType =
-  | "EUNKNOWN"
-  | "EPARSER"
-  | "EUNMATCHEDPARSER"
-  | "ETIMEOUT"
-  | "ERESOLVER"
-  | "EUNMATCHEDRESOLVER"
-  | "EMISSINGPOINTER"
-  | "EINVALIDPOINTER";
+  | 'EUNKNOWN'
+  | 'EPARSER'
+  | 'EUNMATCHEDPARSER'
+  | 'ETIMEOUT'
+  | 'ERESOLVER'
+  | 'EUNMATCHEDRESOLVER'
+  | 'EMISSINGPOINTER'
+  | 'EINVALIDPOINTER';
 
 export class JSONParserError extends Error {
   public readonly name: string;
@@ -23,8 +24,8 @@ export class JSONParserError extends Error {
   public constructor(message: string, source?: string) {
     super();
 
-    this.code = "EUNKNOWN";
-    this.name = "JSONParserError";
+    this.code = 'EUNKNOWN';
+    this.name = 'JSONParserError';
     this.message = message;
     this.source = source;
     this.path = null;
@@ -44,17 +45,15 @@ export class JSONParserErrorGroup<S extends object = JSONSchema> extends Error {
     super();
 
     this.files = parser;
-    this.name = "JSONParserErrorGroup";
+    this.name = 'JSONParserErrorGroup';
     this.message = `${this.errors.length} error${
-      this.errors.length > 1 ? "s" : ""
+      this.errors.length > 1 ? 's' : ''
     } occurred while reading '${toFileSystemPath(parser.$refs._root$Ref!.path)}'`;
 
     Ono.extend(this);
   }
 
-  static getParserErrors<S extends object = JSONSchema>(
-    parser: $RefParser,
-  ) {
+  static getParserErrors<S extends object = JSONSchema>(parser: $RefParser) {
     const errors = [];
 
     for (const $ref of Object.values(parser.$refs._$refs) as $Ref<S>[]) {
@@ -80,16 +79,16 @@ export class JSONParserErrorGroup<S extends object = JSONSchema> extends Error {
 }
 
 export class ParserError extends JSONParserError {
-  code = "EPARSER" as JSONParserErrorType;
-  name = "ParserError";
+  code = 'EPARSER' as JSONParserErrorType;
+  name = 'ParserError';
   constructor(message: any, source: any) {
     super(`Error parsing ${source}: ${message}`, source);
   }
 }
 
 export class UnmatchedParserError extends JSONParserError {
-  code = "EUNMATCHEDPARSER" as JSONParserErrorType;
-  name = "UnmatchedParserError";
+  code = 'EUNMATCHEDPARSER' as JSONParserErrorType;
+  name = 'UnmatchedParserError';
 
   constructor(source: string) {
     super(`Could not find parser for "${source}"`, source);
@@ -97,44 +96,47 @@ export class UnmatchedParserError extends JSONParserError {
 }
 
 export class ResolverError extends JSONParserError {
-  code = "ERESOLVER" as JSONParserErrorType;
-  name = "ResolverError";
+  code = 'ERESOLVER' as JSONParserErrorType;
+  name = 'ResolverError';
   ioErrorCode?: string;
   constructor(ex: Error | any, source?: string) {
     super(ex.message || `Error reading file "${source}"`, source);
-    if ("code" in ex) {
+    if ('code' in ex) {
       this.ioErrorCode = String(ex.code);
     }
   }
 }
 
 export class UnmatchedResolverError extends JSONParserError {
-  code = "EUNMATCHEDRESOLVER" as JSONParserErrorType;
-  name = "UnmatchedResolverError";
+  code = 'EUNMATCHEDRESOLVER' as JSONParserErrorType;
+  name = 'UnmatchedResolverError';
   constructor(source: any) {
     super(`Could not find resolver for "${source}"`, source);
   }
 }
 
 export class MissingPointerError extends JSONParserError {
-  code = "EMISSINGPOINTER" as JSONParserErrorType;
-  name = "MissingPointerError";
+  code = 'EMISSINGPOINTER' as JSONParserErrorType;
+  name = 'MissingPointerError';
   constructor(token: string, path: string) {
-    super(`Missing $ref pointer "${getHash(path)}". Token "${token}" does not exist.`, stripHash(path));
+    super(
+      `Missing $ref pointer "${getHash(path)}". Token "${token}" does not exist.`,
+      stripHash(path),
+    );
   }
 }
 
 export class TimeoutError extends JSONParserError {
-  code = "ETIMEOUT" as JSONParserErrorType;
-  name = "TimeoutError";
+  code = 'ETIMEOUT' as JSONParserErrorType;
+  name = 'TimeoutError';
   constructor(timeout: number) {
     super(`Dereferencing timeout reached: ${timeout}ms`);
   }
 }
 
 export class InvalidPointerError extends JSONParserError {
-  code = "EUNMATCHEDRESOLVER" as JSONParserErrorType;
-  name = "InvalidPointerError";
+  code = 'EUNMATCHEDRESOLVER' as JSONParserErrorType;
+  name = 'InvalidPointerError';
   constructor(pointer: string, path: string) {
     super(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`, stripHash(path));
   }

package/{lib → src}/util/is-windows.ts

@@ -1,2 +1,2 @@
-const isWindowsConst = /^win/.test(globalThis.process ? globalThis.process.platform : "");
+const isWindowsConst = /^win/.test(globalThis.process ? globalThis.process.platform : '');
 export const isWindows = () => isWindowsConst;

package/{lib → src}/util/plugins.ts

@@ -1,5 +1,4 @@
-import type { FileInfo, JSONSchema } from "../types/index.js";
-import type { Plugin } from "../types/index.js";
+import type { FileInfo, JSONSchema, Plugin } from '../types';
 
 export interface PluginResult {
   error?: any;
@@ -22,7 +21,7 @@ export async function run(plugins: Pick<Plugin, 'handler'>[], file: FileInfo) {
 
   return new Promise<PluginResult>((resolve, reject) => {
     const runNextPlugin = async () => {
-      plugin = plugins[index++];
+      plugin = plugins[index++]!;
 
       if (!plugin) {
         // there are no more functions, re-throw the last error
@@ -30,7 +29,7 @@ export async function run(plugins: Pick<Plugin, 'handler'>[], file: FileInfo) {
       }
 
       try {
-        const result = await plugin.handler(file)
+        const result = await plugin.handler(file);
 
         if (result !== undefined) {
           return resolve({
@@ -40,16 +39,16 @@ export async function run(plugins: Pick<Plugin, 'handler'>[], file: FileInfo) {
         }
 
         if (index === plugins.length) {
-          throw new Error("No promise has been returned.");
+          throw new Error('No promise has been returned.');
         }
-      } catch (e) {
+      } catch (error) {
         lastError = {
+          error,
           plugin,
-          error: e,
         };
         runNextPlugin();
       }
-    }
+    };
 
     runNextPlugin();
   });