source: node_modules/@swagger-api/apidom-reference/cjs/resolve/strategies/asyncapi-2/visitor.cjs

"use strict";

var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
exports.__esModule = true;
exports.default = void 0;
var _stampit = _interopRequireDefault(require("stampit"));
var _ramda = require("ramda");
var _ramdaAdjunct = require("ramda-adjunct");
var _apidomCore = require("@swagger-api/apidom-core");
var _apidomError = require("@swagger-api/apidom-error");
var _apidomJsonPointer = require("@swagger-api/apidom-json-pointer");
var _apidomNsAsyncapi = require("@swagger-api/apidom-ns-asyncapi-2");
var _MaximumDereferenceDepthError = _interopRequireDefault(require("../../../errors/MaximumDereferenceDepthError.cjs"));
var _MaximumResolveDepthError = _interopRequireDefault(require("../../../errors/MaximumResolveDepthError.cjs"));
var url = _interopRequireWildcard(require("../../../util/url.cjs"));
var _index = _interopRequireDefault(require("../../../parse/index.cjs"));
var _Reference = _interopRequireDefault(require("../../../Reference.cjs"));
// @ts-ignore
const visitAsync = _apidomCore.visit[Symbol.for('nodejs.util.promisify.custom')];
const AsyncApi2ResolveVisitor = (0, _stampit.default)({
  props: {
    indirections: [],
    namespace: null,
    reference: null,
    crawledElements: null,
    crawlingMap: null,
    options: null
  },
  init({
    reference,
    namespace,
    indirections = [],
    options
  }) {
    this.indirections = indirections;
    this.namespace = namespace;
    this.reference = reference;
    this.crawledElements = [];
    this.crawlingMap = {};
    this.options = options;
  },
  methods: {
    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.default(`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((0, _ramda.propEq)(baseURI, 'uri'));
      }
      const parseResult = await (0, _index.default)(url.unsanitize(baseURI), {
        ...this.options,
        parse: {
          ...this.options.parse,
          mediaType: 'text/plain'
        }
      });

      // register new Reference with ReferenceSet
      const reference = (0, _Reference.default)({
        uri: baseURI,
        value: parseResult,
        depth: this.reference.depth + 1
      });
      refSet.add(reference);
      return reference;
    },
    ReferenceElement(referenceElement) {
      const uri = (0, _apidomCore.toValue)(referenceElement.$ref);
      const retrievalURI = this.toBaseURI(uri);

      // ignore resolving external Reference Objects
      if (!this.options.resolve.external && url.stripHash(this.reference.uri) !== retrievalURI) {
        return false;
      }
      if (!(0, _ramda.has)(retrievalURI, this.crawlingMap)) {
        this.crawlingMap[retrievalURI] = this.toReference(uri);
      }
      this.crawledElements.push(referenceElement);
      return undefined;
    },
    ChannelItemElement(channelItemElement) {
      // ignore PathItemElement without $ref field
      if (!(0, _apidomCore.isStringElement)(channelItemElement.$ref)) {
        return undefined;
      }
      const uri = (0, _apidomCore.toValue)(channelItemElement.$ref);
      const retrievalURI = this.toBaseURI(uri);

      // ignore resolving external Channel Item Objects
      if (!this.options.resolve.external && url.stripHash(this.reference.uri) !== retrievalURI) {
        return undefined;
      }
      if (!(0, _ramda.has)(retrievalURI, this.crawlingMap)) {
        this.crawlingMap[retrievalURI] = this.toReference(uri);
      }
      this.crawledElements.push(channelItemElement);
      return undefined;
    },
    async crawlReferenceElement(referenceElement) {
      // @ts-ignore
      const reference = await this.toReference((0, _apidomCore.toValue)(referenceElement.$ref));
      this.indirections.push(referenceElement);
      const jsonPointer = (0, _apidomJsonPointer.uriToPointer)((0, _apidomCore.toValue)(referenceElement.$ref));

      // possibly non-semantic fragment
      let fragment = (0, _apidomJsonPointer.evaluate)(jsonPointer, reference.value.result);

      // applying semantics to a fragment
      if ((0, _apidomCore.isPrimitiveElement)(fragment)) {
        const referencedElementType = (0, _apidomCore.toValue)(referenceElement.meta.get('referenced-element'));
        if ((0, _apidomNsAsyncapi.isReferenceLikeElement)(fragment)) {
          // handling indirect references
          fragment = _apidomNsAsyncapi.ReferenceElement.refract(fragment);
          fragment.setMetaProperty('referenced-element', referencedElementType);
        } else {
          // handling direct references
          const ElementClass = this.namespace.getElementClass(referencedElementType);
          fragment = ElementClass.refract(fragment);
        }
      }

      // detect direct or circular reference
      if (this.indirections.includes(fragment)) {
        throw new _apidomError.ApiDOMError('Recursive Reference Object detected');
      }

      // detect maximum depth of dereferencing
      if (this.indirections.length > this.options.dereference.maxDepth) {
        throw new _MaximumDereferenceDepthError.default(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
      }

      // dive deep into the fragment
      const visitor = AsyncApi2ResolveVisitor({
        reference,
        namespace: this.namespace,
        indirections: [...this.indirections],
        options: this.options
      });
      await visitAsync(fragment, visitor, {
        keyMap: _apidomNsAsyncapi.keyMap,
        nodeTypeGetter: _apidomNsAsyncapi.getNodeType
      });
      await visitor.crawl();
      this.indirections.pop();
    },
    async crawlChannelItemElement(channelItemElement) {
      const reference = await this.toReference((0, _apidomCore.toValue)(channelItemElement.$ref));
      this.indirections.push(channelItemElement);
      const jsonPointer = (0, _apidomJsonPointer.uriToPointer)((0, _apidomCore.toValue)(channelItemElement.$ref));

      // possibly non-semantic referenced element
      let referencedElement = (0, _apidomJsonPointer.evaluate)(jsonPointer, reference.value.result);

      // applying semantics to a referenced element
      if ((0, _apidomCore.isPrimitiveElement)(referencedElement)) {
        referencedElement = _apidomNsAsyncapi.ChannelItemElement.refract(referencedElement);
      }

      // detect direct or indirect reference
      if (this.indirections.includes(referencedElement)) {
        throw new _apidomError.ApiDOMError('Recursive Channel Item Object reference detected');
      }

      // detect maximum depth of dereferencing
      if (this.indirections.length > this.options.dereference.maxDepth) {
        throw new _MaximumDereferenceDepthError.default(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
      }

      // dive deep into the referenced element
      const visitor = AsyncApi2ResolveVisitor({
        reference,
        namespace: this.namespace,
        indirections: [...this.indirections],
        options: this.options
      });
      await visitAsync(referencedElement, visitor, {
        keyMap: _apidomNsAsyncapi.keyMap,
        nodeTypeGetter: _apidomNsAsyncapi.getNodeType
      });
      await visitor.crawl();
      this.indirections.pop();
    },
    async crawl() {
      /**
       * Synchronize all parallel resolutions in this place.
       * After synchronization happened we can be sure that refSet
       * contains resolved Reference objects.
       */
      await (0, _ramda.pipe)(_ramda.values, _ramdaAdjunct.allP)(this.crawlingMap);
      this.crawlingMap = null;

      /* eslint-disable no-await-in-loop */
      for (const element of this.crawledElements) {
        if ((0, _apidomNsAsyncapi.isReferenceElement)(element)) {
          await this.crawlReferenceElement(element);
        } else if ((0, _apidomNsAsyncapi.isChannelItemElement)(element)) {
          await this.crawlChannelItemElement(element);
        }
      }
      /* eslint-enabled */
    }
  }
});
var _default = exports.default = AsyncApi2ResolveVisitor;