@speclynx/apidom-reference 2.4.0 → 2.5.0

package/src/dereference/strategies/arazzo-1/visitor.mjs

@@ -0,0 +1,405 @@
+import { propEq, none } from 'ramda';
+import { isElement, isStringElement, RefElement, cloneShallow, cloneDeep } from '@speclynx/apidom-datamodel';
+import { IdentityManager, toValue } from '@speclynx/apidom-core';
+import { ApiDOMError } from '@speclynx/apidom-error';
+import { traverseAsync } from '@speclynx/apidom-traverse';
+import { evaluate as jsonPointerEvaluate, compile as jsonPointerCompile, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
+import { isParameterElement, isJSONSchemaElement, isBooleanJSONSchemaElement } from '@speclynx/apidom-ns-arazzo-1';
+import { parse as parseRuntimeExpression } from '@swaggerexpert/arazzo-runtime-expression';
+import { isAnchor, uriToAnchor, evaluate as $anchorEvaluate } from "./selectors/$anchor.mjs";
+import { evaluate as uriEvaluate } from "./selectors/uri.mjs";
+import { resolveSchema$refField } from "../openapi-3-1/util.mjs";
+import { maybeRefractToJSONSchemaElement } from "./util.mjs";
+import MaximumDereferenceDepthError from "../../../errors/MaximumDereferenceDepthError.mjs";
+import MaximumResolveDepthError from "../../../errors/MaximumResolveDepthError.mjs";
+import * as url from "../../../util/url.mjs";
+import parse from "../../../parse/index.mjs";
+import Reference from "../../../Reference.mjs";
+import File from "../../../File.mjs";
+import { AncestorLineage } from "../../util.mjs";
+import EvaluationJsonSchemaUriError from "../../../errors/EvaluationJsonSchemaUriError.mjs";
+// initialize element identity manager
+const identityManager = new IdentityManager();
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Arazzo1DereferenceVisitor {
+  indirections;
+  namespace;
+  reference;
+  options;
+  ancestors;
+  constructor({
+    reference,
+    namespace,
+    options,
+    indirections = [],
+    ancestors = new AncestorLineage()
+  }) {
+    this.indirections = indirections;
+    this.namespace = namespace;
+    this.reference = reference;
+    this.options = options;
+    this.ancestors = new AncestorLineage(...ancestors);
+  }
+  toBaseURI(uri) {
+    return url.resolve(this.reference.uri, url.sanitize(url.stripHash(uri)));
+  }
+  async toReference(uri) {
+    // detect maximum depth of resolution
+    if (this.reference.depth >= this.options.resolve.maxDepth) {
+      throw new MaximumResolveDepthError(`Maximum resolution depth of ${this.options.resolve.maxDepth} has been exceeded by file "${this.reference.uri}"`);
+    }
+    const baseURI = this.toBaseURI(uri);
+    const {
+      refSet
+    } = this.reference;
+
+    // we've already processed this Reference in past
+    if (refSet.has(baseURI)) {
+      return refSet.find(propEq(baseURI, 'uri'));
+    }
+    const parseResult = await parse(url.unsanitize(baseURI), {
+      ...this.options,
+      parse: {
+        ...this.options.parse,
+        mediaType: 'text/plain'
+      }
+    });
+
+    // register new mutable reference with a refSet
+    const mutableReference = new Reference({
+      uri: baseURI,
+      value: cloneDeep(parseResult),
+      depth: this.reference.depth + 1
+    });
+    refSet.add(mutableReference);
+    if (this.options.dereference.immutable) {
+      // register new immutable reference with a refSet
+      const immutableReference = new Reference({
+        uri: `immutable://${baseURI}`,
+        value: parseResult,
+        depth: this.reference.depth + 1
+      });
+      refSet.add(immutableReference);
+    }
+    return mutableReference;
+  }
+  toAncestorLineage(path) {
+    /**
+     * Compute full ancestors lineage.
+     * Ancestors are flatten to unwrap all Element instances.
+     */
+    const ancestorNodes = path.getAncestorNodes();
+    const directAncestors = new Set(ancestorNodes.filter(isElement));
+    const ancestorsLineage = new AncestorLineage(...this.ancestors, directAncestors);
+    return [ancestorsLineage, directAncestors];
+  }
+  ReusableElement(path) {
+    const referencingElement = path.node;
+
+    // skip current Reusable Object if reference field is not defined as a string
+    if (!isStringElement(referencingElement.reference)) {
+      path.skip();
+      return;
+    }
+
+    // ignore if resolve.internal is false (Reusable Objects are internal references only)
+    if (!this.options.resolve.internal) {
+      path.skip();
+      return;
+    }
+    const runtimeExpression = toValue(referencingElement.reference);
+
+    // parse the runtime expression
+    const {
+      result,
+      tree
+    } = parseRuntimeExpression(runtimeExpression);
+    if (!result.success) {
+      throw new ApiDOMError(`Invalid Reusable Object reference format: "${runtimeExpression}"`);
+    }
+
+    // ReusableElement can only reference components
+    if (tree.type !== 'ComponentsExpression') {
+      throw new ApiDOMError(`Reusable Object reference "${runtimeExpression}" must be a components expression`);
+    }
+
+    // evaluate runtime expression as JSON Pointer to get the referenced element
+    const jsonPointer = jsonPointerCompile(['components', tree.field, tree.subField]);
+    let referencedElement;
+    try {
+      referencedElement = jsonPointerEvaluate(this.reference.value.result, jsonPointer);
+    } catch {
+      throw new ApiDOMError(`Reusable Object reference "${runtimeExpression}" cannot be resolved`);
+    }
+
+    /**
+     * Create a shallow clone of the referenced element to avoid modifying the original.
+     */
+    const mergedElement = cloneShallow(referencedElement);
+    // assign unique id to merged element
+    mergedElement.meta.set('id', identityManager.generateId());
+    // annotate with info about original referencing element
+    mergedElement.meta.set('ref-fields', {
+      reference: runtimeExpression,
+      value: toValue(referencingElement.value)
+    });
+    // annotate with info about origin
+    mergedElement.meta.set('ref-origin', this.reference.uri);
+    // annotate with info about referencing element
+    mergedElement.meta.set('ref-referencing-element-id', identityManager.identify(referencingElement));
+
+    // override value field if present for Parameter Objects
+    if (isParameterElement(mergedElement) && referencingElement.hasKey('value')) {
+      mergedElement.remove('value');
+      mergedElement.set('value', referencingElement.get('value'));
+    }
+
+    /**
+     * Transclude referencing element with merged referenced element.
+     */
+    path.replaceWith(mergedElement);
+  }
+  async JSONSchemaElement(path) {
+    const referencingElement = path.node;
+
+    // skip current referencing schema as $ref keyword was not defined
+    if (!isStringElement(referencingElement.$ref)) {
+      return;
+    }
+
+    // skip current referencing element as it's already been accessed
+    if (this.indirections.includes(referencingElement)) {
+      path.skip();
+      return;
+    }
+    const [ancestorsLineage, directAncestors] = this.toAncestorLineage(path);
+
+    // compute baseURI using rules around $id and $ref keywords
+    let reference = await this.toReference(url.unsanitize(this.reference.uri));
+    let {
+      uri: retrievalURI
+    } = reference;
+    const $refBaseURI = resolveSchema$refField(retrievalURI, referencingElement);
+    const $refBaseURIStrippedHash = url.stripHash($refBaseURI);
+    const file = new File({
+      uri: $refBaseURIStrippedHash
+    });
+    const isUnknownURI = none(r => r.canRead(file), this.options.resolve.resolvers);
+    const isURL = !isUnknownURI;
+    let isInternalReference = url.stripHash(this.reference.uri) === $refBaseURI;
+    let isExternalReference = !isInternalReference;
+
+    // determining reference, proper evaluation and selection mechanism
+    let referencedElement;
+    try {
+      if (isUnknownURI || isURL) {
+        // we're dealing with canonical URI or URL with possible fragment
+        retrievalURI = this.toBaseURI($refBaseURI);
+        const selector = $refBaseURI;
+        const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+        referencedElement = uriEvaluate(selector, referenceAsSchema);
+        referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
+        referencedElement.id = identityManager.identify(referencedElement);
+
+        // ignore resolving internal Schema Objects
+        if (!this.options.resolve.internal && isInternalReference) {
+          // skip traversing this schema element but traverse all its child elements
+          return;
+        }
+        // ignore resolving external Schema Objects
+        if (!this.options.resolve.external && isExternalReference) {
+          // skip traversing this schema element but traverse all its child elements
+          return;
+        }
+      } else {
+        // we're assuming here that we're dealing with JSON Pointer here
+        retrievalURI = this.toBaseURI($refBaseURI);
+        isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
+        isExternalReference = !isInternalReference;
+
+        // ignore resolving internal Schema Objects
+        if (!this.options.resolve.internal && isInternalReference) {
+          // skip traversing this schema element but traverse all its child elements
+          return;
+        }
+        // ignore resolving external Schema Objects
+        if (!this.options.resolve.external && isExternalReference) {
+          // skip traversing this schema element but traverse all its child elements
+          return;
+        }
+        reference = await this.toReference(url.unsanitize($refBaseURI));
+        const selector = URIFragmentIdentifier.fromURIReference($refBaseURI);
+        const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+        referencedElement = jsonPointerEvaluate(referenceAsSchema, selector);
+        referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
+        referencedElement.id = identityManager.identify(referencedElement);
+      }
+    } catch (error) {
+      /**
+       * JSONSchemaElement($id=URL) was not found, so we're going to try to resolve
+       * the URL and assume the returned response is a JSON Schema.
+       */
+      if (isURL && error instanceof EvaluationJsonSchemaUriError) {
+        if (isAnchor(uriToAnchor($refBaseURI))) {
+          // we're dealing with JSON Schema $anchor here
+          isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
+          isExternalReference = !isInternalReference;
+
+          // ignore resolving internal Schema Objects
+          if (!this.options.resolve.internal && isInternalReference) {
+            // skip traversing this schema element but traverse all its child elements
+            return;
+          }
+          // ignore resolving external Schema Objects
+          if (!this.options.resolve.external && isExternalReference) {
+            // skip traversing this schema element but traverse all its child elements
+            return;
+          }
+          reference = await this.toReference(url.unsanitize($refBaseURI));
+          const selector = uriToAnchor($refBaseURI);
+          const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+          referencedElement = $anchorEvaluate(selector, referenceAsSchema);
+          referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
+          referencedElement.id = identityManager.identify(referencedElement);
+        } else {
+          // we're assuming here that we're dealing with JSON Pointer here
+          retrievalURI = this.toBaseURI($refBaseURI);
+          isInternalReference = url.stripHash(this.reference.uri) === retrievalURI;
+          isExternalReference = !isInternalReference;
+
+          // ignore resolving internal Schema Objects
+          if (!this.options.resolve.internal && isInternalReference) {
+            // skip traversing this schema element but traverse all its child elements
+            return;
+          }
+          // ignore resolving external Schema Objects
+          if (!this.options.resolve.external && isExternalReference) {
+            // skip traversing this schema element but traverse all its child elements
+            return;
+          }
+          reference = await this.toReference(url.unsanitize($refBaseURI));
+          const selector = URIFragmentIdentifier.fromURIReference($refBaseURI);
+          const referenceAsSchema = maybeRefractToJSONSchemaElement(reference.value.result);
+          referencedElement = jsonPointerEvaluate(referenceAsSchema, selector);
+          referencedElement = maybeRefractToJSONSchemaElement(referencedElement);
+          referencedElement.id = identityManager.identify(referencedElement);
+        }
+      } else {
+        throw error;
+      }
+    }
+    this.indirections.push(referencingElement);
+
+    // detect direct or indirect reference
+    if (referencingElement === referencedElement) {
+      throw new ApiDOMError('Recursive JSON Schema reference detected');
+    }
+
+    // detect maximum depth of dereferencing
+    if (this.indirections.length > this.options.dereference.maxDepth) {
+      throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
+    }
+
+    // detect second deep dive into the same fragment and avoid it
+    if (ancestorsLineage.includes(referencedElement)) {
+      reference.refSet.circular = true;
+      if (this.options.dereference.circular === 'error') {
+        throw new ApiDOMError('Circular reference detected');
+      } else if (this.options.dereference.circular === 'replace') {
+        const refElement = new RefElement(referencedElement.id, {
+          type: 'json-schema',
+          uri: reference.uri,
+          $ref: toValue(referencingElement.$ref)
+        });
+        const replacer = this.options.dereference.strategyOpts['arazzo-1']?.circularReplacer ?? this.options.dereference.circularReplacer;
+        const replacement = replacer(refElement);
+        this.indirections.pop();
+        path.replaceWith(replacement);
+        return;
+      }
+    }
+
+    /**
+     * Dive deep into the fragment.
+     *
+     * Cases to consider:
+     *  1. We're crossing document boundary
+     *  2. Fragment is from non-root document
+     *  3. Fragment is a JSON Schema with $ref field. We need to follow it to get the eventual value
+     *  4. We are dereferencing the fragment lazily/eagerly depending on circular mode
+     */
+    const isNonRootDocument = url.stripHash(reference.refSet.rootRef.uri) !== reference.uri;
+    const shouldDetectCircular = ['error', 'replace'].includes(this.options.dereference.circular);
+    if ((isExternalReference || isNonRootDocument || isJSONSchemaElement(referencedElement) && isStringElement(referencedElement.$ref) || shouldDetectCircular) && !ancestorsLineage.includesCycle(referencedElement)) {
+      // append referencing reference to ancestors lineage
+      directAncestors.add(referencingElement);
+      const visitor = new Arazzo1DereferenceVisitor({
+        reference,
+        namespace: this.namespace,
+        indirections: [...this.indirections],
+        options: this.options,
+        ancestors: ancestorsLineage
+      });
+      referencedElement = await traverseAsync(referencedElement, visitor, {
+        mutable: true
+      });
+
+      // remove referencing reference from ancestors lineage
+      directAncestors.delete(referencingElement);
+    }
+    this.indirections.pop();
+
+    // Boolean JSON Schemas
+    if (isBooleanJSONSchemaElement(referencedElement)) {
+      const booleanJsonSchemaElement = cloneDeep(referencedElement);
+      // assign unique id to merged element
+      booleanJsonSchemaElement.meta.set('id', identityManager.generateId());
+      // annotate referenced element with info about original referencing element
+      booleanJsonSchemaElement.meta.set('ref-fields', {
+        $ref: toValue(referencingElement.$ref)
+      });
+      // annotate referenced element with info about origin
+      booleanJsonSchemaElement.meta.set('ref-origin', reference.uri);
+      // annotate fragment with info about referencing element
+      booleanJsonSchemaElement.meta.set('ref-referencing-element-id', cloneDeep(identityManager.identify(referencingElement)));
+      path.replaceWith(booleanJsonSchemaElement);
+      return;
+    }
+
+    /**
+     * Creating a new version of JSON Schema by merging fields from referenced Schema with referencing one.
+     */
+    if (isJSONSchemaElement(referencedElement)) {
+      const mergedElement = cloneShallow(referencedElement);
+      // assign unique id to merged element
+      mergedElement.meta.set('id', identityManager.generateId());
+      // existing keywords from referencing schema overrides ones from referenced schema
+      referencingElement.forEach((value, keyElement, item) => {
+        mergedElement.remove(toValue(keyElement));
+        mergedElement.content.push(item);
+      });
+      mergedElement.remove('$ref');
+      // annotate referenced element with info about original referencing element
+      mergedElement.meta.set('ref-fields', {
+        $ref: toValue(referencingElement.$ref)
+      });
+      // annotate fragment with info about origin
+      mergedElement.meta.set('ref-origin', reference.uri);
+      // annotate fragment with info about referencing element
+      mergedElement.meta.set('ref-referencing-element-id', cloneDeep(identityManager.identify(referencingElement)));
+      referencedElement = mergedElement;
+    }
+    /**
+     * Transclude referencing element with merged referenced element.
+     */
+    path.replaceWith(referencedElement);
+  }
+}
+export default Arazzo1DereferenceVisitor;

package/src/dereference/strategies/asyncapi-2/visitor.cjs

@@ -219,7 +219,7 @@ class AsyncAPI2DereferenceVisitor {
     this.indirections.pop();
 
     // Boolean JSON Schemas
-    if ((0, _apidomNsAsyncapi.isBooleanJsonSchemaElement)(referencedElement)) {
+    if ((0, _apidomNsAsyncapi.isBooleanJSONSchemaElement)(referencedElement)) {
       const booleanJsonSchemaElement = (0, _apidomDatamodel.cloneDeep)(referencedElement);
       // assign unique id to merged element
       booleanJsonSchemaElement.meta.set('id', identityManager.generateId());

package/src/dereference/strategies/asyncapi-2/visitor.mjs

@@ -4,7 +4,7 @@ import { IdentityManager, toValue } from '@speclynx/apidom-core';
 import { ApiDOMError } from '@speclynx/apidom-error';
 import { traverseAsync } from '@speclynx/apidom-traverse';
 import { evaluate, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
-import { isReferenceLikeElement, isBooleanJsonSchemaElement, isChannelItemElement, isReferenceElement, refract, refractReference, refractChannelItem } from '@speclynx/apidom-ns-asyncapi-2';
+import { isReferenceLikeElement, isBooleanJSONSchemaElement, isChannelItemElement, isReferenceElement, refract, refractReference, refractChannelItem } from '@speclynx/apidom-ns-asyncapi-2';
 import MaximumDereferenceDepthError from "../../../errors/MaximumDereferenceDepthError.mjs";
 import MaximumResolveDepthError from "../../../errors/MaximumResolveDepthError.mjs";
 import { AncestorLineage } from "../../util.mjs";
@@ -213,7 +213,7 @@ class AsyncAPI2DereferenceVisitor {
     this.indirections.pop();
 
     // Boolean JSON Schemas
-    if (isBooleanJsonSchemaElement(referencedElement)) {
+    if (isBooleanJSONSchemaElement(referencedElement)) {
       const booleanJsonSchemaElement = cloneDeep(referencedElement);
       // assign unique id to merged element
       booleanJsonSchemaElement.meta.set('id', identityManager.generateId());

package/src/dereference/strategies/openapi-3-1/selectors/$anchor.cjs

@@ -6,7 +6,7 @@ exports.uriToAnchor = exports.parse = exports.isAnchor = exports.evaluate = expo
 var _ramdaAdjunct = require("ramda-adjunct");
 var _apidomCore = require("@speclynx/apidom-core");
 var _apidomTraverse = require("@speclynx/apidom-traverse");
-var _apidomNsOpenapi = require("@speclynx/apidom-ns-openapi-3-1");
+var _apidomNsJsonSchema = require("@speclynx/apidom-ns-json-schema-2020-12");
 var _url = require("../../../../util/url.cjs");
 var _EvaluationJsonSchema$anchorError = _interopRequireDefault(require("../../../../errors/EvaluationJsonSchema$anchorError.cjs"));
 exports.EvaluationJsonSchema$anchorError = _EvaluationJsonSchema$anchorError.default;
@@ -56,7 +56,7 @@ const evaluate = (anchor, element) => {
   const token = parse(anchor);
 
   // @ts-ignore
-  const result = (0, _apidomTraverse.find)(element, e => (0, _apidomNsOpenapi.isSchemaElement)(e) && (0, _apidomCore.toValue)(e.$anchor) === token);
+  const result = (0, _apidomTraverse.find)(element, e => (0, _apidomNsJsonSchema.isJSONSchemaElement)(e) && (0, _apidomCore.toValue)(e.$anchor) === token);
   if ((0, _ramdaAdjunct.isUndefined)(result)) {
     throw new _EvaluationJsonSchema$anchorError.default(`Evaluation failed on token: "${token}"`);
   }

package/src/dereference/strategies/openapi-3-1/selectors/$anchor.mjs

@@ -1,7 +1,7 @@
 import { trimCharsStart, isUndefined } from 'ramda-adjunct';
 import { toValue } from '@speclynx/apidom-core';
 import { find } from '@speclynx/apidom-traverse';
-import { isSchemaElement } from '@speclynx/apidom-ns-openapi-3-1';
+import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
 import { getHash } from "../../../../util/url.mjs";
 import EvaluationJsonSchema$anchorError from "../../../../errors/EvaluationJsonSchema$anchorError.mjs";
 import InvalidJsonSchema$anchorError from "../../../../errors/InvalidJsonSchema$anchorError.mjs";
@@ -44,7 +44,7 @@ export const evaluate = (anchor, element) => {
   const token = parse(anchor);
 
   // @ts-ignore
-  const result = find(element, e => isSchemaElement(e) && toValue(e.$anchor) === token);
+  const result = find(element, e => isJSONSchemaElement(e) && toValue(e.$anchor) === token);
   if (isUndefined(result)) {
     throw new EvaluationJsonSchema$anchorError(`Evaluation failed on token: "${token}"`);
   }

package/src/dereference/strategies/openapi-3-1/selectors/uri.cjs

@@ -6,7 +6,7 @@ exports.__esModule = true;
 exports.evaluate = exports.JsonSchemaUriError = void 0;
 var _ramdaAdjunct = require("ramda-adjunct");
 var _apidomTraverse = require("@speclynx/apidom-traverse");
-var _apidomNsOpenapi = require("@speclynx/apidom-ns-openapi-3-1");
+var _apidomNsJsonSchema = require("@speclynx/apidom-ns-json-schema-2020-12");
 var _apidomJsonPointer = require("@speclynx/apidom-json-pointer");
 var url = _interopRequireWildcard(require("../../../../util/url.cjs"));
 var _EvaluationJsonSchemaUriError = _interopRequireDefault(require("../../../../errors/EvaluationJsonSchemaUriError.cjs"));
@@ -24,11 +24,11 @@ const evaluate = (uri, element) => {
     cache
   } = evaluate;
   const uriStrippedHash = url.stripHash(uri);
-  const isSchemaElementWith$id = e => (0, _apidomNsOpenapi.isSchemaElement)(e) && typeof e.$id !== 'undefined';
+  const isJSONSchemaElementWith$id = e => (0, _apidomNsJsonSchema.isJSONSchemaElement)(e) && typeof e.$id !== 'undefined';
 
   // warm the cache
   if (!cache.has(element)) {
-    const schemaObjectElements = (0, _apidomTraverse.filter)(element, isSchemaElementWith$id);
+    const schemaObjectElements = (0, _apidomTraverse.filter)(element, isJSONSchemaElementWith$id);
     cache.set(element, Array.from(schemaObjectElements));
   }
 

package/src/dereference/strategies/openapi-3-1/selectors/uri.mjs

@@ -1,6 +1,6 @@
 import { isUndefined } from 'ramda-adjunct';
 import { filter } from '@speclynx/apidom-traverse';
-import { isSchemaElement } from '@speclynx/apidom-ns-openapi-3-1';
+import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
 import { URIFragmentIdentifier, evaluate as jsonPointerEvaluate } from '@speclynx/apidom-json-pointer';
 import * as url from "../../../../util/url.mjs";
 import EvaluationJsonSchemaUriError from "../../../../errors/EvaluationJsonSchemaUriError.mjs";
@@ -15,11 +15,11 @@ export const evaluate = (uri, element) => {
     cache
   } = evaluate;
   const uriStrippedHash = url.stripHash(uri);
-  const isSchemaElementWith$id = e => isSchemaElement(e) && typeof e.$id !== 'undefined';
+  const isJSONSchemaElementWith$id = e => isJSONSchemaElement(e) && typeof e.$id !== 'undefined';
 
   // warm the cache
   if (!cache.has(element)) {
-    const schemaObjectElements = filter(element, isSchemaElementWith$id);
+    const schemaObjectElements = filter(element, isJSONSchemaElementWith$id);
     cache.set(element, Array.from(schemaObjectElements));
   }
 

package/src/dereference/strategies/openapi-3-1/visitor.cjs

@@ -542,7 +542,6 @@ class OpenAPI3_1DereferenceVisitor {
     const isURL = !isUnknownURI;
     let isInternalReference = url.stripHash(this.reference.uri) === $refBaseURI;
     let isExternalReference = !isInternalReference;
-    this.indirections.push(referencingElement);
 
     // determining reference, proper evaluation and selection mechanism
     let referencedElement;
@@ -591,7 +590,7 @@ class OpenAPI3_1DereferenceVisitor {
       }
     } catch (error) {
       /**
-       * No SchemaElement($id=URL) was not found, so we're going to try to resolve
+       * SchemaElement($id=URL) was not found, so we're going to try to resolve
        * the URL and assume the returned response is a JSON Schema.
        */
       if (isURL && error instanceof _EvaluationJsonSchemaUriError.default) {
@@ -643,6 +642,7 @@ class OpenAPI3_1DereferenceVisitor {
         throw error;
       }
     }
+    this.indirections.push(referencingElement);
 
     // detect direct or indirect reference
     if (referencingElement === referencedElement) {
@@ -705,7 +705,7 @@ class OpenAPI3_1DereferenceVisitor {
     this.indirections.pop();
 
     // Boolean JSON Schemas
-    if ((0, _apidomNsOpenapi.isBooleanJsonSchemaElement)(referencedElement)) {
+    if ((0, _apidomNsOpenapi.isBooleanJSONSchemaElement)(referencedElement)) {
       const booleanJsonSchemaElement = (0, _apidomDatamodel.cloneDeep)(referencedElement);
       // assign unique id to merged element
       booleanJsonSchemaElement.meta.set('id', identityManager.generateId());

package/src/dereference/strategies/openapi-3-1/visitor.mjs

@@ -5,7 +5,7 @@ import { IdentityManager, toValue, fixedFields } from '@speclynx/apidom-core';
 import { ApiDOMError } from '@speclynx/apidom-error';
 import { traverseAsync, find } from '@speclynx/apidom-traverse';
 import { evaluate as jsonPointerEvaluate, URIFragmentIdentifier } from '@speclynx/apidom-json-pointer';
-import { isReferenceLikeElement, isPathItemElement, isReferenceElement, isSchemaElement, isOperationElement, isBooleanJsonSchemaElement, refract, refractReference, refractPathItem, refractOperation } from '@speclynx/apidom-ns-openapi-3-1';
+import { isReferenceLikeElement, isPathItemElement, isReferenceElement, isSchemaElement, isOperationElement, isBooleanJSONSchemaElement, refract, refractReference, refractPathItem, refractOperation } from '@speclynx/apidom-ns-openapi-3-1';
 import { isAnchor, uriToAnchor, evaluate as $anchorEvaluate } from "./selectors/$anchor.mjs";
 import { evaluate as uriEvaluate } from "./selectors/uri.mjs";
 import MaximumDereferenceDepthError from "../../../errors/MaximumDereferenceDepthError.mjs";
@@ -536,7 +536,6 @@ class OpenAPI3_1DereferenceVisitor {
     const isURL = !isUnknownURI;
     let isInternalReference = url.stripHash(this.reference.uri) === $refBaseURI;
     let isExternalReference = !isInternalReference;
-    this.indirections.push(referencingElement);
 
     // determining reference, proper evaluation and selection mechanism
     let referencedElement;
@@ -585,7 +584,7 @@ class OpenAPI3_1DereferenceVisitor {
       }
     } catch (error) {
       /**
-       * No SchemaElement($id=URL) was not found, so we're going to try to resolve
+       * SchemaElement($id=URL) was not found, so we're going to try to resolve
        * the URL and assume the returned response is a JSON Schema.
        */
       if (isURL && error instanceof EvaluationJsonSchemaUriError) {
@@ -637,6 +636,7 @@ class OpenAPI3_1DereferenceVisitor {
         throw error;
       }
     }
+    this.indirections.push(referencingElement);
 
     // detect direct or indirect reference
     if (referencingElement === referencedElement) {
@@ -699,7 +699,7 @@ class OpenAPI3_1DereferenceVisitor {
     this.indirections.pop();
 
     // Boolean JSON Schemas
-    if (isBooleanJsonSchemaElement(referencedElement)) {
+    if (isBooleanJSONSchemaElement(referencedElement)) {
       const booleanJsonSchemaElement = cloneDeep(referencedElement);
       // assign unique id to merged element
       booleanJsonSchemaElement.meta.set('id', identityManager.generateId());

package/types/dereference/strategies/arazzo-1/index.d.ts

@@ -0,0 +1,32 @@
+import { Element } from '@speclynx/apidom-datamodel';
+import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy.ts';
+import File from '../../../File.ts';
+import Arazzo1DereferenceVisitor from './visitor.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+export type { default as DereferenceStrategy, DereferenceStrategyOptions, } from '../DereferenceStrategy.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { Arazzo1DereferenceVisitorOptions } from './visitor.ts';
+export type { ReferenceOptions as ApiDOMReferenceOptions, ReferenceBundleOptions as ApiDOMReferenceBundleOptions, ReferenceDereferenceOptions as ApiDOMReferenceDereferenceOptions, ReferenceParseOptions as ApiDOMReferenceParseOptions, ReferenceResolveOptions as ApiDOMReferenceResolveOptions, } from '../../../options/index.ts';
+export type { default as Parser, ParserOptions } from '../../../parse/parsers/Parser.ts';
+export type { default as Resolver, ResolverOptions } from '../../../resolve/resolvers/Resolver.ts';
+export type { default as ResolveStrategy, ResolveStrategyOptions, } from '../../../resolve/strategies/ResolveStrategy.ts';
+export type { default as BundleStrategy, BundleStrategyOptions, } from '../../../bundle/strategies/BundleStrategy.ts';
+export type { AncestorLineage } from '../../util.ts';
+/**
+ * @public
+ */
+export interface Arazzo1DereferenceStrategyOptions extends Omit<DereferenceStrategyOptions, 'name'> {
+}
+/**
+ * @public
+ */
+declare class Arazzo1DereferenceStrategy extends DereferenceStrategy {
+    constructor(options?: Arazzo1DereferenceStrategyOptions);
+    canDereference(file: File): boolean;
+    dereference(file: File, options: ReferenceOptions): Promise<Element>;
+}
+export { Arazzo1DereferenceVisitor };
+export { resolveSchema$refField, resolveSchema$idField, maybeRefractToJSONSchemaElement, } from './util.ts';
+export default Arazzo1DereferenceStrategy;

package/types/dereference/strategies/arazzo-1/selectors/$anchor.d.ts

@@ -0,0 +1 @@
+export { isAnchor, uriToAnchor, parse, evaluate, EvaluationJsonSchema$anchorError, InvalidJsonSchema$anchorError, JsonSchema$anchorError, } from '../../openapi-3-1/selectors/$anchor.ts';

package/types/dereference/strategies/arazzo-1/selectors/uri.d.ts

@@ -0,0 +1 @@
+export { evaluate, EvaluationJsonSchemaUriError, JsonSchemaUriError, } from '../../openapi-3-1/selectors/uri.ts';

package/types/dereference/strategies/arazzo-1/util.d.ts

@@ -0,0 +1,13 @@
+import { Element } from '@speclynx/apidom-datamodel';
+export { resolveSchema$refField, resolveSchema$idField } from '../openapi-3-1/util.ts';
+/**
+ * Cached version of JSONSchemaElement.refract.
+ */
+export declare const refractToJSONSchemaElement: {
+    <T extends Element>(element: T): any;
+    cache: WeakMap<WeakKey, any>;
+};
+/**
+ * @public
+ */
+export declare const maybeRefractToJSONSchemaElement: <T extends Element>(element: T) => any;