openapi-typesafe 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/adapters/redocly-loader/ref-resolution-check.mjs

@@ -0,0 +1,189 @@
+import { detectSpec, normalizeTypes, getTypes, isRef } from '@redocly/openapi-core';
+import { UNKNOWN_TYPE, propertyType, isNamedType, joinPointer, escapePointer, isExternalValue, hasRef, REF_CYCLE_MESSAGE, ANCHOR_REF, nextTick, parseRef } from './ref-resolution-steps.mjs';
+
+class RefResolutionWalk {
+  #resolver;
+  /** Redocly's `SpecExtension` type: its values are walked like values of no known type. */
+  specExtension;
+  /** Walked nodes per type name; a node walked again with the same type starts the same lookups. */
+  #seenNodes = /* @__PURE__ */ new Map();
+  #lookups = [];
+  constructor(resolver, specExtension) {
+    this.#resolver = resolver;
+    this.specExtension = specExtension;
+  }
+  isWalkedLikeUnknown(type) {
+    return type === UNKNOWN_TYPE || type === this.specExtension;
+  }
+  /** Wait for every lookup, including those started while waiting; return the first failure. */
+  async settle() {
+    let settled;
+    do {
+      settled = await Promise.allSettled(this.#lookups);
+    } while (settled.length !== this.#lookups.length);
+    return settled.find((result) => result.status === "rejected");
+  }
+  walkFrom(node, document, pointer, type) {
+    new DocumentWalk(this, document).walk(node, type, document.source.absoluteRef + pointer);
+  }
+  /** Whether the node was walked with this type before; marks it walked. */
+  isSeen(type, node) {
+    let seen = this.#seenNodes.get(type.name);
+    if (seen === void 0) {
+      seen = /* @__PURE__ */ new WeakSet();
+      this.#seenNodes.set(type.name, seen);
+    }
+    if (seen.has(node)) {
+      return true;
+    }
+    seen.add(node);
+    return false;
+  }
+  track(lookup, type) {
+    this.#lookups.push(
+      lookup.then((resolved) => {
+        if (resolved.resolved && resolved.document !== void 0) {
+          this.walkFrom(resolved.node, resolved.document, resolved.nodePointer ?? "#/", type);
+        }
+      })
+    );
+  }
+  async loadDocument(base, uri) {
+    try {
+      return await this.#resolver.resolveDocument(base.source.absoluteRef, uri);
+    } catch {
+      return void 0;
+    }
+  }
+}
+class DocumentWalk {
+  #walk;
+  #document;
+  #anchors = /* @__PURE__ */ new Map();
+  constructor(walk, document) {
+    this.#walk = walk;
+    this.#document = document;
+  }
+  walk(node, type, absoluteRef) {
+    if (typeof node !== "object" || node === null || this.#walk.isSeen(type, node)) {
+      return;
+    }
+    const anchor = node.$anchor;
+    if (Object.hasOwn(node, "$anchor") && anchor) {
+      this.#anchors.set(`#${String(anchor)}`, node);
+    }
+    if (Array.isArray(node)) {
+      this.#walkItems(node, type, absoluteRef);
+      return;
+    }
+    for (const name of Object.keys(node)) {
+      const value = node[name];
+      const [propType, walked] = propertyType(type, name, value, this.#walk.specExtension);
+      if (isNamedType(propType) && typeof walked === "object") {
+        this.walk(walked, propType, joinPointer(absoluteRef, escapePointer(name)));
+      }
+    }
+    if (isRef(node)) {
+      this.#walk.track(this.#follow(this.#document, node, { prev: null, node }), type);
+    }
+    if (isExternalValue(node)) {
+      const ref = { $ref: node.externalValue };
+      this.#walk.track(this.#follow(this.#document, ref, { prev: null, node }), type);
+    }
+  }
+  #walkItems(items, type, absoluteRef) {
+    const itemsType = type.items;
+    if (itemsType === void 0 && !this.#walk.isWalkedLikeUnknown(type)) {
+      return;
+    }
+    items.forEach((item, index) => {
+      const pointer = joinPointer(absoluteRef, index);
+      const itemType = typeof itemsType === "function" ? itemsType(item, pointer) : itemsType;
+      if (itemType === void 0 && !this.#walk.isWalkedLikeUnknown(type)) {
+        return;
+      }
+      this.walk(item, isNamedType(itemType) ? itemType : UNKNOWN_TYPE, pointer);
+    });
+  }
+  async #follow(document, ref, refStack) {
+    if (hasRef(refStack.prev, ref)) {
+      throw new Error(REF_CYCLE_MESSAGE);
+    }
+    if (ANCHOR_REF.test(ref.$ref)) {
+      await nextTick();
+      return { resolved: true, node: this.#anchors.get(ref.$ref), document, nodePointer: ref.$ref };
+    }
+    const { uri, pointer } = parseRef(ref.$ref);
+    const targetDocument = uri === null ? document : await this.#walk.loadDocument(document, uri);
+    if (targetDocument === void 0) {
+      return { resolved: false };
+    }
+    const found = await this.#followSegments(targetDocument, pointer, refStack);
+    if (found.document !== void 0 && isRef(found.node)) {
+      return this.#follow(found.document, found.node, pushRef(refStack, found.node));
+    }
+    return found;
+  }
+  /** Follow the pointer segments; a `$ref` met on the way is resolved first. */
+  async #followSegments(targetDocument, segments, refStack) {
+    let document = targetDocument;
+    let nodePointer = "#/";
+    let target = targetDocument.parsed;
+    for (const segment of segments) {
+      if (typeof target !== "object") {
+        return { resolved: true, node: void 0, document, nodePointer };
+      }
+      const step = target[segment];
+      if (step !== void 0) {
+        target = step;
+      } else if (isRef(target)) {
+        const resolved = await this.#follow(document, target, pushRef(refStack, target));
+        document = resolved.document ?? document;
+        if (typeof resolved.node !== "object") {
+          return {
+            resolved: true,
+            node: void 0,
+            document,
+            nodePointer: resolved.nodePointer ?? nodePointer
+          };
+        }
+        target = resolved.node[segment];
+        nodePointer = resolved.nodePointer ?? nodePointer;
+      } else {
+        return { resolved: true, node: void 0, document, nodePointer };
+      }
+      nodePointer = joinPointer(nodePointer, escapePointer(segment));
+    }
+    return { resolved: true, node: target, document, nodePointer };
+  }
+}
+function pushRef(head, node) {
+  return { prev: head, node };
+}
+async function checkRefsResolve(document, resolver, styleguide) {
+  const specVersion = detectSpec(document.parsed);
+  const types = normalizeTypes(
+    styleguide.extendTypes(getTypes(specVersion), specVersion),
+    styleguide
+  );
+  const rootType = types.Root;
+  const specExtension = types.SpecExtension;
+  if (rootType === void 0 || specExtension === void 0) {
+    throw new Error(`Redocly has no Root or SpecExtension type for ${specVersion}`);
+  }
+  const walk = new RefResolutionWalk(resolver, specExtension);
+  let rootFailure;
+  try {
+    walk.walkFrom(document.parsed, document, "#/", rootType);
+  } catch (error) {
+    rootFailure = { status: "rejected", reason: error };
+  }
+  const lookupFailure = await walk.settle();
+  const failure = rootFailure ?? lookupFailure;
+  if (failure !== void 0) {
+    throw failure.reason;
+  }
+}
+
+export { checkRefsResolve };
+//# sourceMappingURL=ref-resolution-check.mjs.map

package/dist/adapters/redocly-loader/ref-resolution-check.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-resolution-check.mjs","sources":["../../../src/adapters/redocly-loader/ref-resolution-check.ts"],"sourcesContent":["import {\n  type BaseResolver,\n  type Document,\n  detectSpec,\n  getTypes,\n  isRef,\n  normalizeTypes,\n  type Config as RedoclyConfig,\n} from \"@redocly/openapi-core\";\nimport {\n  ANCHOR_REF,\n  escapePointer,\n  hasRef,\n  isExternalValue,\n  isNamedType,\n  joinPointer,\n  nextTick,\n  parseRef,\n  propertyType,\n  REF_CYCLE_MESSAGE,\n  type Ref,\n  type RefStack,\n  type ResolvedRef,\n  UNKNOWN_TYPE,\n  type WalkType,\n} from \"./ref-resolution-steps.js\";\n\n/**\n * Redocly 1.34 resolves `$ref`s with `Promise.all` over the lookups it has started and stops at\n * the first one that fails. Lookups it starts after that (the walk of a document that was still\n * loading) are never awaited: when one of them fails too, its rejection is unhandled, and Node.js\n * ends the process on an unhandled rejection (ADR-031). Redocly 2.x has the same loop.\n *\n * This is a port of Redocly's `resolveDocument` (`lib/resolve.js`, 1.34.22, MIT) that waits for\n * every lookup and then throws the first failure. The loader runs it before Redocly lints or\n * bundles, so Redocly only resolves documents in which no lookup fails. It walks the same nodes\n * with the same types and throws the same errors: the \"Self-referencing circular pointer\" Error,\n * the URIError of a malformed percent escape, and the TypeError of a key such as `valueOf`.\n */\n\n/** One walk of the documents a root reaches, with every `$ref` lookup it starts. */\nclass RefResolutionWalk {\n  readonly #resolver: BaseResolver;\n  /** Redocly's `SpecExtension` type: its values are walked like values of no known type. */\n  readonly specExtension: WalkType;\n  /** Walked nodes per type name; a node walked again with the same type starts the same lookups. */\n  readonly #seenNodes = new Map<string, WeakSet<object>>();\n  readonly #lookups: Promise<void>[] = [];\n\n  constructor(resolver: BaseResolver, specExtension: WalkType) {\n    this.#resolver = resolver;\n    this.specExtension = specExtension;\n  }\n\n  isWalkedLikeUnknown(type: WalkType): boolean {\n    return type === UNKNOWN_TYPE || type === this.specExtension;\n  }\n\n  /** Wait for every lookup, including those started while waiting; return the first failure. */\n  async settle(): Promise<PromiseRejectedResult | undefined> {\n    let settled: PromiseSettledResult<void>[];\n    do {\n      settled = await Promise.allSettled(this.#lookups);\n    } while (settled.length !== this.#lookups.length);\n    return settled.find((result) => result.status === \"rejected\");\n  }\n\n  walkFrom(node: unknown, document: Document, pointer: string, type: WalkType): void {\n    new DocumentWalk(this, document).walk(node, type, document.source.absoluteRef + pointer);\n  }\n\n  /** Whether the node was walked with this type before; marks it walked. */\n  isSeen(type: WalkType, node: object): boolean {\n    let seen = this.#seenNodes.get(type.name);\n    if (seen === undefined) {\n      seen = new WeakSet();\n      this.#seenNodes.set(type.name, seen);\n    }\n    if (seen.has(node)) {\n      return true;\n    }\n    seen.add(node);\n    return false;\n  }\n\n  track(lookup: Promise<ResolvedRef>, type: WalkType): void {\n    this.#lookups.push(\n      lookup.then((resolved) => {\n        if (resolved.resolved && resolved.document !== undefined) {\n          this.walkFrom(resolved.node, resolved.document, resolved.nodePointer ?? \"#/\", type);\n        }\n      }),\n    );\n  }\n\n  async loadDocument(base: Document, uri: string): Promise<Document | undefined> {\n    try {\n      return (await this.#resolver.resolveDocument(base.source.absoluteRef, uri)) as Document;\n    } catch {\n      // Redocly records the failed lookup as an unresolved `$ref`; the lint reports it.\n      return undefined;\n    }\n  }\n}\n\n/** The walk of one document from one node, with the anchors it collects (as in Redocly). */\nclass DocumentWalk {\n  readonly #walk: RefResolutionWalk;\n  readonly #document: Document;\n  readonly #anchors = new Map<string, unknown>();\n\n  constructor(walk: RefResolutionWalk, document: Document) {\n    this.#walk = walk;\n    this.#document = document;\n  }\n\n  walk(node: unknown, type: WalkType, absoluteRef: string): void {\n    if (typeof node !== \"object\" || node === null || this.#walk.isSeen(type, node)) {\n      return;\n    }\n    const anchor = (node as { $anchor?: unknown }).$anchor;\n    if (Object.hasOwn(node, \"$anchor\") && anchor) {\n      this.#anchors.set(`#${String(anchor)}`, node);\n    }\n    if (Array.isArray(node)) {\n      this.#walkItems(node, type, absoluteRef);\n      return;\n    }\n    for (const name of Object.keys(node)) {\n      const value = (node as Record<string, unknown>)[name];\n      const [propType, walked] = propertyType(type, name, value, this.#walk.specExtension);\n      if (isNamedType(propType) && typeof walked === \"object\") {\n        this.walk(walked, propType, joinPointer(absoluteRef, escapePointer(name)));\n      }\n    }\n    if (isRef(node)) {\n      this.#walk.track(this.#follow(this.#document, node, { prev: null, node }), type);\n    }\n    if (isExternalValue(node)) {\n      const ref = { $ref: node.externalValue };\n      this.#walk.track(this.#follow(this.#document, ref, { prev: null, node }), type);\n    }\n  }\n\n  #walkItems(items: readonly unknown[], type: WalkType, absoluteRef: string): void {\n    const itemsType = type.items;\n    if (itemsType === undefined && !this.#walk.isWalkedLikeUnknown(type)) {\n      return;\n    }\n    items.forEach((item, index) => {\n      const pointer = joinPointer(absoluteRef, index);\n      const itemType = typeof itemsType === \"function\" ? itemsType(item, pointer) : itemsType;\n      if (itemType === undefined && !this.#walk.isWalkedLikeUnknown(type)) {\n        return;\n      }\n      this.walk(item, isNamedType(itemType) ? itemType : UNKNOWN_TYPE, pointer);\n    });\n  }\n\n  async #follow(document: Document, ref: Ref, refStack: RefStack): Promise<ResolvedRef> {\n    if (hasRef(refStack.prev, ref)) {\n      throw new Error(REF_CYCLE_MESSAGE);\n    }\n    if (ANCHOR_REF.test(ref.$ref)) {\n      await nextTick();\n      return { resolved: true, node: this.#anchors.get(ref.$ref), document, nodePointer: ref.$ref };\n    }\n    const { uri, pointer } = parseRef(ref.$ref);\n    const targetDocument = uri === null ? document : await this.#walk.loadDocument(document, uri);\n    if (targetDocument === undefined) {\n      return { resolved: false };\n    }\n    const found = await this.#followSegments(targetDocument, pointer, refStack);\n    if (found.document !== undefined && isRef(found.node)) {\n      return this.#follow(found.document, found.node, pushRef(refStack, found.node));\n    }\n    return found;\n  }\n\n  /** Follow the pointer segments; a `$ref` met on the way is resolved first. */\n  async #followSegments(\n    targetDocument: Document,\n    segments: readonly string[],\n    refStack: RefStack,\n  ): Promise<ResolvedRef> {\n    let document = targetDocument;\n    let nodePointer = \"#/\";\n    let target: unknown = targetDocument.parsed;\n    for (const segment of segments) {\n      if (typeof target !== \"object\") {\n        return { resolved: true, node: undefined, document, nodePointer };\n      }\n      // A `null` target throws a TypeError here, as it does in Redocly.\n      const step = (target as Record<string, unknown>)[segment];\n      if (step !== undefined) {\n        target = step;\n      } else if (isRef(target)) {\n        const resolved = await this.#follow(document, target, pushRef(refStack, target));\n        document = resolved.document ?? document;\n        if (typeof resolved.node !== \"object\") {\n          return {\n            resolved: true,\n            node: undefined,\n            document,\n            nodePointer: resolved.nodePointer ?? nodePointer,\n          };\n        }\n        target = (resolved.node as Record<string, unknown>)[segment];\n        nodePointer = resolved.nodePointer ?? nodePointer;\n      } else {\n        return { resolved: true, node: undefined, document, nodePointer };\n      }\n      nodePointer = joinPointer(nodePointer, escapePointer(segment));\n    }\n    return { resolved: true, node: target, document, nodePointer };\n  }\n}\n\nfunction pushRef(head: RefStack, node: unknown): RefStack {\n  return { prev: head, node };\n}\n\n/**\n * Resolve every `$ref` the document reaches, as Redocly's lint and bundle do, and throw the first\n * failure only after all lookups have finished. Documents are loaded through the given resolver,\n * whose cache Redocly then reuses.\n */\nexport async function checkRefsResolve(\n  document: Document,\n  resolver: BaseResolver,\n  styleguide: RedoclyConfig[\"styleguide\"],\n): Promise<void> {\n  const specVersion = detectSpec(document.parsed);\n  const types = normalizeTypes(\n    styleguide.extendTypes(getTypes(specVersion), specVersion),\n    styleguide,\n  );\n  const rootType = types.Root;\n  const specExtension = types.SpecExtension;\n  if (rootType === undefined || specExtension === undefined) {\n    // Redocly gives every spec version both types; a missing one is a Redocly change to port.\n    throw new Error(`Redocly has no Root or SpecExtension type for ${specVersion}`);\n  }\n  const walk = new RefResolutionWalk(resolver, specExtension);\n  let rootFailure: PromiseRejectedResult | undefined;\n  try {\n    walk.walkFrom(document.parsed, document, \"#/\", rootType);\n  } catch (error) {\n    // The walk of the root can fail after it started lookups; they are awaited all the same.\n    rootFailure = { status: \"rejected\", reason: error };\n  }\n  const lookupFailure = await walk.settle();\n  const failure = rootFailure ?? lookupFailure;\n  if (failure !== undefined) {\n    throw failure.reason;\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/redocly-loader/ref-resolution-steps.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+const jsonPointer = require('../../domain/openapi/json-pointer.cjs');
+
+const UNKNOWN_TYPE = { name: "unknown", properties: {} };
+const RESOLVABLE_SCALAR_TYPE = { name: "scalar", properties: {} };
+const ANCHOR_REF = /^#[A-Za-z][A-Za-z0-9\-_:.]*$/;
+const REF_CYCLE_MESSAGE = "Self-referencing circular pointer";
+function isNamedType(type) {
+  return typeof type?.name === "string";
+}
+function joinPointer(base, key) {
+  const start = base === "" ? "#/" : base;
+  return start.endsWith("/") ? `${start}${key}` : `${start}/${key}`;
+}
+function escapePointer(fragment) {
+  return fragment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function parseRef(ref) {
+  const [uri = ""] = ref.split("#/");
+  return {
+    uri: (uri.endsWith("#") ? uri.slice(0, -1) : uri) || null,
+    pointer: jsonPointer.parseRefPointer(ref)
+  };
+}
+function hasRef(head, node) {
+  for (let entry = head; entry !== null; entry = entry.prev) {
+    if (entry.node === node) {
+      return true;
+    }
+  }
+  return false;
+}
+function isExternalValue(node) {
+  return typeof node.externalValue === "string";
+}
+function nextTick() {
+  return new Promise((resolve) => setTimeout(resolve));
+}
+function propertyType(type, name, value, specExtension) {
+  let declared = type.properties[name];
+  if (declared === void 0) {
+    declared = type.additionalProperties;
+  }
+  let propType = typeof declared === "function" ? declared(value, name) : declared;
+  if (propType === void 0) {
+    propType = UNKNOWN_TYPE;
+  }
+  if (type.extensionsPrefix && name.startsWith(type.extensionsPrefix) && propType === UNKNOWN_TYPE) {
+    return [specExtension, value];
+  }
+  if (!isNamedType(propType) && propType?.directResolveAs) {
+    return [propType.directResolveAs, { $ref: value }];
+  }
+  if (propType && !isNamedType(propType) && propType.resolvable !== false) {
+    return [RESOLVABLE_SCALAR_TYPE, value];
+  }
+  return [propType, value];
+}
+
+exports.ANCHOR_REF = ANCHOR_REF;
+exports.REF_CYCLE_MESSAGE = REF_CYCLE_MESSAGE;
+exports.RESOLVABLE_SCALAR_TYPE = RESOLVABLE_SCALAR_TYPE;
+exports.UNKNOWN_TYPE = UNKNOWN_TYPE;
+exports.escapePointer = escapePointer;
+exports.hasRef = hasRef;
+exports.isExternalValue = isExternalValue;
+exports.isNamedType = isNamedType;
+exports.joinPointer = joinPointer;
+exports.nextTick = nextTick;
+exports.parseRef = parseRef;
+exports.propertyType = propertyType;
+//# sourceMappingURL=ref-resolution-steps.cjs.map

package/dist/adapters/redocly-loader/ref-resolution-steps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-resolution-steps.cjs","sources":["../../../src/adapters/redocly-loader/ref-resolution-steps.ts"],"sourcesContent":["import type { Document, normalizeTypes } from \"@redocly/openapi-core\";\nimport { parseRefPointer } from \"../../domain/openapi/json-pointer.js\";\n\n/**\n * The pieces of Redocly 1.34's `$ref` resolution (`lib/resolve.js`, `lib/ref-utils.js`, MIT) that\n * the resolution check (`ref-resolution-check.ts`, ADR-031) walks with, kept as Redocly has them.\n */\n\ntype RedoclyTypes = ReturnType<typeof normalizeTypes>;\nexport type WalkType = RedoclyTypes[string];\ntype PropTypeOrFunction = WalkType[\"properties\"][string] | WalkType[\"additionalProperties\"];\n/** The type of a property or array item, after Redocly called a type function. */\nexport type PropType = Exclude<PropTypeOrFunction, (...args: never[]) => unknown>;\n\n/** Redocly's own placeholders: a node of no known type, and a scalar that is a `$ref`. */\nexport const UNKNOWN_TYPE: WalkType = { name: \"unknown\", properties: {} };\nexport const RESOLVABLE_SCALAR_TYPE: WalkType = { name: \"scalar\", properties: {} };\n\n/** Redocly's test for an anchor reference (`#name`), which waits for the whole document walk. */\nexport const ANCHOR_REF = /^#[A-Za-z][A-Za-z0-9\\-_:.]*$/;\n\n/** Redocly throws a plain Error with this message for a `$ref` chain that points back to itself. */\nexport const REF_CYCLE_MESSAGE = \"Self-referencing circular pointer\";\n\nexport interface RefStack {\n  readonly prev: RefStack | null;\n  readonly node: unknown;\n}\n\nexport interface ResolvedRef {\n  readonly resolved: boolean;\n  readonly node?: unknown;\n  readonly document?: Document;\n  readonly nodePointer?: string;\n}\n\nexport type Ref = { readonly $ref: string };\n\nexport function isNamedType(type: PropType): type is WalkType {\n  return typeof (type as { name?: unknown } | null | undefined)?.name === \"string\";\n}\n\nexport function joinPointer(base: string, key: string | number): string {\n  const start = base === \"\" ? \"#/\" : base;\n  return start.endsWith(\"/\") ? `${start}${key}` : `${start}/${key}`;\n}\n\nexport function escapePointer(fragment: string): string {\n  return fragment.replaceAll(\"~\", \"~0\").replaceAll(\"/\", \"~1\");\n}\n\n/** Redocly's `parseRef`: the document part (null for a local ref) and the unescaped segments. */\nexport function parseRef(ref: string): { uri: string | null; pointer: string[] } {\n  const [uri = \"\"] = ref.split(\"#/\");\n  return {\n    uri: (uri.endsWith(\"#\") ? uri.slice(0, -1) : uri) || null,\n    pointer: parseRefPointer(ref),\n  };\n}\n\nexport function hasRef(head: RefStack | null, node: unknown): boolean {\n  for (let entry = head; entry !== null; entry = entry.prev) {\n    if (entry.node === node) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function isExternalValue(node: object): node is { externalValue: string } {\n  return typeof (node as { externalValue?: unknown }).externalValue === \"string\";\n}\n\n/** Wait one macrotask, as Redocly does before it reads the anchors of a document. */\nexport function nextTick(): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve));\n}\n\n/**\n * The type Redocly gives one property value, and the value to walk (a `directResolveAs` string\n * becomes a `$ref`). A value whose type has no name is not walked.\n */\nexport function propertyType(\n  type: WalkType,\n  name: string,\n  value: unknown,\n  specExtension: WalkType,\n): [PropType, unknown] {\n  // `properties[name]` also finds `Object.prototype` members, as in Redocly; for `valueOf` and the\n  // like the call below throws the TypeError that the loader turns into SCHEMA_KEY_UNSUPPORTED.\n  let declared: PropTypeOrFunction = type.properties[name];\n  if (declared === undefined) {\n    declared = type.additionalProperties;\n  }\n  let propType: PropType = typeof declared === \"function\" ? declared(value, name) : declared;\n  if (propType === undefined) {\n    propType = UNKNOWN_TYPE;\n  }\n  if (\n    type.extensionsPrefix &&\n    name.startsWith(type.extensionsPrefix) &&\n    propType === UNKNOWN_TYPE\n  ) {\n    return [specExtension, value];\n  }\n  if (!isNamedType(propType) && propType?.directResolveAs) {\n    return [propType.directResolveAs, { $ref: value }];\n  }\n  if (propType && !isNamedType(propType) && propType.resolvable !== false) {\n    return [RESOLVABLE_SCALAR_TYPE, value];\n  }\n  return [propType, value];\n}\n"],"names":["parseRefPointer"],"mappings":"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"}

package/dist/adapters/redocly-loader/ref-resolution-steps.mjs

@@ -0,0 +1,60 @@
+import { parseRefPointer } from '../../domain/openapi/json-pointer.mjs';
+
+const UNKNOWN_TYPE = { name: "unknown", properties: {} };
+const RESOLVABLE_SCALAR_TYPE = { name: "scalar", properties: {} };
+const ANCHOR_REF = /^#[A-Za-z][A-Za-z0-9\-_:.]*$/;
+const REF_CYCLE_MESSAGE = "Self-referencing circular pointer";
+function isNamedType(type) {
+  return typeof type?.name === "string";
+}
+function joinPointer(base, key) {
+  const start = base === "" ? "#/" : base;
+  return start.endsWith("/") ? `${start}${key}` : `${start}/${key}`;
+}
+function escapePointer(fragment) {
+  return fragment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function parseRef(ref) {
+  const [uri = ""] = ref.split("#/");
+  return {
+    uri: (uri.endsWith("#") ? uri.slice(0, -1) : uri) || null,
+    pointer: parseRefPointer(ref)
+  };
+}
+function hasRef(head, node) {
+  for (let entry = head; entry !== null; entry = entry.prev) {
+    if (entry.node === node) {
+      return true;
+    }
+  }
+  return false;
+}
+function isExternalValue(node) {
+  return typeof node.externalValue === "string";
+}
+function nextTick() {
+  return new Promise((resolve) => setTimeout(resolve));
+}
+function propertyType(type, name, value, specExtension) {
+  let declared = type.properties[name];
+  if (declared === void 0) {
+    declared = type.additionalProperties;
+  }
+  let propType = typeof declared === "function" ? declared(value, name) : declared;
+  if (propType === void 0) {
+    propType = UNKNOWN_TYPE;
+  }
+  if (type.extensionsPrefix && name.startsWith(type.extensionsPrefix) && propType === UNKNOWN_TYPE) {
+    return [specExtension, value];
+  }
+  if (!isNamedType(propType) && propType?.directResolveAs) {
+    return [propType.directResolveAs, { $ref: value }];
+  }
+  if (propType && !isNamedType(propType) && propType.resolvable !== false) {
+    return [RESOLVABLE_SCALAR_TYPE, value];
+  }
+  return [propType, value];
+}
+
+export { ANCHOR_REF, REF_CYCLE_MESSAGE, RESOLVABLE_SCALAR_TYPE, UNKNOWN_TYPE, escapePointer, hasRef, isExternalValue, isNamedType, joinPointer, nextTick, parseRef, propertyType };
+//# sourceMappingURL=ref-resolution-steps.mjs.map

package/dist/adapters/redocly-loader/ref-resolution-steps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-resolution-steps.mjs","sources":["../../../src/adapters/redocly-loader/ref-resolution-steps.ts"],"sourcesContent":["import type { Document, normalizeTypes } from \"@redocly/openapi-core\";\nimport { parseRefPointer } from \"../../domain/openapi/json-pointer.js\";\n\n/**\n * The pieces of Redocly 1.34's `$ref` resolution (`lib/resolve.js`, `lib/ref-utils.js`, MIT) that\n * the resolution check (`ref-resolution-check.ts`, ADR-031) walks with, kept as Redocly has them.\n */\n\ntype RedoclyTypes = ReturnType<typeof normalizeTypes>;\nexport type WalkType = RedoclyTypes[string];\ntype PropTypeOrFunction = WalkType[\"properties\"][string] | WalkType[\"additionalProperties\"];\n/** The type of a property or array item, after Redocly called a type function. */\nexport type PropType = Exclude<PropTypeOrFunction, (...args: never[]) => unknown>;\n\n/** Redocly's own placeholders: a node of no known type, and a scalar that is a `$ref`. */\nexport const UNKNOWN_TYPE: WalkType = { name: \"unknown\", properties: {} };\nexport const RESOLVABLE_SCALAR_TYPE: WalkType = { name: \"scalar\", properties: {} };\n\n/** Redocly's test for an anchor reference (`#name`), which waits for the whole document walk. */\nexport const ANCHOR_REF = /^#[A-Za-z][A-Za-z0-9\\-_:.]*$/;\n\n/** Redocly throws a plain Error with this message for a `$ref` chain that points back to itself. */\nexport const REF_CYCLE_MESSAGE = \"Self-referencing circular pointer\";\n\nexport interface RefStack {\n  readonly prev: RefStack | null;\n  readonly node: unknown;\n}\n\nexport interface ResolvedRef {\n  readonly resolved: boolean;\n  readonly node?: unknown;\n  readonly document?: Document;\n  readonly nodePointer?: string;\n}\n\nexport type Ref = { readonly $ref: string };\n\nexport function isNamedType(type: PropType): type is WalkType {\n  return typeof (type as { name?: unknown } | null | undefined)?.name === \"string\";\n}\n\nexport function joinPointer(base: string, key: string | number): string {\n  const start = base === \"\" ? \"#/\" : base;\n  return start.endsWith(\"/\") ? `${start}${key}` : `${start}/${key}`;\n}\n\nexport function escapePointer(fragment: string): string {\n  return fragment.replaceAll(\"~\", \"~0\").replaceAll(\"/\", \"~1\");\n}\n\n/** Redocly's `parseRef`: the document part (null for a local ref) and the unescaped segments. */\nexport function parseRef(ref: string): { uri: string | null; pointer: string[] } {\n  const [uri = \"\"] = ref.split(\"#/\");\n  return {\n    uri: (uri.endsWith(\"#\") ? uri.slice(0, -1) : uri) || null,\n    pointer: parseRefPointer(ref),\n  };\n}\n\nexport function hasRef(head: RefStack | null, node: unknown): boolean {\n  for (let entry = head; entry !== null; entry = entry.prev) {\n    if (entry.node === node) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function isExternalValue(node: object): node is { externalValue: string } {\n  return typeof (node as { externalValue?: unknown }).externalValue === \"string\";\n}\n\n/** Wait one macrotask, as Redocly does before it reads the anchors of a document. */\nexport function nextTick(): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve));\n}\n\n/**\n * The type Redocly gives one property value, and the value to walk (a `directResolveAs` string\n * becomes a `$ref`). A value whose type has no name is not walked.\n */\nexport function propertyType(\n  type: WalkType,\n  name: string,\n  value: unknown,\n  specExtension: WalkType,\n): [PropType, unknown] {\n  // `properties[name]` also finds `Object.prototype` members, as in Redocly; for `valueOf` and the\n  // like the call below throws the TypeError that the loader turns into SCHEMA_KEY_UNSUPPORTED.\n  let declared: PropTypeOrFunction = type.properties[name];\n  if (declared === undefined) {\n    declared = type.additionalProperties;\n  }\n  let propType: PropType = typeof declared === \"function\" ? declared(value, name) : declared;\n  if (propType === undefined) {\n    propType = UNKNOWN_TYPE;\n  }\n  if (\n    type.extensionsPrefix &&\n    name.startsWith(type.extensionsPrefix) &&\n    propType === UNKNOWN_TYPE\n  ) {\n    return [specExtension, value];\n  }\n  if (!isNamedType(propType) && propType?.directResolveAs) {\n    return [propType.directResolveAs, { $ref: value }];\n  }\n  if (propType && !isNamedType(propType) && propType.resolvable !== false) {\n    return [RESOLVABLE_SCALAR_TYPE, value];\n  }\n  return [propType, value];\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/redocly-loader/remote-fetch.cjs

@@ -1,9 +1,10 @@
 'use strict';
 
 const allowedHosts = require('./allowed-hosts.cjs');
+const configuredHeaders = require('./configured-headers.cjs');
 const schemaLoadErrors = require('./schema-load-errors.cjs');
 
-const MAX_CHECKED_REDIRECTS = 5;
+const MAX_REDIRECTS = 20;
 const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
 async function bufferedResponse(response) {
@@ -26,35 +27,61 @@ function fetchWithTimeout(timeoutMs) {
     }
   };
 }
-function fetchWithCheckedRedirects(fetchImpl, hosts) {
+function fetchWithCheckedRedirects(fetchImpl, policy) {
   return async (input, init = {}) => {
-    const firstOrigin = new URL(input).origin;
     let url = new URL(input);
-    for (let hop = 0; hop <= MAX_CHECKED_REDIRECTS; hop += 1) {
-      if (hop > 0 && !allowedHosts.isHostAllowed(url, hosts)) {
-        throw schemaLoadErrors.refForbiddenError(url.href, { reason: "host-not-allowed", allowedHosts: [...hosts] });
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+      if (hop > 0 && policy.hosts !== void 0 && !allowedHosts.isHostAllowed(url, policy.hosts)) {
+        throw schemaLoadErrors.refForbiddenError(url.href, {
+          reason: "host-not-allowed",
+          allowedHosts: [...policy.hosts]
+        });
       }
-      const { headers, ...rest } = init;
-      const hopInit = url.origin === firstOrigin && headers !== void 0 ? { ...rest, headers } : rest;
-      const response = await fetchImpl(url.href, { ...hopInit, redirect: "manual" });
+      const headers = await configuredHeaders.headersFor(url, policy.headers);
+      const response = await fetchImpl(url.href, { ...init, headers, redirect: "manual" });
       const location = response.headers.get("location");
       if (!REDIRECT_STATUSES.has(response.status) || location === null) {
         return response;
       }
       url = new URL(location, url);
     }
-    throw new Error(`More than ${MAX_CHECKED_REDIRECTS} redirects loading ${input}`);
+    throw new Error(`More than ${MAX_REDIRECTS} redirects loading ${input}`);
+  };
+}
+function fetchWithConcurrencyLimit(fetchImpl, limit) {
+  let running = 0;
+  const waiting = [];
+  return async (input, init) => {
+    if (running < limit) {
+      running += 1;
+    } else {
+      await new Promise((resolve) => waiting.push(resolve));
+    }
+    try {
+      return await fetchImpl(input, init);
+    } finally {
+      const next = waiting.shift();
+      if (next === void 0) {
+        running -= 1;
+      } else {
+        next();
+      }
+    }
   };
 }
 function resolveConfigWithAccess(resolve, options) {
   const configured = resolve.http.customFetch;
   const base = configured ?? fetchWithTimeout(options.timeoutMs);
-  const hosts = options.access.remoteHosts;
-  const customFetch = hosts === void 0 ? base : fetchWithCheckedRedirects(base, hosts);
-  return { ...resolve, http: { ...resolve.http, customFetch } };
+  const checked = fetchWithCheckedRedirects(base, {
+    headers: resolve.http.headers,
+    hosts: options.access.remoteHosts
+  });
+  const customFetch = fetchWithConcurrencyLimit(checked, options.maxParallelFetches);
+  return { ...resolve, http: { ...resolve.http, headers: [], customFetch } };
 }
 
-exports.MAX_CHECKED_REDIRECTS = MAX_CHECKED_REDIRECTS;
+exports.MAX_REDIRECTS = MAX_REDIRECTS;
 exports.fetchWithCheckedRedirects = fetchWithCheckedRedirects;
+exports.fetchWithConcurrencyLimit = fetchWithConcurrencyLimit;
 exports.resolveConfigWithAccess = resolveConfigWithAccess;
 //# sourceMappingURL=remote-fetch.cjs.map

package/dist/adapters/redocly-loader/remote-fetch.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"remote-fetch.cjs","sources":["../../../src/adapters/redocly-loader/remote-fetch.ts"],"sourcesContent":["import type { Config as RedoclyConfig } from \"@redocly/openapi-core\";\nimport type { RefAccess } from \"../../application/ports/schema-loader.js\";\nimport { isHostAllowed } from \"./allowed-hosts.js\";\nimport { refForbiddenError } from \"./schema-load-errors.js\";\n\n/** How the loader fetches remote documents: a time limit, and the host limit on redirects. */\n\ntype ResolveConfig = RedoclyConfig[\"resolve\"];\n\n/** The fetch Redocly calls for a remote document (`resolve.http.customFetch`). */\nexport type RemoteFetch = (input: string, init?: RequestInit) => Promise<Response>;\n\n/**\n * Redirects followed for a remote `$ref` when hosts are limited. Each hop is checked, so fetch\n * cannot follow them on its own; 5 covers http → https plus a moved file, and a loop stops early.\n */\nexport const MAX_CHECKED_REDIRECTS = 5;\n\nconst REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);\n\n/** Statuses whose responses have no body; `new Response()` refuses a body for them. */\nconst NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);\n\n/** A response whose body is already read, so that reading it again cannot wait or fail. */\nasync function bufferedResponse(response: Response): Promise<Response> {\n  const body = await response.arrayBuffer();\n  const { status, statusText, headers } = response;\n  return new Response(NULL_BODY_STATUSES.has(status) ? null : body, {\n    status,\n    statusText,\n    headers,\n  });\n}\n\n/**\n * Fetch with a time limit for the whole response, body included: Node's own fetch waits five\n * minutes for a server that never answers, and a server that sends its body one byte at a time\n * never finishes. The body is read here, inside the limit; when Redocly read it, the abort\n * surfaced as a `DOMException` whose read-only `message` Redocly tried to change, which gave\n * \"Cannot set property message of  which has only a getter\" instead of the time limit.\n */\nfunction fetchWithTimeout(timeoutMs: number): RemoteFetch {\n  return async (input, init = {}) => {\n    try {\n      const response = await fetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) });\n      return await bufferedResponse(response);\n    } catch (cause) {\n      const isTimeout = cause instanceof Error && cause.name === \"TimeoutError\";\n      throw isTimeout ? new Error(`Timed out after ${timeoutMs} ms loading ${input}`) : cause;\n    }\n  };\n}\n\n/**\n * Follow redirects one by one, and refuse a redirect to a host that is not listed. The first URL\n * was checked by the resolver (or is the root document). As fetch does, the configured headers\n * (often credentials) are not sent on to another origin.\n */\nexport function fetchWithCheckedRedirects(\n  fetchImpl: RemoteFetch,\n  hosts: readonly string[],\n): RemoteFetch {\n  return async (input, init = {}) => {\n    const firstOrigin = new URL(input).origin;\n    let url = new URL(input);\n    for (let hop = 0; hop <= MAX_CHECKED_REDIRECTS; hop += 1) {\n      if (hop > 0 && !isHostAllowed(url, hosts)) {\n        throw refForbiddenError(url.href, { reason: \"host-not-allowed\", allowedHosts: [...hosts] });\n      }\n      const { headers, ...rest } = init;\n      const hopInit: RequestInit =\n        url.origin === firstOrigin && headers !== undefined ? { ...rest, headers } : rest;\n      const response = await fetchImpl(url.href, { ...hopInit, redirect: \"manual\" });\n      const location = response.headers.get(\"location\");\n      if (!REDIRECT_STATUSES.has(response.status) || location === null) {\n        return response;\n      }\n      url = new URL(location, url);\n    }\n    throw new Error(`More than ${MAX_CHECKED_REDIRECTS} redirects loading ${input}`);\n  };\n}\n\nexport interface RemoteFetchOptions {\n  /** Time limit of one fetch and its body, unless the Redocly config has its own `customFetch`. */\n  readonly timeoutMs: number;\n  readonly access: RefAccess;\n}\n\n/**\n * The resolve config with the fetch the loader uses. A `customFetch` of the Redocly config is\n * kept; with a host limit, it is wrapped so that each redirect is checked.\n */\nexport function resolveConfigWithAccess(\n  resolve: ResolveConfig,\n  options: RemoteFetchOptions,\n): ResolveConfig {\n  // Redocly types `customFetch` as `Function`; it is called as fetch is.\n  const configured = resolve.http.customFetch as RemoteFetch | undefined;\n  const base = configured ?? fetchWithTimeout(options.timeoutMs);\n  const hosts = options.access.remoteHosts;\n  const customFetch = hosts === undefined ? base : fetchWithCheckedRedirects(base, hosts);\n  return { ...resolve, http: { ...resolve.http, customFetch } };\n}\n"],"names":["isHostAllowed","refForbiddenError"],"mappings":"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"}
+{"version":3,"file":"remote-fetch.cjs","sources":["../../../src/adapters/redocly-loader/remote-fetch.ts"],"sourcesContent":["import type { Config as RedoclyConfig } from \"@redocly/openapi-core\";\nimport type { RefAccess } from \"../../application/ports/schema-loader.js\";\nimport { isHostAllowed } from \"./allowed-hosts.js\";\nimport { type ConfiguredHeader, headersFor } from \"./configured-headers.js\";\nimport { refForbiddenError } from \"./schema-load-errors.js\";\n\n/**\n * How the loader fetches remote documents: a time limit, the host limit and the configured headers\n * checked on every redirect.\n */\n\ntype ResolveConfig = RedoclyConfig[\"resolve\"];\n\n/** The fetch Redocly calls for a remote document (`resolve.http.customFetch`). */\nexport type RemoteFetch = (input: string, init?: RequestInit) => Promise<Response>;\n\n/**\n * Redirects followed for one remote document. The loader follows them itself, so that each hop is\n * checked; 20 is the limit of the Fetch standard, which fetch applied before.\n */\nexport const MAX_REDIRECTS = 20;\n\nconst REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);\n\n/** Statuses whose responses have no body; `new Response()` refuses a body for them. */\nconst NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);\n\n/** A response whose body is already read, so that reading it again cannot wait or fail. */\nasync function bufferedResponse(response: Response): Promise<Response> {\n  const body = await response.arrayBuffer();\n  const { status, statusText, headers } = response;\n  return new Response(NULL_BODY_STATUSES.has(status) ? null : body, {\n    status,\n    statusText,\n    headers,\n  });\n}\n\n/**\n * Fetch with a time limit for the whole response, body included: Node's own fetch waits five\n * minutes for a server that never answers, and a server that sends its body one byte at a time\n * never finishes. The body is read here, inside the limit; when Redocly read it, the abort\n * surfaced as a `DOMException` whose read-only `message` Redocly tried to change, which gave\n * \"Cannot set property message of  which has only a getter\" instead of the time limit.\n */\nfunction fetchWithTimeout(timeoutMs: number): RemoteFetch {\n  return async (input, init = {}) => {\n    try {\n      const response = await fetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) });\n      return await bufferedResponse(response);\n    } catch (cause) {\n      const isTimeout = cause instanceof Error && cause.name === \"TimeoutError\";\n      throw isTimeout ? new Error(`Timed out after ${timeoutMs} ms loading ${input}`) : cause;\n    }\n  };\n}\n\n/** What every hop of a remote fetch is checked against. */\nexport interface RedirectPolicy {\n  /** `resolve.http.headers` of the Redocly config; chosen again for the URL of every hop. */\n  readonly headers: readonly ConfiguredHeader[];\n  /** `--remote-ref-hosts`; undefined allows every host. */\n  readonly hosts: readonly string[] | undefined;\n}\n\n/**\n * Follow redirects one by one. Fetch drops only `Authorization`, `Cookie` and\n * `Proxy-Authorization` on a redirect to another origin and keeps every other header (an\n * `X-Api-Key`), so the configured headers are chosen for each hop's own URL instead, and a hop to\n * a host that is not listed is refused before it is fetched. The first URL was checked by the\n * resolver (or is the root document). Redocly passes only the configured headers in `init`, and\n * it gets an empty list of them (`resolveConfigWithAccess`), so `init.headers` is replaced.\n */\nexport function fetchWithCheckedRedirects(\n  fetchImpl: RemoteFetch,\n  policy: RedirectPolicy,\n): RemoteFetch {\n  return async (input, init = {}) => {\n    let url = new URL(input);\n    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {\n      if (hop > 0 && policy.hosts !== undefined && !isHostAllowed(url, policy.hosts)) {\n        throw refForbiddenError(url.href, {\n          reason: \"host-not-allowed\",\n          allowedHosts: [...policy.hosts],\n        });\n      }\n      const headers = await headersFor(url, policy.headers);\n      const response = await fetchImpl(url.href, { ...init, headers, redirect: \"manual\" });\n      const location = response.headers.get(\"location\");\n      if (!REDIRECT_STATUSES.has(response.status) || location === null) {\n        return response;\n      }\n      url = new URL(location, url);\n    }\n    throw new Error(`More than ${MAX_REDIRECTS} redirects loading ${input}`);\n  };\n}\n\n/** Bounds on the remote documents of one load (threat model T2, ADR-033). */\nexport interface RemoteDocumentLimits {\n  /** Remote documents one load may fetch, the root included; one more is refused. */\n  readonly maxDocuments: number;\n  /** Remote documents fetched at the same time; the others wait for a free slot. */\n  readonly maxParallelFetches: number;\n}\n\n/**\n * At most `limit` calls of the fetch run at once; the others wait in order. A finished call hands\n * its slot to the next waiting one.\n */\nexport function fetchWithConcurrencyLimit(fetchImpl: RemoteFetch, limit: number): RemoteFetch {\n  let running = 0;\n  const waiting: (() => void)[] = [];\n  return async (input, init) => {\n    if (running < limit) {\n      running += 1;\n    } else {\n      await new Promise<void>((resolve) => waiting.push(resolve));\n    }\n    try {\n      return await fetchImpl(input, init);\n    } finally {\n      const next = waiting.shift();\n      if (next === undefined) {\n        running -= 1;\n      } else {\n        next();\n      }\n    }\n  };\n}\n\nexport interface RemoteFetchOptions {\n  /** Time limit of one fetch and its body, unless the Redocly config has its own `customFetch`. */\n  readonly timeoutMs: number;\n  readonly access: RefAccess;\n  readonly maxParallelFetches: number;\n}\n\n/**\n * The resolve config with the fetch the loader uses. A `customFetch` of the Redocly config is\n * kept and wrapped, so that each redirect is checked and only a few documents load at once. The\n * configured headers move into that wrapper: Redocly would match them against the raw URL and\n * send them on through redirects.\n */\nexport function resolveConfigWithAccess(\n  resolve: ResolveConfig,\n  options: RemoteFetchOptions,\n): ResolveConfig {\n  // Redocly types `customFetch` as `Function`; it is called as fetch is.\n  const configured = resolve.http.customFetch as RemoteFetch | undefined;\n  const base = configured ?? fetchWithTimeout(options.timeoutMs);\n  const checked = fetchWithCheckedRedirects(base, {\n    headers: resolve.http.headers,\n    hosts: options.access.remoteHosts,\n  });\n  // The limit is outside the redirects, so all hops of one document share one slot.\n  const customFetch = fetchWithConcurrencyLimit(checked, options.maxParallelFetches);\n  return { ...resolve, http: { ...resolve.http, headers: [], customFetch } };\n}\n"],"names":["isHostAllowed","refForbiddenError","headersFor"],"mappings":"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"}

package/dist/adapters/redocly-loader/remote-fetch.mjs

@@ -1,7 +1,8 @@
 import { isHostAllowed } from './allowed-hosts.mjs';
+import { headersFor } from './configured-headers.mjs';
 import { refForbiddenError } from './schema-load-errors.mjs';
 
-const MAX_CHECKED_REDIRECTS = 5;
+const MAX_REDIRECTS = 20;
 const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
 async function bufferedResponse(response) {
@@ -24,33 +25,58 @@ function fetchWithTimeout(timeoutMs) {
     }
   };
 }
-function fetchWithCheckedRedirects(fetchImpl, hosts) {
+function fetchWithCheckedRedirects(fetchImpl, policy) {
   return async (input, init = {}) => {
-    const firstOrigin = new URL(input).origin;
     let url = new URL(input);
-    for (let hop = 0; hop <= MAX_CHECKED_REDIRECTS; hop += 1) {
-      if (hop > 0 && !isHostAllowed(url, hosts)) {
-        throw refForbiddenError(url.href, { reason: "host-not-allowed", allowedHosts: [...hosts] });
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+      if (hop > 0 && policy.hosts !== void 0 && !isHostAllowed(url, policy.hosts)) {
+        throw refForbiddenError(url.href, {
+          reason: "host-not-allowed",
+          allowedHosts: [...policy.hosts]
+        });
       }
-      const { headers, ...rest } = init;
-      const hopInit = url.origin === firstOrigin && headers !== void 0 ? { ...rest, headers } : rest;
-      const response = await fetchImpl(url.href, { ...hopInit, redirect: "manual" });
+      const headers = await headersFor(url, policy.headers);
+      const response = await fetchImpl(url.href, { ...init, headers, redirect: "manual" });
       const location = response.headers.get("location");
       if (!REDIRECT_STATUSES.has(response.status) || location === null) {
         return response;
       }
       url = new URL(location, url);
     }
-    throw new Error(`More than ${MAX_CHECKED_REDIRECTS} redirects loading ${input}`);
+    throw new Error(`More than ${MAX_REDIRECTS} redirects loading ${input}`);
+  };
+}
+function fetchWithConcurrencyLimit(fetchImpl, limit) {
+  let running = 0;
+  const waiting = [];
+  return async (input, init) => {
+    if (running < limit) {
+      running += 1;
+    } else {
+      await new Promise((resolve) => waiting.push(resolve));
+    }
+    try {
+      return await fetchImpl(input, init);
+    } finally {
+      const next = waiting.shift();
+      if (next === void 0) {
+        running -= 1;
+      } else {
+        next();
+      }
+    }
   };
 }
 function resolveConfigWithAccess(resolve, options) {
   const configured = resolve.http.customFetch;
   const base = configured ?? fetchWithTimeout(options.timeoutMs);
-  const hosts = options.access.remoteHosts;
-  const customFetch = hosts === void 0 ? base : fetchWithCheckedRedirects(base, hosts);
-  return { ...resolve, http: { ...resolve.http, customFetch } };
+  const checked = fetchWithCheckedRedirects(base, {
+    headers: resolve.http.headers,
+    hosts: options.access.remoteHosts
+  });
+  const customFetch = fetchWithConcurrencyLimit(checked, options.maxParallelFetches);
+  return { ...resolve, http: { ...resolve.http, headers: [], customFetch } };
 }
 
-export { MAX_CHECKED_REDIRECTS, fetchWithCheckedRedirects, resolveConfigWithAccess };
+export { MAX_REDIRECTS, fetchWithCheckedRedirects, fetchWithConcurrencyLimit, resolveConfigWithAccess };
 //# sourceMappingURL=remote-fetch.mjs.map