swagger-client 3.36.2 → 3.37.1

package/es/helpers/openapi-predicates.js

@@ -28,7 +28,17 @@ export const isOpenAPI31 = spec => {
     return false;
   }
 };
-export const isOpenAPI3 = spec => isOpenAPI30(spec) || isOpenAPI31(spec);
+export const isOpenAPI32 = spec => {
+  try {
+    const {
+      openapi
+    } = spec;
+    return typeof openapi === 'string' && /^3\.2\.(?:[1-9]\d*|0)$/.test(openapi);
+  } catch {
+    return false;
+  }
+};
+export const isOpenAPI3 = spec => isOpenAPI30(spec) || isOpenAPI31(spec) || isOpenAPI32(spec);
 
 // backward compatibility export
 export { isOpenAPI2 as isSwagger2 };

package/es/index.js

@@ -8,6 +8,7 @@ import genericResolveStrategy from './resolver/strategies/generic/index.js';
 import openApi2ResolveStrategy, { clearCache } from './resolver/strategies/openapi-2/index.js';
 import openApi30ResolveStrategy from './resolver/strategies/openapi-3-0/index.js';
 import openApi31ApiDOMResolveStrategy from './resolver/strategies/openapi-3-1-apidom/index.js';
+import openApi32ApiDOMResolveStrategy from './resolver/strategies/openapi-3-2-apidom/index.js';
 import { makeApisTagOperation } from './interfaces.js';
 import { execute, buildRequest, baseUrl } from './execute/index.js';
 import { opId, isHttpUrl } from './helpers/index.js';
@@ -17,20 +18,24 @@ import JsonParser from './resolver/apidom/reference/parse/parsers/json/index.js'
 import YamlParser from './resolver/apidom/reference/parse/parsers/yaml-1-2/index.js';
 import OpenApiJson3_1Parser from './resolver/apidom/reference/parse/parsers/openapi-json-3-1/index.js';
 import OpenApiYaml3_1Parser from './resolver/apidom/reference/parse/parsers/openapi-yaml-3-1/index.js';
+import OpenApiJson3_2Parser from './resolver/apidom/reference/parse/parsers/openapi-json-3-2/index.js';
+import OpenApiYaml3_2Parser from './resolver/apidom/reference/parse/parsers/openapi-yaml-3-2/index.js';
 import OpenApi3_1SwaggerClientDereferenceStrategy from './resolver/apidom/reference/dereference/strategies/openapi-3-1-swagger-client/index.js';
+import OpenApi3_2SwaggerClientDereferenceStrategy from './resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/index.js';
 Swagger.http = Http;
 Swagger.makeHttp = makeHttp.bind(null, Swagger.http);
 Swagger.resolveStrategies = {
+  'openapi-3-2-apidom': openApi32ApiDOMResolveStrategy,
   'openapi-3-1-apidom': openApi31ApiDOMResolveStrategy,
   'openapi-3-0': openApi30ResolveStrategy,
   'openapi-2-0': openApi2ResolveStrategy,
   generic: genericResolveStrategy
 };
 Swagger.resolve = makeResolve({
-  strategies: [Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
+  strategies: [Swagger.resolveStrategies['openapi-3-2-apidom'], Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
 });
 Swagger.resolveSubtree = makeResolveSubtree({
-  strategies: [Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
+  strategies: [Swagger.resolveStrategies['openapi-3-2-apidom'], Swagger.resolveStrategies['openapi-3-1-apidom'], Swagger.resolveStrategies['openapi-3-0'], Swagger.resolveStrategies['openapi-2-0'], Swagger.resolveStrategies.generic]
 });
 Swagger.execute = execute;
 Swagger.serializeRes = serializeRes;
@@ -53,12 +58,15 @@ Swagger.apidom = {
       JsonParser,
       YamlParser,
       OpenApiJson3_1Parser,
-      OpenApiYaml3_1Parser
+      OpenApiYaml3_1Parser,
+      OpenApiJson3_2Parser,
+      OpenApiYaml3_2Parser
     }
   },
   dereference: {
     strategies: {
-      OpenApi3_1SwaggerClientDereferenceStrategy
+      OpenApi3_1SwaggerClientDereferenceStrategy,
+      OpenApi3_2SwaggerClientDereferenceStrategy
     }
   }
 };

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/errors/SchemaRefError.js

@@ -0,0 +1,3 @@
+import { ApiDOMStructuredError } from '@swagger-api/apidom-error';
+class SchemaRefError extends ApiDOMStructuredError {}
+export default SchemaRefError;

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/index.js

@@ -0,0 +1,99 @@
+/* eslint-disable camelcase */
+import { createNamespace, visit, cloneDeep } from '@swagger-api/apidom-core';
+import { ReferenceSet, Reference } from '@swagger-api/apidom-reference/configuration/empty';
+import OpenAPI3_2DereferenceStrategy from '@swagger-api/apidom-reference/dereference/strategies/openapi-3-2';
+import openApi3_2Namespace, { getNodeType, keyMap } from '@swagger-api/apidom-ns-openapi-3-2';
+import RootVisitor from './visitors/root.js';
+const visitAsync = visit[Symbol.for('nodejs.util.promisify.custom')];
+class OpenAPI3_2SwaggerClientDereferenceStrategy extends OpenAPI3_2DereferenceStrategy {
+  allowMetaPatches;
+  parameterMacro;
+  modelPropertyMacro;
+  mode;
+  ancestors;
+  constructor({
+    allowMetaPatches = false,
+    parameterMacro = null,
+    modelPropertyMacro = null,
+    mode = 'non-strict',
+    ancestors = [],
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.name = 'openapi-3-2-swagger-client';
+    this.allowMetaPatches = allowMetaPatches;
+    this.parameterMacro = parameterMacro;
+    this.modelPropertyMacro = modelPropertyMacro;
+    this.mode = mode;
+    this.ancestors = [...ancestors];
+  }
+  async dereference(file, options) {
+    var _options$dereference$;
+    const namespace = createNamespace(openApi3_2Namespace);
+    const immutableRefSet = (_options$dereference$ = options.dereference.refSet) !== null && _options$dereference$ !== void 0 ? _options$dereference$ : new ReferenceSet();
+    const mutableRefsSet = 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(ref => ref.uri === file.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 => mutableRefsSet.add(ref));
+      reference = mutableRefsSet.find(ref => ref.uri === file.uri);
+      refSet = mutableRefsSet;
+    }
+    const rootVisitor = new RootVisitor({
+      reference,
+      namespace,
+      options,
+      allowMetaPatches: this.allowMetaPatches,
+      ancestors: this.ancestors,
+      modelPropertyMacro: this.modelPropertyMacro,
+      mode: this.mode,
+      parameterMacro: this.parameterMacro
+    });
+    const dereferencedElement = await visitAsync(refSet.rootRef.value, rootVisitor, {
+      keyMap,
+      nodeTypeGetter: getNodeType
+    });
+
+    /**
+     * If immutable option is set, replay refs from the refSet.
+     */
+    if (options.dereference.immutable) {
+      mutableRefsSet.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();
+    }
+    mutableRefsSet.clean();
+    return dereferencedElement;
+  }
+}
+export default OpenAPI3_2SwaggerClientDereferenceStrategy;
+/* eslint-enable camelcase */

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/utils/get-root-cause.js

@@ -0,0 +1,17 @@
+/**
+ * Retrieves the root cause of ApiDOM error hierarchy.
+ * ApiDOM error hierarchies are modeled similar to Java.
+ * Every error can have cause attribute which references
+ * cause of this error.
+ */
+const getRootCause = error => {
+  if (error.cause == null) return error;
+  let {
+    cause
+  } = error;
+  while (cause.cause != null) {
+    cause = cause.cause;
+  }
+  return cause;
+};
+export default getRootCause;

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/utils/to-path.js

@@ -0,0 +1,23 @@
+import { isMemberElement, isArrayElement, toValue } from '@swagger-api/apidom-core';
+const trimParseResult = elementPath => elementPath.slice(2);
+
+/**
+ * Transforms ApiDOM traversal meta information into
+ * SwaggerClient compatible path.
+ *
+ * SwaggerClient path is a list of JSON Pointer tokens.
+ */
+const toPath = elementPath => {
+  const elementPathSanitized = trimParseResult(elementPath);
+  return elementPathSanitized.reduce((path, element, index) => {
+    if (isMemberElement(element)) {
+      const token = String(toValue(element.key));
+      path.push(token);
+    } else if (isArrayElement(elementPathSanitized[index - 2])) {
+      const token = elementPathSanitized[index - 2].content.indexOf(element);
+      path.push(token);
+    }
+    return path;
+  }, []);
+};
+export default toPath;

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-2-swagger-client/visitors/all-of.js

@@ -0,0 +1,103 @@
+import { uniqWith } from 'ramda';
+import { isArrayElement, isObjectElement, deepmerge, toValue, cloneShallow, includesClasses } from '@swagger-api/apidom-core';
+import { isSchemaElement } from '@swagger-api/apidom-ns-openapi-3-2';
+import toPath from '../utils/to-path.js';
+class AllOfVisitor {
+  options;
+  SchemaElement = {
+    leave(schemaElement, key, parent, path, ancestors) {
+      // do nothing
+      if (typeof schemaElement.allOf === 'undefined') return undefined;
+
+      // collect error and return if allOf keyword is not an array
+      if (!isArrayElement(schemaElement.allOf)) {
+        var _this$options$derefer, _this$options$derefer2;
+        const error = new TypeError('allOf must be an array');
+        error.fullPath = [...toPath([...ancestors, parent, schemaElement]), 'allOf'];
+        (_this$options$derefer = this.options.dereference.dereferenceOpts) === null || _this$options$derefer === void 0 || (_this$options$derefer = _this$options$derefer.errors) === null || _this$options$derefer === void 0 || (_this$options$derefer2 = _this$options$derefer.push) === null || _this$options$derefer2 === void 0 || _this$options$derefer2.call(_this$options$derefer, error);
+        return undefined;
+      }
+
+      // remove allOf keyword if empty
+      if (schemaElement.allOf.isEmpty) {
+        schemaElement.remove('allOf');
+        return undefined;
+      }
+
+      // collect errors if allOf keyword contains anything else than Schema Object
+      const includesSchemaElementOnly = schemaElement.allOf.content.every(isSchemaElement);
+      if (!includesSchemaElementOnly) {
+        var _this$options$derefer3, _this$options$derefer4;
+        const error = new TypeError('Elements in allOf must be objects');
+        error.fullPath = [...toPath([...ancestors, parent, schemaElement]), 'allOf'];
+        (_this$options$derefer3 = this.options.dereference.dereferenceOpts) === null || _this$options$derefer3 === void 0 || (_this$options$derefer3 = _this$options$derefer3.errors) === null || _this$options$derefer3 === void 0 || (_this$options$derefer4 = _this$options$derefer3.push) === null || _this$options$derefer4 === void 0 || _this$options$derefer4.call(_this$options$derefer3, error);
+        return undefined;
+      }
+      while (schemaElement.hasKey('allOf')) {
+        const {
+          allOf
+        } = schemaElement;
+        schemaElement.remove('allOf');
+        const allOfMerged = deepmerge.all([...allOf.content, schemaElement], {
+          customMerge: keyElement => {
+            if (toValue(keyElement) === 'enum') {
+              return (targetElement, sourceElement) => {
+                if (includesClasses(['json-schema-enum'], targetElement) && includesClasses(['json-schema-enum'], sourceElement)) {
+                  const areElementsEqual = (a, b) => {
+                    if (isArrayElement(a) || isArrayElement(b) || isObjectElement(a) || isObjectElement(b)) {
+                      return false;
+                    }
+                    return a.equals(toValue(b));
+                  };
+                  const clone = cloneShallow(targetElement);
+                  clone.content = uniqWith(areElementsEqual)([...targetElement.content, ...sourceElement.content]);
+                  return clone;
+                }
+                return deepmerge(targetElement, sourceElement);
+              };
+            }
+            return deepmerge;
+          }
+        });
+
+        /**
+         * If there was not an original $$ref value, make sure to remove
+         * any $$ref value that may exist from the result of `allOf` merges.
+         */
+        if (!schemaElement.hasKey('$$ref')) {
+          allOfMerged.remove('$$ref');
+        }
+
+        /**
+         * If there was an example keyword in the original schema,
+         * keep it instead of merging with example from other schema.
+         */
+        if (schemaElement.hasKey('example')) {
+          const member = allOfMerged.getMember('example');
+          if (member) {
+            member.value = schemaElement.get('example');
+          }
+        }
+
+        /**
+         * If there was an examples keyword in the original schema,
+         * keep it instead of merging with examples from other schema.
+         */
+        if (schemaElement.hasKey('examples')) {
+          const member = allOfMerged.getMember('examples');
+          if (member) {
+            member.value = schemaElement.get('examples');
+          }
+        }
+        schemaElement.content = allOfMerged.content;
+      }
+      return undefined;
+    }
+  };
+  constructor({
+    options
+  }) {
+    this.options = options;
+  }
+}
+export default AllOfVisitor;