@speclynx/apidom-reference 4.0.3 → 4.0.4

package/src/dereference/strategies/openapi-3-1/index.ts

@@ -1,141 +0,0 @@
-import { propEq } from 'ramda';
-import { Element, cloneDeep } from '@speclynx/apidom-datamodel';
-import { traverseAsync } from '@speclynx/apidom-traverse';
-import { isOpenApi3_1Element, mediaTypes } from '@speclynx/apidom-ns-openapi-3-1';
-
-import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy.ts';
-import File from '../../../File.ts';
-import Reference from '../../../Reference.ts';
-import ReferenceSet from '../../../ReferenceSet.ts';
-import OpenAPI3_1DereferenceVisitor 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 { OpenAPI3_1DereferenceVisitorOptions } 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 OpenAPI3_1DereferenceStrategyOptions extends Omit<
-  DereferenceStrategyOptions,
-  'name'
-> {}
-
-/**
- * @public
- */
-class OpenAPI3_1DereferenceStrategy extends DereferenceStrategy {
-  constructor(options?: OpenAPI3_1DereferenceStrategyOptions) {
-    super({ ...(options ?? {}), name: 'openapi-3-1' });
-  }
-
-  canDereference(file: File): boolean {
-    // assert by media type
-    if (file.mediaType !== 'text/plain') {
-      return mediaTypes.includes(file.mediaType);
-    }
-
-    // assert by inspecting ApiDOM
-    return isOpenApi3_1Element(file.parseResult?.result);
-  }
-
-  async dereference(file: File, options: ReferenceOptions): Promise<Element> {
-    const immutableRefSet = options.dereference.refSet ?? new ReferenceSet();
-    const mutableRefSet = new ReferenceSet();
-    let refSet = immutableRefSet;
-    let reference;
-
-    if (!immutableRefSet.has(file.uri)) {
-      reference = new Reference({ uri: file.uri, value: file.parseResult! });
-      immutableRefSet.add(reference);
-    } else {
-      // pre-computed refSet was provided as configuration option
-      reference = immutableRefSet.find(propEq(file.uri, 'uri'));
-    }
-
-    /**
-     * Clone refSet due the dereferencing process being mutable.
-     * We don't want to mutate the original refSet and the references.
-     */
-    if (options.dereference.immutable) {
-      immutableRefSet.refs
-        .map(
-          (ref) =>
-            new Reference({
-              ...ref,
-              value: cloneDeep(ref.value),
-            }),
-        )
-        .forEach((ref) => mutableRefSet.add(ref));
-      reference = mutableRefSet.find((ref) => ref.uri === file.uri);
-      refSet = mutableRefSet;
-    }
-
-    const visitor = new OpenAPI3_1DereferenceVisitor({ reference: reference!, options });
-
-    const dereferencedElement = await traverseAsync(refSet.rootRef!.value, visitor, {
-      mutable: true,
-    });
-
-    /**
-     * If immutable option is set, replay refs from the refSet.
-     */
-    if (options.dereference.immutable) {
-      mutableRefSet.refs
-        .filter((ref) => ref.uri.startsWith('immutable://'))
-        .map(
-          (ref) =>
-            new Reference({
-              ...ref,
-              uri: ref.uri.replace(/^immutable:\/\//, ''),
-            }),
-        )
-        .forEach((ref) => immutableRefSet.add(ref));
-    }
-
-    /**
-     * Release all memory if this refSet was not provided as an configuration option.
-     * If provided as configuration option, then provider is responsible for cleanup.
-     */
-    if (options.dereference.refSet === null) {
-      immutableRefSet.clean();
-    }
-
-    mutableRefSet.clean();
-
-    return dereferencedElement;
-  }
-}
-
-export { OpenAPI3_1DereferenceVisitor };
-export {
-  resolveSchema$refField,
-  resolveSchema$idField,
-  maybeRefractToSchemaElement,
-} from './util.ts';
-
-export default OpenAPI3_1DereferenceStrategy;

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

@@ -1,64 +0,0 @@
-import { trimCharsStart, isUndefined } from 'ramda-adjunct';
-import { Element } from '@speclynx/apidom-datamodel';
-import { toValue } from '@speclynx/apidom-core';
-import { find } from '@speclynx/apidom-traverse';
-import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
-
-import { getHash } from '../../../../util/url.ts';
-import EvaluationJsonSchema$anchorError from '../../../../errors/EvaluationJsonSchema$anchorError.ts';
-import InvalidJsonSchema$anchorError from '../../../../errors/InvalidJsonSchema$anchorError.ts';
-
-/**
- * @public
- */
-export const isAnchor = (uri: string) => {
-  /**
-   *  MUST start with a letter ([A-Za-z]) or underscore ("_"), followed by any number of letters,
-   *  digits ([0-9]), hyphens ("-"), underscores ("_"), and periods (".").
-   *
-   *  https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.8.2.2
-   */
-  return /^[A-Za-z_][A-Za-z_0-9.-]*$/.test(uri);
-};
-
-/**
- * @public
- */
-export const uriToAnchor = (uri: string): string => {
-  const hash = getHash(uri);
-  return trimCharsStart('#', hash);
-};
-
-/**
- * @public
- */
-export const parse = (anchor: string): string => {
-  if (!isAnchor(anchor)) {
-    throw new InvalidJsonSchema$anchorError(anchor);
-  }
-
-  return anchor;
-};
-
-/**
- * Evaluates JSON Schema $anchor against ApiDOM fragment.
- * @public
- */
-export const evaluate = <T extends Element>(anchor: string, element: T): Element | undefined => {
-  const token = parse(anchor);
-
-  const resultPath = find(
-    element,
-    // @ts-ignore
-    (path) => isJSONSchemaElement(path.node) && toValue(path.node.$anchor) === token,
-  );
-
-  if (isUndefined(resultPath)) {
-    throw new EvaluationJsonSchema$anchorError(`Evaluation failed on token: "${token}"`);
-  }
-
-  return resultPath.node;
-};
-
-export { EvaluationJsonSchema$anchorError, InvalidJsonSchema$anchorError };
-export { default as JsonSchema$anchorError } from '../../../../errors/JsonSchema$anchorError.ts';

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

@@ -1,54 +0,0 @@
-import { isUndefined } from 'ramda-adjunct';
-import { Element } from '@speclynx/apidom-datamodel';
-import { filter, type Path } from '@speclynx/apidom-traverse';
-import { isJSONSchemaElement, JSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
-import {
-  URIFragmentIdentifier,
-  evaluate as jsonPointerEvaluate,
-} from '@speclynx/apidom-json-pointer';
-
-import * as url from '../../../../util/url.ts';
-import EvaluationJsonSchemaUriError from '../../../../errors/EvaluationJsonSchemaUriError.ts';
-import { isAnchor, uriToAnchor, evaluate as $anchorEvaluate } from './$anchor.ts';
-import { resolveSchema$idField } from '../util.ts';
-
-/**
- * Evaluates JSON Schema $ref containing unknown URI against ApiDOM fragment.
- * @public
- */
-export const evaluate = <T extends Element>(uri: string, element: T): Element | undefined => {
-  const { cache } = evaluate;
-  const uriStrippedHash = url.stripHash(uri);
-  const isJSONSchemaElementWith$id = (path: Path<Element>) =>
-    isJSONSchemaElement(path.node) && typeof (path.node as any).$id !== 'undefined';
-
-  // warm the cache
-  if (!cache.has(element)) {
-    const schemaObjectPaths = filter(element, isJSONSchemaElementWith$id);
-    cache.set(
-      element,
-      schemaObjectPaths.map((path) => path.node),
-    );
-  }
-
-  // search for the matching schema
-  const result = cache.get(element).find((e: JSONSchemaElement) => {
-    const $idBaseURI = resolveSchema$idField(uriStrippedHash, e);
-    return $idBaseURI === uriStrippedHash;
-  });
-
-  if (isUndefined(result)) {
-    throw new EvaluationJsonSchemaUriError(`Evaluation failed on URI: "${uri}"`);
-  }
-
-  if (isAnchor(uriToAnchor(uri))) {
-    // we're dealing with JSON Schema $anchor here
-    return $anchorEvaluate(uriToAnchor(uri), result);
-  }
-
-  return jsonPointerEvaluate(result, URIFragmentIdentifier.fromURIReference(uri));
-};
-evaluate.cache = new WeakMap();
-
-export { EvaluationJsonSchemaUriError };
-export { default as JsonSchemaUriError } from '../../../../errors/JsonSchemaUriError.ts';

package/src/dereference/strategies/openapi-3-1/util.ts

@@ -1,83 +0,0 @@
-import { reduce } from 'ramda';
-import { Element, isPrimitiveElement } from '@speclynx/apidom-datamodel';
-import { toValue } from '@speclynx/apidom-core';
-import { JSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
-import { refractSchema } from '@speclynx/apidom-ns-openapi-3-1';
-
-import * as url from '../../../util/url.ts';
-
-/**
- * @public
- */
-export const resolveSchema$refField = (retrievalURI: string, schemaElement: JSONSchemaElement) => {
-  if (typeof schemaElement.$ref === 'undefined') {
-    return undefined;
-  }
-
-  const hash = url.getHash(toValue(schemaElement.$ref) as string);
-  const ancestorsSchemaIdentifiers = schemaElement.meta.get(
-    'ancestorsSchemaIdentifiers',
-  ) as string[];
-  const $refBaseURI = reduce(
-    (acc: string, uri: string): string => {
-      return url.resolve(acc, url.sanitize(url.stripHash(uri)));
-    },
-    retrievalURI,
-    [...ancestorsSchemaIdentifiers, toValue(schemaElement.$ref) as string],
-  );
-
-  return `${$refBaseURI}${hash === '#' ? '' : hash}`;
-};
-
-/**
- * @public
- */
-export const resolveSchema$idField = (
-  retrievalURI: string,
-  schemaElement: JSONSchemaElement,
-): string | undefined => {
-  if (typeof schemaElement.$id === 'undefined') {
-    return undefined;
-  }
-
-  const ancestorsSchemaIdentifiers = schemaElement.meta.get(
-    'ancestorsSchemaIdentifiers',
-  ) as string[];
-
-  return reduce(
-    (acc: string, $id: string): string => {
-      return url.resolve(acc, url.sanitize(url.stripHash($id)));
-    },
-    retrievalURI,
-    ancestorsSchemaIdentifiers,
-  );
-};
-
-/**
- * Cached version of SchemaElement.refract.
- */
-export const refractToSchemaElement = <T extends Element>(element: T) => {
-  if (refractToSchemaElement.cache.has(element)) {
-    return refractToSchemaElement.cache.get(element);
-  }
-
-  const refracted = refractSchema(element);
-  refractToSchemaElement.cache.set(element, refracted);
-  return refracted;
-};
-refractToSchemaElement.cache = new WeakMap();
-
-/**
- * @public
- */
-export const maybeRefractToSchemaElement = <T extends Element>(element: T) => {
-  /**
-   * Conditional version of refractToSchemaElement, that acts as an identity
-   * function for all non-primitive Element instances.
-   */
-  if (isPrimitiveElement(element)) {
-    return refractToSchemaElement(element);
-  }
-
-  return element;
-};