@usearazzo/runner 0.0.0-stage → 1.0.1-alpha.10

package/src/normalizer/OpenAPI30OperationNormalizer.cjs

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _resolver = require("@usearazzo/resolver");
+var _empty = require("@speclynx/apidom-reference/configuration/empty");
+var _apidomJsonPointer = require("@speclynx/apidom-json-pointer");
+var _openapi = _interopRequireDefault(require("@speclynx/apidom-reference/dereference/strategies/openapi-3-0"));
+var _apidomNsOpenapi = require("@speclynx/apidom-ns-openapi-3-0");
+var _NormalizationError = _interopRequireDefault(require("../errors/NormalizationError.cjs"));
+var _OpenAPIDocumentRegistryProvider = require("../registry/providers/OpenAPIDocumentRegistryProvider.cjs");
+/**
+ * Options for normalizing an OpenAPI 3.0 operation.
+ * @public
+ */
+
+const normalizerOptionsOverride = (0, _empty.mergeOptions)(_OpenAPIDocumentRegistryProvider.providerOptionsOverride, {
+  dereference: {
+    strategies: [new _openapi.default()]
+  }
+});
+
+/**
+ * Version-specific normalization for OpenAPI 3.0 operations.
+ *
+ * Dereferences the operation subtree and handles merging of servers,
+ * parameters, and security from path item and root levels.
+ * @public
+ */
+class OpenAPI30OperationNormalizer {
+  #options;
+  constructor(options = {}) {
+    this.#options = (0, _empty.mergeOptions)(normalizerOptionsOverride, options);
+  }
+  async normalize(operation, document) {
+    const operationPointer = (0, _apidomCore.toValue)(operation.meta.get('pointer'));
+    if (!(0, _apidomJsonPointer.testJSONPointer)(operationPointer)) {
+      throw new _NormalizationError.default(`Operation is missing valid "pointer" metadata. Was it produced by OpenAPIOperationExtractor?`, {
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri,
+        operationPointer
+      });
+    }
+    const tokens = (0, _apidomJsonPointer.parse)(operationPointer).tree;
+    const pathItemPointer = (0, _apidomJsonPointer.compile)(tokens.slice(0, -1));
+    let pathItem;
+    try {
+      pathItem = (0, _apidomJsonPointer.evaluate)(document.parseResult.api, pathItemPointer);
+    } catch (error) {
+      throw new _NormalizationError.default(`Failed to evaluate path item pointer "${pathItemPointer}" in OpenAPI 3.0 document at "${document.uri}"`, {
+        cause: error,
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+    if (!(0, _apidomNsOpenapi.isPathItemElement)(pathItem)) {
+      throw new _NormalizationError.default(`Pointer "${pathItemPointer}" does not reference a path item in OpenAPI 3.0 document at "${document.uri}"`, {
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+
+    // preparing data for normalization by lazy dereferencing
+    const entry = document.parseResult.api;
+    const operationDeref = await this.#dereferenceOperation(operation, document);
+
+    // dereferencing Path Item Parameter Object references
+    if ((0, _apidomDatamodel.isArrayElement)(pathItem.parameters)) {
+      pathItem.parameters = await this.#dereferencePathItemParameters(pathItem, document);
+    }
+
+    // normalization (mutable)
+    _apidomNsOpenapi.refractorPluginNormalizeServers.ensureDefaultServer(entry);
+    _apidomNsOpenapi.refractorPluginNormalizeServers.inheritServersToPathItem(pathItem, entry);
+    _apidomNsOpenapi.refractorPluginNormalizeServers.inheritServersToOperation(operationDeref, pathItem);
+    _apidomNsOpenapi.refractorPluginNormalizeParameters.inheritParametersToOperation(operationDeref, pathItem);
+    _apidomNsOpenapi.refractorPluginNormalizeSecurityRequirements.inheritSecurityToOperation(operationDeref, entry);
+    return operationDeref;
+  }
+  async #dereferenceOperation(operation, document) {
+    try {
+      return await (0, _resolver.dereferenceOpenAPIElement)(operation, (0, _empty.mergeOptions)(_resolver.defaultDereferenceOpenAPIOptions, (0, _empty.mergeOptions)(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new _NormalizationError.default(`Failed to dereference Operation("${(0, _apidomCore.toValue)(operation.operationId)}") in OpenAPI 3.0 document at "${document.uri}"`, {
+        cause: error,
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri
+      });
+    }
+  }
+  async #dereferencePathItemParameters(pathItem, document) {
+    try {
+      return await (0, _resolver.dereferenceOpenAPIElement)(pathItem.parameters, (0, _empty.mergeOptions)(_resolver.defaultDereferenceOpenAPIOptions, (0, _empty.mergeOptions)(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new _NormalizationError.default(`Failed to dereference Path Item parameters in OpenAPI 3.0 document at "${document.uri}"`, {
+        cause: error,
+        uri: document.uri
+      });
+    }
+  }
+}
+var _default = exports.default = OpenAPI30OperationNormalizer;

package/src/normalizer/OpenAPI30OperationNormalizer.mjs

@@ -0,0 +1,121 @@
+import { toValue } from '@speclynx/apidom-core';
+import { isArrayElement } from '@speclynx/apidom-datamodel';
+import { dereferenceOpenAPIElement, defaultDereferenceOpenAPIOptions } from '@usearazzo/resolver';
+import { mergeOptions } from '@speclynx/apidom-reference/configuration/empty';
+import { evaluate, parse, compile, testJSONPointer } from '@speclynx/apidom-json-pointer';
+import OpenAPI30DereferenceStrategy from '@speclynx/apidom-reference/dereference/strategies/openapi-3-0';
+import { isPathItemElement, refractorPluginNormalizeServers, refractorPluginNormalizeParameters, refractorPluginNormalizeSecurityRequirements } from '@speclynx/apidom-ns-openapi-3-0';
+import NormalizationError from "../errors/NormalizationError.mjs";
+import { providerOptionsOverride as openAPIProviderOptions } from "../registry/providers/OpenAPIDocumentRegistryProvider.mjs";
+/**
+ * Options for normalizing an OpenAPI 3.0 operation.
+ * @public
+ */
+const normalizerOptionsOverride = mergeOptions(openAPIProviderOptions, {
+  dereference: {
+    strategies: [new OpenAPI30DereferenceStrategy()]
+  }
+});
+
+/**
+ * Version-specific normalization for OpenAPI 3.0 operations.
+ *
+ * Dereferences the operation subtree and handles merging of servers,
+ * parameters, and security from path item and root levels.
+ * @public
+ */
+class OpenAPI30OperationNormalizer {
+  #options;
+  constructor(options = {}) {
+    this.#options = mergeOptions(normalizerOptionsOverride, options);
+  }
+  async normalize(operation, document) {
+    const operationPointer = toValue(operation.meta.get('pointer'));
+    if (!testJSONPointer(operationPointer)) {
+      throw new NormalizationError(`Operation is missing valid "pointer" metadata. Was it produced by OpenAPIOperationExtractor?`, {
+        operationId: toValue(operation.operationId),
+        uri: document.uri,
+        operationPointer
+      });
+    }
+    const tokens = parse(operationPointer).tree;
+    const pathItemPointer = compile(tokens.slice(0, -1));
+    let pathItem;
+    try {
+      pathItem = evaluate(document.parseResult.api, pathItemPointer);
+    } catch (error) {
+      throw new NormalizationError(`Failed to evaluate path item pointer "${pathItemPointer}" in OpenAPI 3.0 document at "${document.uri}"`, {
+        cause: error,
+        operationId: toValue(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+    if (!isPathItemElement(pathItem)) {
+      throw new NormalizationError(`Pointer "${pathItemPointer}" does not reference a path item in OpenAPI 3.0 document at "${document.uri}"`, {
+        operationId: toValue(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+
+    // preparing data for normalization by lazy dereferencing
+    const entry = document.parseResult.api;
+    const operationDeref = await this.#dereferenceOperation(operation, document);
+
+    // dereferencing Path Item Parameter Object references
+    if (isArrayElement(pathItem.parameters)) {
+      pathItem.parameters = await this.#dereferencePathItemParameters(pathItem, document);
+    }
+
+    // normalization (mutable)
+    refractorPluginNormalizeServers.ensureDefaultServer(entry);
+    refractorPluginNormalizeServers.inheritServersToPathItem(pathItem, entry);
+    refractorPluginNormalizeServers.inheritServersToOperation(operationDeref, pathItem);
+    refractorPluginNormalizeParameters.inheritParametersToOperation(operationDeref, pathItem);
+    refractorPluginNormalizeSecurityRequirements.inheritSecurityToOperation(operationDeref, entry);
+    return operationDeref;
+  }
+  async #dereferenceOperation(operation, document) {
+    try {
+      return await dereferenceOpenAPIElement(operation, mergeOptions(defaultDereferenceOpenAPIOptions, mergeOptions(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new NormalizationError(`Failed to dereference Operation("${toValue(operation.operationId)}") in OpenAPI 3.0 document at "${document.uri}"`, {
+        cause: error,
+        operationId: toValue(operation.operationId),
+        uri: document.uri
+      });
+    }
+  }
+  async #dereferencePathItemParameters(pathItem, document) {
+    try {
+      return await dereferenceOpenAPIElement(pathItem.parameters, mergeOptions(defaultDereferenceOpenAPIOptions, mergeOptions(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new NormalizationError(`Failed to dereference Path Item parameters in OpenAPI 3.0 document at "${document.uri}"`, {
+        cause: error,
+        uri: document.uri
+      });
+    }
+  }
+}
+export default OpenAPI30OperationNormalizer;

package/src/normalizer/OpenAPI31OperationNormalizer.cjs

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _resolver = require("@usearazzo/resolver");
+var _empty = require("@speclynx/apidom-reference/configuration/empty");
+var _apidomJsonPointer = require("@speclynx/apidom-json-pointer");
+var _openapi = _interopRequireDefault(require("@speclynx/apidom-reference/dereference/strategies/openapi-3-1"));
+var _apidomNsOpenapi = require("@speclynx/apidom-ns-openapi-3-1");
+var _NormalizationError = _interopRequireDefault(require("../errors/NormalizationError.cjs"));
+var _OpenAPIDocumentRegistryProvider = require("../registry/providers/OpenAPIDocumentRegistryProvider.cjs");
+/**
+ * Options for normalizing an OpenAPI 3.1 operation.
+ * @public
+ */
+
+const normalizerOptionsOverride = (0, _empty.mergeOptions)(_OpenAPIDocumentRegistryProvider.providerOptionsOverride, {
+  dereference: {
+    strategies: [new _openapi.default()]
+  }
+});
+
+/**
+ * Version-specific normalization for OpenAPI 3.1 operations.
+ *
+ * Dereferences the operation subtree and handles merging of servers,
+ * parameters, and security from path item and root levels.
+ * Same inheritance rules as 3.0 but with JSON Schema $id semantics
+ * for schema resolution.
+ * @public
+ */
+class OpenAPI31OperationNormalizer {
+  #options;
+  constructor(options = {}) {
+    this.#options = (0, _empty.mergeOptions)(normalizerOptionsOverride, options);
+  }
+  async normalize(operation, document) {
+    const operationPointer = (0, _apidomCore.toValue)(operation.meta.get('pointer'));
+    if (!(0, _apidomJsonPointer.testJSONPointer)(operationPointer)) {
+      throw new _NormalizationError.default(`Operation is missing valid "pointer" metadata. Was it produced by OpenAPIOperationExtractor?`, {
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri,
+        operationPointer
+      });
+    }
+    const tokens = (0, _apidomJsonPointer.parse)(operationPointer).tree;
+    const pathItemPointer = (0, _apidomJsonPointer.compile)(tokens.slice(0, -1));
+    let pathItem;
+    try {
+      pathItem = (0, _apidomJsonPointer.evaluate)(document.parseResult.api, pathItemPointer);
+    } catch (error) {
+      throw new _NormalizationError.default(`Failed to evaluate path item pointer "${pathItemPointer}" in OpenAPI 3.1 document at "${document.uri}"`, {
+        cause: error,
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+    if (!(0, _apidomNsOpenapi.isPathItemElement)(pathItem)) {
+      throw new _NormalizationError.default(`Pointer "${pathItemPointer}" does not reference a path item in OpenAPI 3.1 document at "${document.uri}"`, {
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+
+    // preparing data for normalization by lazy dereferencing
+    const entry = document.parseResult.api;
+    const operationDeref = await this.#dereferenceOperation(operation, document);
+
+    // dereferencing Path Item Parameter Object references
+    if ((0, _apidomDatamodel.isArrayElement)(pathItem.parameters)) {
+      pathItem.parameters = await this.#dereferencePathItemParameters(pathItem, document);
+    }
+
+    // normalization (mutable)
+    _apidomNsOpenapi.refractorPluginNormalizeServers.ensureDefaultServer(entry);
+    _apidomNsOpenapi.refractorPluginNormalizeServers.inheritServersToPathItem(pathItem, entry);
+    _apidomNsOpenapi.refractorPluginNormalizeServers.inheritServersToOperation(operationDeref, pathItem);
+    _apidomNsOpenapi.refractorPluginNormalizeParameters.inheritParametersToOperation(operationDeref, pathItem);
+    _apidomNsOpenapi.refractorPluginNormalizeSecurityRequirements.inheritSecurityToOperation(operationDeref, entry);
+    return operationDeref;
+  }
+  async #dereferenceOperation(operation, document) {
+    try {
+      return await (0, _resolver.dereferenceOpenAPIElement)(operation, (0, _empty.mergeOptions)(_resolver.defaultDereferenceOpenAPIOptions, (0, _empty.mergeOptions)(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new _NormalizationError.default(`Failed to dereference Operation("${(0, _apidomCore.toValue)(operation.operationId)}") in OpenAPI 3.1 document at "${document.uri}"`, {
+        cause: error,
+        operationId: (0, _apidomCore.toValue)(operation.operationId),
+        uri: document.uri
+      });
+    }
+  }
+  async #dereferencePathItemParameters(pathItem, document) {
+    try {
+      return await (0, _resolver.dereferenceOpenAPIElement)(pathItem.parameters, (0, _empty.mergeOptions)(_resolver.defaultDereferenceOpenAPIOptions, (0, _empty.mergeOptions)(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new _NormalizationError.default(`Failed to dereference Path Item parameters in OpenAPI 3.1 document at "${document.uri}"`, {
+        cause: error,
+        uri: document.uri
+      });
+    }
+  }
+}
+var _default = exports.default = OpenAPI31OperationNormalizer;

package/src/normalizer/OpenAPI31OperationNormalizer.mjs

@@ -0,0 +1,123 @@
+import { toValue } from '@speclynx/apidom-core';
+import { isArrayElement } from '@speclynx/apidom-datamodel';
+import { dereferenceOpenAPIElement, defaultDereferenceOpenAPIOptions } from '@usearazzo/resolver';
+import { mergeOptions } from '@speclynx/apidom-reference/configuration/empty';
+import { evaluate, parse, compile, testJSONPointer } from '@speclynx/apidom-json-pointer';
+import OpenAPI31DereferenceStrategy from '@speclynx/apidom-reference/dereference/strategies/openapi-3-1';
+import { isPathItemElement, refractorPluginNormalizeServers, refractorPluginNormalizeParameters, refractorPluginNormalizeSecurityRequirements } from '@speclynx/apidom-ns-openapi-3-1';
+import NormalizationError from "../errors/NormalizationError.mjs";
+import { providerOptionsOverride as openAPIProviderOptions } from "../registry/providers/OpenAPIDocumentRegistryProvider.mjs";
+/**
+ * Options for normalizing an OpenAPI 3.1 operation.
+ * @public
+ */
+const normalizerOptionsOverride = mergeOptions(openAPIProviderOptions, {
+  dereference: {
+    strategies: [new OpenAPI31DereferenceStrategy()]
+  }
+});
+
+/**
+ * Version-specific normalization for OpenAPI 3.1 operations.
+ *
+ * Dereferences the operation subtree and handles merging of servers,
+ * parameters, and security from path item and root levels.
+ * Same inheritance rules as 3.0 but with JSON Schema $id semantics
+ * for schema resolution.
+ * @public
+ */
+class OpenAPI31OperationNormalizer {
+  #options;
+  constructor(options = {}) {
+    this.#options = mergeOptions(normalizerOptionsOverride, options);
+  }
+  async normalize(operation, document) {
+    const operationPointer = toValue(operation.meta.get('pointer'));
+    if (!testJSONPointer(operationPointer)) {
+      throw new NormalizationError(`Operation is missing valid "pointer" metadata. Was it produced by OpenAPIOperationExtractor?`, {
+        operationId: toValue(operation.operationId),
+        uri: document.uri,
+        operationPointer
+      });
+    }
+    const tokens = parse(operationPointer).tree;
+    const pathItemPointer = compile(tokens.slice(0, -1));
+    let pathItem;
+    try {
+      pathItem = evaluate(document.parseResult.api, pathItemPointer);
+    } catch (error) {
+      throw new NormalizationError(`Failed to evaluate path item pointer "${pathItemPointer}" in OpenAPI 3.1 document at "${document.uri}"`, {
+        cause: error,
+        operationId: toValue(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+    if (!isPathItemElement(pathItem)) {
+      throw new NormalizationError(`Pointer "${pathItemPointer}" does not reference a path item in OpenAPI 3.1 document at "${document.uri}"`, {
+        operationId: toValue(operation.operationId),
+        uri: document.uri,
+        operationPointer,
+        pathItemPointer
+      });
+    }
+
+    // preparing data for normalization by lazy dereferencing
+    const entry = document.parseResult.api;
+    const operationDeref = await this.#dereferenceOperation(operation, document);
+
+    // dereferencing Path Item Parameter Object references
+    if (isArrayElement(pathItem.parameters)) {
+      pathItem.parameters = await this.#dereferencePathItemParameters(pathItem, document);
+    }
+
+    // normalization (mutable)
+    refractorPluginNormalizeServers.ensureDefaultServer(entry);
+    refractorPluginNormalizeServers.inheritServersToPathItem(pathItem, entry);
+    refractorPluginNormalizeServers.inheritServersToOperation(operationDeref, pathItem);
+    refractorPluginNormalizeParameters.inheritParametersToOperation(operationDeref, pathItem);
+    refractorPluginNormalizeSecurityRequirements.inheritSecurityToOperation(operationDeref, entry);
+    return operationDeref;
+  }
+  async #dereferenceOperation(operation, document) {
+    try {
+      return await dereferenceOpenAPIElement(operation, mergeOptions(defaultDereferenceOpenAPIOptions, mergeOptions(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new NormalizationError(`Failed to dereference Operation("${toValue(operation.operationId)}") in OpenAPI 3.1 document at "${document.uri}"`, {
+        cause: error,
+        operationId: toValue(operation.operationId),
+        uri: document.uri
+      });
+    }
+  }
+  async #dereferencePathItemParameters(pathItem, document) {
+    try {
+      return await dereferenceOpenAPIElement(pathItem.parameters, mergeOptions(defaultDereferenceOpenAPIOptions, mergeOptions(this.#options, {
+        resolve: {
+          baseURI: document.uri
+        },
+        dereference: {
+          strategyOpts: {
+            parseResult: document.parseResult
+          }
+        }
+      })));
+    } catch (error) {
+      throw new NormalizationError(`Failed to dereference Path Item parameters in OpenAPI 3.1 document at "${document.uri}"`, {
+        cause: error,
+        uri: document.uri
+      });
+    }
+  }
+}
+export default OpenAPI31OperationNormalizer;

package/src/normalizer/OpenAPIOperationNormalizer.cjs

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apidomNsOpenapi = require("@speclynx/apidom-ns-openapi-2");
+var _apidomNsOpenapi2 = require("@speclynx/apidom-ns-openapi-3-0");
+var _apidomNsOpenapi3 = require("@speclynx/apidom-ns-openapi-3-1");
+var _NormalizationError = _interopRequireDefault(require("../errors/NormalizationError.cjs"));
+var _OpenAPI2OperationNormalizer = _interopRequireDefault(require("./OpenAPI2OperationNormalizer.cjs"));
+var _OpenAPI30OperationNormalizer = _interopRequireDefault(require("./OpenAPI30OperationNormalizer.cjs"));
+var _OpenAPI31OperationNormalizer = _interopRequireDefault(require("./OpenAPI31OperationNormalizer.cjs"));
+/**
+ * Options for the OpenAPI operation normalizer facade.
+ * @public
+ */
+
+/**
+ * Facade for normalizing OpenAPI operations across all supported versions.
+ *
+ * Detects the OpenAPI version from the document and delegates to the
+ * appropriate version-specific normalizer (2.0, 3.0, or 3.1).
+ *
+ * Custom normalizer instances can be provided via constructor options.
+ * @public
+ */
+class OpenAPIOperationNormalizer {
+  #openapi2;
+  #openapi30;
+  #openapi31;
+  constructor(options = {}) {
+    this.#openapi2 = options.openapi2 ?? new _OpenAPI2OperationNormalizer.default();
+    this.#openapi30 = options.openapi30 ?? new _OpenAPI30OperationNormalizer.default();
+    this.#openapi31 = options.openapi31 ?? new _OpenAPI31OperationNormalizer.default();
+  }
+
+  /**
+   * Normalizes the operation by delegating to the version-specific normalizer.
+   */
+  async normalize(operation, document) {
+    const root = document.parseResult.api;
+    if ((0, _apidomNsOpenapi.isSwaggerElement)(root)) {
+      return this.#openapi2.normalize(operation, document);
+    }
+    if ((0, _apidomNsOpenapi2.isOpenApi3_0Element)(root)) {
+      return this.#openapi30.normalize(operation, document);
+    }
+    if ((0, _apidomNsOpenapi3.isOpenApi3_1Element)(root)) {
+      return this.#openapi31.normalize(operation, document);
+    }
+    throw new _NormalizationError.default(`Unsupported OpenAPI version in document at "${document.uri}"`, {
+      uri: document.uri
+    });
+  }
+}
+var _default = exports.default = OpenAPIOperationNormalizer;

package/src/normalizer/OpenAPIOperationNormalizer.mjs

@@ -0,0 +1,50 @@
+import { isSwaggerElement } from '@speclynx/apidom-ns-openapi-2';
+import { isOpenApi3_0Element } from '@speclynx/apidom-ns-openapi-3-0';
+import { isOpenApi3_1Element } from '@speclynx/apidom-ns-openapi-3-1';
+import NormalizationError from "../errors/NormalizationError.mjs";
+import OpenAPI2OperationNormalizer from "./OpenAPI2OperationNormalizer.mjs";
+import OpenAPI30OperationNormalizer from "./OpenAPI30OperationNormalizer.mjs";
+import OpenAPI31OperationNormalizer from "./OpenAPI31OperationNormalizer.mjs";
+/**
+ * Options for the OpenAPI operation normalizer facade.
+ * @public
+ */
+/**
+ * Facade for normalizing OpenAPI operations across all supported versions.
+ *
+ * Detects the OpenAPI version from the document and delegates to the
+ * appropriate version-specific normalizer (2.0, 3.0, or 3.1).
+ *
+ * Custom normalizer instances can be provided via constructor options.
+ * @public
+ */
+class OpenAPIOperationNormalizer {
+  #openapi2;
+  #openapi30;
+  #openapi31;
+  constructor(options = {}) {
+    this.#openapi2 = options.openapi2 ?? new OpenAPI2OperationNormalizer();
+    this.#openapi30 = options.openapi30 ?? new OpenAPI30OperationNormalizer();
+    this.#openapi31 = options.openapi31 ?? new OpenAPI31OperationNormalizer();
+  }
+
+  /**
+   * Normalizes the operation by delegating to the version-specific normalizer.
+   */
+  async normalize(operation, document) {
+    const root = document.parseResult.api;
+    if (isSwaggerElement(root)) {
+      return this.#openapi2.normalize(operation, document);
+    }
+    if (isOpenApi3_0Element(root)) {
+      return this.#openapi30.normalize(operation, document);
+    }
+    if (isOpenApi3_1Element(root)) {
+      return this.#openapi31.normalize(operation, document);
+    }
+    throw new NormalizationError(`Unsupported OpenAPI version in document at "${document.uri}"`, {
+      uri: document.uri
+    });
+  }
+}
+export default OpenAPIOperationNormalizer;