@speclynx/apidom-reference 4.0.2 → 4.0.3

package/src/resolve/resolvers/http-axios/index.cjs

@@ -0,0 +1,113 @@
+"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 _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _axios = _interopRequireDefault(require("axios"));
+var _HTTPResolver = _interopRequireDefault(require("../HTTPResolver.cjs"));
+var _MemoryCache = _interopRequireDefault(require("./cache/MemoryCache.cjs"));
+var _ResolverError = _interopRequireDefault(require("../../../errors/ResolverError.cjs"));
+var url = _interopRequireWildcard(require("../../../util/url.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class HTTPResolverAxios extends _HTTPResolver.default {
+  axiosConfig = {};
+  axiosInstance;
+  previousAxiosConfig;
+  cacheStore;
+  previousCache;
+  constructor(options) {
+    const {
+      axiosConfig = {},
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'http-axios'
+    });
+    this.axiosConfig = axiosConfig;
+    this.cacheStore = new _MemoryCache.default((0, _ramdaAdjunct.isPlainObject)(this.cache) ? this.cache : {});
+  }
+  getHttpClient() {
+    if (this.axiosInstance === undefined || this.previousAxiosConfig !== this.axiosConfig) {
+      const config = (0, _ramda.omit)(['interceptors'], this.axiosConfig);
+      const {
+        interceptors
+      } = this.axiosConfig;
+      this.axiosInstance = _axios.default.create({
+        timeout: this.timeout,
+        maxRedirects: this.redirects,
+        withCredentials: this.withCredentials,
+        responseType: 'arraybuffer',
+        ...config
+      });
+
+      // settings up request interceptors
+      if (Array.isArray(interceptors?.request)) {
+        interceptors.request.forEach(requestInterceptor => {
+          this.axiosInstance.interceptors.request.use(...(0, _ramdaAdjunct.ensureArray)(requestInterceptor));
+        });
+      }
+
+      // settings up response interceptors
+      if (Array.isArray(interceptors?.response)) {
+        interceptors.response.forEach(responseInterceptor => {
+          this.axiosInstance.interceptors.response.use(...(0, _ramdaAdjunct.ensureArray)(responseInterceptor));
+        });
+      }
+      this.previousAxiosConfig = this.axiosConfig;
+    }
+    return this.axiosInstance;
+  }
+
+  /**
+   * Ensures cacheStore is config-isolated for cloned resolvers.
+   * When a resolver is cloned via Object.create (in readFile), the clone inherits
+   * cacheStore from the prototype. Object.create(cacheStore) creates a view that
+   * shares the underlying store Map but allows isolated config (maxEntries, maxStaleAge)
+   * via own properties set by Object.assign.
+   */
+  getCacheStore() {
+    if (this.previousCache !== this.cache) {
+      if (!Object.hasOwn(this, 'cacheStore')) {
+        this.cacheStore = Object.create(this.cacheStore);
+      }
+      if ((0, _ramdaAdjunct.isPlainObject)(this.cache)) {
+        Object.assign(this.cacheStore, this.cache);
+      }
+      this.previousCache = this.cache;
+    }
+    return this.cacheStore;
+  }
+  async read(file) {
+    const uri = url.stripHash(file.uri);
+    const cacheStore = this.cache ? this.getCacheStore() : undefined;
+
+    // return cached content if available
+    const cached = cacheStore?.get(uri);
+    if (cached !== undefined) return cached;
+    const client = this.getHttpClient();
+    try {
+      const response = await client.get(uri);
+      cacheStore?.set(uri, response.data);
+      return response.data;
+    } catch (error) {
+      throw new _ResolverError.default(`Error downloading "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = HTTPResolverAxios;

package/src/resolve/resolvers/http-axios/index.mjs

@@ -0,0 +1,105 @@
+import { omit } from 'ramda';
+import { ensureArray, isPlainObject } from 'ramda-adjunct';
+import axios from 'axios';
+import HTTPResolver from "../HTTPResolver.mjs";
+import MemoryCache from "./cache/MemoryCache.mjs";
+import ResolverError from "../../../errors/ResolverError.mjs";
+import * as url from "../../../util/url.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class HTTPResolverAxios extends HTTPResolver {
+  axiosConfig = {};
+  axiosInstance;
+  previousAxiosConfig;
+  cacheStore;
+  previousCache;
+  constructor(options) {
+    const {
+      axiosConfig = {},
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'http-axios'
+    });
+    this.axiosConfig = axiosConfig;
+    this.cacheStore = new MemoryCache(isPlainObject(this.cache) ? this.cache : {});
+  }
+  getHttpClient() {
+    if (this.axiosInstance === undefined || this.previousAxiosConfig !== this.axiosConfig) {
+      const config = omit(['interceptors'], this.axiosConfig);
+      const {
+        interceptors
+      } = this.axiosConfig;
+      this.axiosInstance = axios.create({
+        timeout: this.timeout,
+        maxRedirects: this.redirects,
+        withCredentials: this.withCredentials,
+        responseType: 'arraybuffer',
+        ...config
+      });
+
+      // settings up request interceptors
+      if (Array.isArray(interceptors?.request)) {
+        interceptors.request.forEach(requestInterceptor => {
+          this.axiosInstance.interceptors.request.use(...ensureArray(requestInterceptor));
+        });
+      }
+
+      // settings up response interceptors
+      if (Array.isArray(interceptors?.response)) {
+        interceptors.response.forEach(responseInterceptor => {
+          this.axiosInstance.interceptors.response.use(...ensureArray(responseInterceptor));
+        });
+      }
+      this.previousAxiosConfig = this.axiosConfig;
+    }
+    return this.axiosInstance;
+  }
+
+  /**
+   * Ensures cacheStore is config-isolated for cloned resolvers.
+   * When a resolver is cloned via Object.create (in readFile), the clone inherits
+   * cacheStore from the prototype. Object.create(cacheStore) creates a view that
+   * shares the underlying store Map but allows isolated config (maxEntries, maxStaleAge)
+   * via own properties set by Object.assign.
+   */
+  getCacheStore() {
+    if (this.previousCache !== this.cache) {
+      if (!Object.hasOwn(this, 'cacheStore')) {
+        this.cacheStore = Object.create(this.cacheStore);
+      }
+      if (isPlainObject(this.cache)) {
+        Object.assign(this.cacheStore, this.cache);
+      }
+      this.previousCache = this.cache;
+    }
+    return this.cacheStore;
+  }
+  async read(file) {
+    const uri = url.stripHash(file.uri);
+    const cacheStore = this.cache ? this.getCacheStore() : undefined;
+
+    // return cached content if available
+    const cached = cacheStore?.get(uri);
+    if (cached !== undefined) return cached;
+    const client = this.getHttpClient();
+    try {
+      const response = await client.get(uri);
+      cacheStore?.set(uri, response.data);
+      return response.data;
+    } catch (error) {
+      throw new ResolverError(`Error downloading "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default HTTPResolverAxios;

package/src/resolve/resolvers/http-axios/index.ts

@@ -0,0 +1,130 @@
+import { omit } from 'ramda';
+import { ensureArray, isPlainObject } from 'ramda-adjunct';
+import axios, { Axios, AxiosInstance, CreateAxiosDefaults } from 'axios';
+
+import HTTPResolver, { HTTPResolverOptions } from '../HTTPResolver.ts';
+import MemoryCache from './cache/MemoryCache.ts';
+import File from '../../../File.ts';
+import ResolverError from '../../../errors/ResolverError.ts';
+import * as url from '../../../util/url.ts';
+
+export type {
+  default as HTTPResolver,
+  HTTPResolverOptions,
+  CacheOptions,
+} from '../HTTPResolver.ts';
+export type { default as Resolver, ResolverOptions } from '../Resolver.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+
+/**
+ * @public
+ */
+export interface HTTPResolverAxiosConfig extends CreateAxiosDefaults {
+  interceptors?: Axios['interceptors'];
+}
+
+/**
+ * @public
+ */
+export interface HTTPResolverAxiosOptions extends Omit<HTTPResolverOptions, 'name'> {
+  readonly axiosConfig?: HTTPResolverAxiosConfig;
+}
+
+/**
+ * @public
+ */
+class HTTPResolverAxios extends HTTPResolver {
+  public axiosConfig: HTTPResolverAxiosConfig = {};
+
+  protected axiosInstance!: AxiosInstance;
+
+  protected previousAxiosConfig!: HTTPResolverAxiosConfig;
+
+  protected cacheStore: MemoryCache<Buffer>;
+
+  protected previousCache!: typeof this.cache;
+
+  constructor(options?: HTTPResolverAxiosOptions) {
+    const { axiosConfig = {}, ...rest } = options ?? {};
+
+    super({ ...rest, name: 'http-axios' });
+    this.axiosConfig = axiosConfig;
+    this.cacheStore = new MemoryCache(isPlainObject(this.cache) ? this.cache : {});
+  }
+
+  getHttpClient(): AxiosInstance {
+    if (this.axiosInstance === undefined || this.previousAxiosConfig !== this.axiosConfig) {
+      const config = omit(['interceptors'], this.axiosConfig);
+      const { interceptors } = this.axiosConfig;
+
+      this.axiosInstance = axios.create({
+        timeout: this.timeout,
+        maxRedirects: this.redirects,
+        withCredentials: this.withCredentials,
+        responseType: 'arraybuffer',
+        ...config,
+      });
+
+      // settings up request interceptors
+      if (Array.isArray(interceptors?.request)) {
+        interceptors.request.forEach((requestInterceptor) => {
+          this.axiosInstance.interceptors.request.use(...ensureArray(requestInterceptor));
+        });
+      }
+
+      // settings up response interceptors
+      if (Array.isArray(interceptors?.response)) {
+        interceptors.response.forEach((responseInterceptor: any) => {
+          this.axiosInstance.interceptors.response.use(...ensureArray(responseInterceptor));
+        });
+      }
+
+      this.previousAxiosConfig = this.axiosConfig;
+    }
+
+    return this.axiosInstance;
+  }
+
+  /**
+   * Ensures cacheStore is config-isolated for cloned resolvers.
+   * When a resolver is cloned via Object.create (in readFile), the clone inherits
+   * cacheStore from the prototype. Object.create(cacheStore) creates a view that
+   * shares the underlying store Map but allows isolated config (maxEntries, maxStaleAge)
+   * via own properties set by Object.assign.
+   */
+  protected getCacheStore(): MemoryCache<Buffer> {
+    if (this.previousCache !== this.cache) {
+      if (!Object.hasOwn(this, 'cacheStore')) {
+        this.cacheStore = Object.create(this.cacheStore) as MemoryCache<Buffer>;
+      }
+      if (isPlainObject(this.cache)) {
+        Object.assign(this.cacheStore, this.cache);
+      }
+
+      this.previousCache = this.cache;
+    }
+
+    return this.cacheStore;
+  }
+
+  async read(file: File): Promise<Buffer> {
+    const uri = url.stripHash(file.uri);
+    const cacheStore = this.cache ? this.getCacheStore() : undefined;
+
+    // return cached content if available
+    const cached = cacheStore?.get(uri);
+    if (cached !== undefined) return cached;
+
+    const client: AxiosInstance = this.getHttpClient();
+
+    try {
+      const response = await client.get<Buffer>(uri);
+      cacheStore?.set(uri, response.data);
+      return response.data;
+    } catch (error: unknown) {
+      throw new ResolverError(`Error downloading "${file.uri}"`, { cause: error });
+    }
+  }
+}
+
+export default HTTPResolverAxios;

package/src/resolve/strategies/ResolveStrategy.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class ResolveStrategy {
+  name;
+  constructor({
+    name
+  }) {
+    this.name = name;
+  }
+}
+var _default = exports.default = ResolveStrategy;

package/src/resolve/strategies/ResolveStrategy.mjs

@@ -0,0 +1,16 @@
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class ResolveStrategy {
+  name;
+  constructor({
+    name
+  }) {
+    this.name = name;
+  }
+}
+export default ResolveStrategy;

package/src/resolve/strategies/ResolveStrategy.ts

@@ -0,0 +1,26 @@
+import File from '../../File.ts';
+import ReferenceSet from '../../ReferenceSet.ts';
+import type { ReferenceOptions } from '../../options/index.ts';
+
+/**
+ * @public
+ */
+export interface ResolveStrategyOptions {
+  readonly name: string;
+}
+
+/**
+ * @public
+ */
+abstract class ResolveStrategy {
+  public readonly name: string;
+
+  constructor({ name }: ResolveStrategyOptions) {
+    this.name = name;
+  }
+
+  abstract canResolve(file: File, options: ReferenceOptions): boolean;
+  abstract resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
+}
+
+export default ResolveStrategy;

package/src/resolve/strategies/apidom/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ResolveStrategy = _interopRequireDefault(require("../ResolveStrategy.cjs"));
+var _ReferenceSet = _interopRequireDefault(require("../../../ReferenceSet.cjs"));
+var _util = require("../../../options/util.cjs");
+var _UnmatchedDereferenceStrategyError = _interopRequireDefault(require("../../../errors/UnmatchedDereferenceStrategyError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class ApiDOMResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'apidom'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default(`"apidom" resolve strategy requires "apidom" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new _ReferenceSet.default();
+    const mergedOptions = (0, _util.merge)(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+var _default = exports.default = ApiDOMResolveStrategy;

package/src/resolve/strategies/apidom/index.mjs

@@ -0,0 +1,43 @@
+import ResolveStrategy from "../ResolveStrategy.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import { merge as mergeOptions } from "../../../options/util.mjs";
+import UnmatchedDereferenceStrategyError from "../../../errors/UnmatchedDereferenceStrategyError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class ApiDOMResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'apidom'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(`"apidom" resolve strategy requires "apidom" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default ApiDOMResolveStrategy;

package/src/resolve/strategies/apidom/index.ts

@@ -0,0 +1,78 @@
+import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import File from '../../../File.ts';
+import { merge as mergeOptions } from '../../../options/util.ts';
+import UnmatchedDereferenceStrategyError from '../../../errors/UnmatchedDereferenceStrategyError.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+
+export type { default as ResolveStrategy, ResolveStrategyOptions } from '../ResolveStrategy.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { default as File, FileOptions } from '../../../File.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 '../../resolvers/Resolver.ts';
+export type {
+  default as DereferenceStrategy,
+  DereferenceStrategyOptions,
+} from '../../../dereference/strategies/DereferenceStrategy.ts';
+export type {
+  default as BundleStrategy,
+  BundleStrategyOptions,
+} from '../../../bundle/strategies/BundleStrategy.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+
+/**
+ * @public
+ */
+export interface ApiDOMResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class ApiDOMResolveStrategy extends ResolveStrategy {
+  constructor(options?: ApiDOMResolveStrategyOptions) {
+    super({ ...(options ?? {}), name: 'apidom' });
+  }
+
+  canResolve(file: File, options: ReferenceOptions): boolean {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'apidom',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+
+    return dereferenceStrategy.canDereference(file, options);
+  }
+
+  async resolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'apidom',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(
+        `"apidom" resolve strategy requires "apidom" dereference strategy to be configured for file "${file.uri}"`,
+      );
+    }
+
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: { internal: false },
+      dereference: { refSet },
+    });
+
+    await dereferenceStrategy.dereference(file, mergedOptions);
+
+    return refSet;
+  }
+}
+
+export default ApiDOMResolveStrategy;

package/src/resolve/strategies/asyncapi-2/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ResolveStrategy = _interopRequireDefault(require("../ResolveStrategy.cjs"));
+var _ReferenceSet = _interopRequireDefault(require("../../../ReferenceSet.cjs"));
+var _util = require("../../../options/util.cjs");
+var _UnmatchedDereferenceStrategyError = _interopRequireDefault(require("../../../errors/UnmatchedDereferenceStrategyError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class AsyncAPI2ResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'asyncapi-2'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default(`"asyncapi-2" resolve strategy requires "asyncapi-2" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new _ReferenceSet.default();
+    const mergedOptions = (0, _util.merge)(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+var _default = exports.default = AsyncAPI2ResolveStrategy;

package/src/resolve/strategies/asyncapi-2/index.mjs

@@ -0,0 +1,43 @@
+import ResolveStrategy from "../ResolveStrategy.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import { merge as mergeOptions } from "../../../options/util.mjs";
+import UnmatchedDereferenceStrategyError from "../../../errors/UnmatchedDereferenceStrategyError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class AsyncAPI2ResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'asyncapi-2'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(`"asyncapi-2" resolve strategy requires "asyncapi-2" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default AsyncAPI2ResolveStrategy;