@speclynx/apidom-ns-openapi-3-1 4.0.2 → 4.0.3

package/src/refractor/index.ts

@@ -0,0 +1,380 @@
+import { resolveSpecification, dispatchRefractorPlugins } from '@speclynx/apidom-core';
+import { Element, refract as baseRefract } from '@speclynx/apidom-datamodel';
+import { traverse, getNodePrimitiveType } from '@speclynx/apidom-traverse';
+import { path } from 'ramda';
+
+import type { BaseFixedFieldsVisitor as VisitorClass } from './visitors/open-api-3-1/bases.ts';
+import specification from './specification.ts';
+import createToolbox, { type Toolbox } from './toolbox.ts';
+import type CallbackElement from '../elements/Callback.ts';
+import type ComponentsElement from '../elements/Components.ts';
+import type ContactElement from '../elements/Contact.ts';
+import type DiscriminatorElement from '../elements/Discriminator.ts';
+import type EncodingElement from '../elements/Encoding.ts';
+import type ExampleElement from '../elements/Example.ts';
+import type ExternalDocumentationElement from '../elements/ExternalDocumentation.ts';
+import type HeaderElement from '../elements/Header.ts';
+import type InfoElement from '../elements/Info.ts';
+import type JsonSchemaDialectElement from '../elements/JsonSchemaDialect.ts';
+import type LicenseElement from '../elements/License.ts';
+import type LinkElement from '../elements/Link.ts';
+import type MediaTypeElement from '../elements/MediaType.ts';
+import type OAuthFlowElement from '../elements/OAuthFlow.ts';
+import type OAuthFlowsElement from '../elements/OAuthFlows.ts';
+import type OpenApi3_1Element from '../elements/OpenApi3-1.ts';
+import type OperationElement from '../elements/Operation.ts';
+import type ParameterElement from '../elements/Parameter.ts';
+import type PathItemElement from '../elements/PathItem.ts';
+import type PathsElement from '../elements/Paths.ts';
+import type ReferenceElement from '../elements/Reference.ts';
+import type RequestBodyElement from '../elements/RequestBody.ts';
+import type ResponseElement from '../elements/Response.ts';
+import type ResponsesElement from '../elements/Responses.ts';
+import type SchemaElement from '../elements/Schema.ts';
+import type SecurityRequirementElement from '../elements/SecurityRequirement.ts';
+import type SecuritySchemeElement from '../elements/SecurityScheme.ts';
+import type ServerElement from '../elements/Server.ts';
+import type ServerVariableElement from '../elements/ServerVariable.ts';
+import type TagElement from '../elements/Tag.ts';
+import type XmlElement from '../elements/Xml.ts';
+
+/**
+ * @public
+ */
+export type RefractorPlugin = (toolbox: Toolbox) => {
+  visitor?: object;
+  pre?: () => void;
+  post?: () => void;
+};
+
+/**
+ * @public
+ */
+export interface RefractorOptions {
+  readonly element?: string;
+  readonly plugins?: RefractorPlugin[];
+  readonly specificationObj?: typeof specification;
+  readonly consume?: boolean;
+}
+
+/**
+ * @public
+ */
+const refract = <T extends Element>(
+  value: unknown,
+  {
+    element = 'openApi3_1',
+    plugins = [],
+    specificationObj = specification,
+    consume = false,
+  }: RefractorOptions = {},
+): T => {
+  const genericElement = baseRefract(value);
+  const resolvedSpec = resolveSpecification(specificationObj);
+  const elementMap = resolvedSpec.elementMap as Record<string, string[]>;
+  const specPath = elementMap[element];
+
+  if (!specPath) {
+    throw new Error(`Unknown element type: "${element}"`);
+  }
+
+  /**
+   * This is where generic ApiDOM becomes semantic (namespace applied).
+   * We don't allow consumers to hook into this translation.
+   * Though we allow consumers to define their own plugins on already transformed ApiDOM.
+   */
+  const RootVisitorClass = path(specPath, resolvedSpec) as new (
+    options: Record<string, unknown>,
+  ) => InstanceType<typeof VisitorClass>;
+  const rootVisitor = new RootVisitorClass({ specObj: resolvedSpec, consume });
+
+  traverse(genericElement, rootVisitor, { nodeTypeGetter: getNodePrimitiveType });
+
+  /**
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return dispatchRefractorPlugins(rootVisitor.element, plugins, {
+    toolboxCreator: createToolbox,
+  }) as T;
+};
+
+/**
+ * Refracts a value into an OpenApi3_1Element.
+ * @public
+ */
+export const refractOpenApi3_1 = <T extends Element = OpenApi3_1Element>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'openApi3_1' });
+
+/**
+ * Refracts a value into an InfoElement.
+ * @public
+ */
+export const refractInfo = <T extends Element = InfoElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'info' });
+
+/**
+ * Refracts a value into a ContactElement.
+ * @public
+ */
+export const refractContact = <T extends Element = ContactElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'contact' });
+
+/**
+ * Refracts a value into a LicenseElement.
+ * @public
+ */
+export const refractLicense = <T extends Element = LicenseElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'license' });
+
+/**
+ * Refracts a value into a ServerElement.
+ * @public
+ */
+export const refractServer = <T extends Element = ServerElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'server' });
+
+/**
+ * Refracts a value into a ServerVariableElement.
+ * @public
+ */
+export const refractServerVariable = <T extends Element = ServerVariableElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'serverVariable' });
+
+/**
+ * Refracts a value into a ComponentsElement.
+ * @public
+ */
+export const refractComponents = <T extends Element = ComponentsElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'components' });
+
+/**
+ * Refracts a value into a PathsElement.
+ * @public
+ */
+export const refractPaths = <T extends Element = PathsElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'paths' });
+
+/**
+ * Refracts a value into a PathItemElement.
+ * @public
+ */
+export const refractPathItem = <T extends Element = PathItemElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'pathItem' });
+
+/**
+ * Refracts a value into an OperationElement.
+ * @public
+ */
+export const refractOperation = <T extends Element = OperationElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'operation' });
+
+/**
+ * Refracts a value into an ExternalDocumentationElement.
+ * @public
+ */
+export const refractExternalDocumentation = <T extends Element = ExternalDocumentationElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'externalDocumentation' });
+
+/**
+ * Refracts a value into a ParameterElement.
+ * @public
+ */
+export const refractParameter = <T extends Element = ParameterElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'parameter' });
+
+/**
+ * Refracts a value into a RequestBodyElement.
+ * @public
+ */
+export const refractRequestBody = <T extends Element = RequestBodyElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'requestBody' });
+
+/**
+ * Refracts a value into a MediaTypeElement.
+ * @public
+ */
+export const refractMediaType = <T extends Element = MediaTypeElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'mediaType' });
+
+/**
+ * Refracts a value into an EncodingElement.
+ * @public
+ */
+export const refractEncoding = <T extends Element = EncodingElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'encoding' });
+
+/**
+ * Refracts a value into a ResponsesElement.
+ * @public
+ */
+export const refractResponses = <T extends Element = ResponsesElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'responses' });
+
+/**
+ * Refracts a value into a ResponseElement.
+ * @public
+ */
+export const refractResponse = <T extends Element = ResponseElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'response' });
+
+/**
+ * Refracts a value into a CallbackElement.
+ * @public
+ */
+export const refractCallback = <T extends Element = CallbackElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'callback' });
+
+/**
+ * Refracts a value into an ExampleElement.
+ * @public
+ */
+export const refractExample = <T extends Element = ExampleElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'example' });
+
+/**
+ * Refracts a value into a LinkElement.
+ * @public
+ */
+export const refractLink = <T extends Element = LinkElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'link' });
+
+/**
+ * Refracts a value into a HeaderElement.
+ * @public
+ */
+export const refractHeader = <T extends Element = HeaderElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'header' });
+
+/**
+ * Refracts a value into a TagElement.
+ * @public
+ */
+export const refractTag = <T extends Element = TagElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'tag' });
+
+/**
+ * Refracts a value into a ReferenceElement.
+ * @public
+ */
+export const refractReference = <T extends Element = ReferenceElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'reference' });
+
+/**
+ * Refracts a value into a SchemaElement.
+ * @public
+ */
+export const refractSchema = <T extends Element = SchemaElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'schema' });
+
+/**
+ * Refracts a value into a DiscriminatorElement.
+ * @public
+ */
+export const refractDiscriminator = <T extends Element = DiscriminatorElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'discriminator' });
+
+/**
+ * Refracts a value into an XmlElement.
+ * @public
+ */
+export const refractXml = <T extends Element = XmlElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'xml' });
+
+/**
+ * Refracts a value into a SecuritySchemeElement.
+ * @public
+ */
+export const refractSecurityScheme = <T extends Element = SecuritySchemeElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'securityScheme' });
+
+/**
+ * Refracts a value into an OAuthFlowsElement.
+ * @public
+ */
+export const refractOAuthFlows = <T extends Element = OAuthFlowsElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'oAuthFlows' });
+
+/**
+ * Refracts a value into an OAuthFlowElement.
+ * @public
+ */
+export const refractOAuthFlow = <T extends Element = OAuthFlowElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'oAuthFlow' });
+
+/**
+ * Refracts a value into a SecurityRequirementElement.
+ * @public
+ */
+export const refractSecurityRequirement = <T extends Element = SecurityRequirementElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'securityRequirement' });
+
+/**
+ * Refracts a value into a JsonSchemaDialectElement.
+ * @public
+ */
+export const refractJsonSchemaDialect = <T extends Element = JsonSchemaDialectElement>(
+  value: unknown,
+  options: Omit<RefractorOptions, 'element'> = {},
+): T => refract(value, { ...options, element: 'jsonSchemaDialect' });
+
+export default refract;

package/src/refractor/inspect.cjs

@@ -0,0 +1,207 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+var _apidomCore = require("@speclynx/apidom-core");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _Callback = _interopRequireDefault(require("../elements/Callback.cjs"));
+exports.CallbackElement = _Callback.default;
+var _Components = _interopRequireDefault(require("../elements/Components.cjs"));
+exports.ComponentsElement = _Components.default;
+var _Contact = _interopRequireDefault(require("../elements/Contact.cjs"));
+exports.ContactElement = _Contact.default;
+var _Discriminator = _interopRequireDefault(require("../elements/Discriminator.cjs"));
+exports.DiscriminatorElement = _Discriminator.default;
+var _Encoding = _interopRequireDefault(require("../elements/Encoding.cjs"));
+exports.EncodingElement = _Encoding.default;
+var _Example = _interopRequireDefault(require("../elements/Example.cjs"));
+exports.ExampleElement = _Example.default;
+var _ExternalDocumentation = _interopRequireDefault(require("../elements/ExternalDocumentation.cjs"));
+exports.ExternalDocumentationElement = _ExternalDocumentation.default;
+var _Header = _interopRequireDefault(require("../elements/Header.cjs"));
+exports.HeaderElement = _Header.default;
+var _Info = _interopRequireDefault(require("../elements/Info.cjs"));
+exports.InfoElement = _Info.default;
+var _JsonSchemaDialect = _interopRequireDefault(require("../elements/JsonSchemaDialect.cjs"));
+exports.JsonSchemaDialectElement = _JsonSchemaDialect.default;
+var _License = _interopRequireDefault(require("../elements/License.cjs"));
+exports.LicenseElement = _License.default;
+var _Link = _interopRequireDefault(require("../elements/Link.cjs"));
+exports.LinkElement = _Link.default;
+var _MediaType = _interopRequireDefault(require("../elements/MediaType.cjs"));
+exports.MediaTypeElement = _MediaType.default;
+var _OAuthFlow = _interopRequireDefault(require("../elements/OAuthFlow.cjs"));
+exports.OAuthFlowElement = _OAuthFlow.default;
+var _OAuthFlows = _interopRequireDefault(require("../elements/OAuthFlows.cjs"));
+exports.OAuthFlowsElement = _OAuthFlows.default;
+var _Openapi = _interopRequireDefault(require("../elements/Openapi.cjs"));
+exports.OpenapiElement = _Openapi.default;
+var _OpenApi = _interopRequireDefault(require("../elements/OpenApi3-1.cjs"));
+exports.OpenApi3_1Element = _OpenApi.default;
+var _Operation = _interopRequireDefault(require("../elements/Operation.cjs"));
+exports.OperationElement = _Operation.default;
+var _Parameter = _interopRequireDefault(require("../elements/Parameter.cjs"));
+exports.ParameterElement = _Parameter.default;
+var _PathItem = _interopRequireDefault(require("../elements/PathItem.cjs"));
+exports.PathItemElement = _PathItem.default;
+var _Paths = _interopRequireDefault(require("../elements/Paths.cjs"));
+exports.PathsElement = _Paths.default;
+var _Reference = _interopRequireDefault(require("../elements/Reference.cjs"));
+exports.ReferenceElement = _Reference.default;
+var _RequestBody = _interopRequireDefault(require("../elements/RequestBody.cjs"));
+exports.RequestBodyElement = _RequestBody.default;
+var _Response = _interopRequireDefault(require("../elements/Response.cjs"));
+exports.ResponseElement = _Response.default;
+var _Responses = _interopRequireDefault(require("../elements/Responses.cjs"));
+exports.ResponsesElement = _Responses.default;
+var _Schema = _interopRequireDefault(require("../elements/Schema.cjs"));
+exports.SchemaElement = _Schema.default;
+var _SecurityRequirement = _interopRequireDefault(require("../elements/SecurityRequirement.cjs"));
+exports.SecurityRequirementElement = _SecurityRequirement.default;
+var _SecurityScheme = _interopRequireDefault(require("../elements/SecurityScheme.cjs"));
+exports.SecuritySchemeElement = _SecurityScheme.default;
+var _Server = _interopRequireDefault(require("../elements/Server.cjs"));
+exports.ServerElement = _Server.default;
+var _ServerVariable = _interopRequireDefault(require("../elements/ServerVariable.cjs"));
+exports.ServerVariableElement = _ServerVariable.default;
+var _Tag = _interopRequireDefault(require("../elements/Tag.cjs"));
+exports.TagElement = _Tag.default;
+var _Xml = _interopRequireDefault(require("../elements/Xml.cjs"));
+exports.XmlElement = _Xml.default;
+var _specification = _interopRequireDefault(require("./specification.cjs"));
+/**
+ * OpenAPI 3.1 specification elements.
+ */
+
+/**
+ * @public
+ */
+
+// Resolve specification to dereference $ref pointers
+const resolvedSpec = (0, _apidomCore.resolveSpecification)(_specification.default);
+
+// Extract fixed fields as list of { name, alias?, $visitor }
+const getFixedFields = fixedFieldsSpec => {
+  return Object.entries(fixedFieldsSpec).map(([name, fieldSpec]) => {
+    if ((0, _ramdaAdjunct.isPlainObject)(fieldSpec)) {
+      return {
+        name,
+        ...fieldSpec
+      };
+    }
+    return {
+      name,
+      $visitor: fieldSpec
+    };
+  });
+};
+
+// OpenAPI 3.1 specification elements
+Object.defineProperty(_OpenApi.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.OpenApi.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Info.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Info.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Contact.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Contact.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_License.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.License.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Server.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Server.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_ServerVariable.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.ServerVariable.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Components.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Components.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_PathItem.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.PathItem.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Operation.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Operation.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_ExternalDocumentation.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.ExternalDocumentation.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Parameter.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Parameter.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_RequestBody.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.RequestBody.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_MediaType.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.MediaType.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Encoding.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Encoding.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Responses.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Responses.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Response.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Response.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Example.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Example.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Link.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Link.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Header.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Header.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Tag.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Tag.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Reference.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Reference.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Schema.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Schema.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Discriminator.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.Discriminator.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_Xml.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.XML.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_SecurityScheme.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.SecurityScheme.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_OAuthFlows.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.OAuthFlows.fixedFields),
+  enumerable: true
+});
+Object.defineProperty(_OAuthFlow.default, 'fixedFields', {
+  get: () => getFixedFields(resolvedSpec.visitors.document.objects.OAuthFlow.fixedFields),
+  enumerable: true
+});