swagger-client 3.10.8 → 3.10.12

package/es/index.js

@@ -0,0 +1,116 @@
+import _objectSpread from "@babel/runtime-corejs2/helpers/objectSpread2";
+import assign from 'lodash/assign';
+import startsWith from 'lodash/startsWith';
+import Url from 'url';
+import Http, { makeHttp, serializeRes, serializeHeaders } from './http';
+import Resolver, { clearCache } from './resolver';
+import resolveSubtree from './subtree-resolver';
+import { makeApisTagOperation } from './interfaces';
+import { execute, buildRequest, baseUrl } from './execute';
+import { opId } from './helpers';
+Swagger.http = Http;
+Swagger.makeHttp = makeHttp.bind(null, Swagger.http);
+Swagger.resolve = Resolver;
+Swagger.resolveSubtree = resolveSubtree;
+Swagger.execute = execute;
+Swagger.serializeRes = serializeRes;
+Swagger.serializeHeaders = serializeHeaders;
+Swagger.clearCache = clearCache;
+Swagger.makeApisTagOperation = makeApisTagOperation;
+Swagger.buildRequest = buildRequest;
+Swagger.helpers = {
+  opId: opId
+};
+Swagger.getBaseUrl = baseUrl;
+
+function Swagger(url) {
+  var _this = this;
+
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  // Allow url as a separate argument
+  if (typeof url === 'string') {
+    opts.url = url;
+  } else {
+    opts = url;
+  }
+
+  if (!(this instanceof Swagger)) {
+    return new Swagger(opts);
+  }
+
+  assign(this, opts);
+  var prom = this.resolve().then(function () {
+    if (!_this.disableInterfaces) {
+      assign(_this, Swagger.makeApisTagOperation(_this));
+    }
+
+    return _this;
+  }); // Expose this instance on the promise that gets returned
+
+  prom.client = this;
+  return prom;
+}
+
+Swagger.prototype = {
+  http: Http,
+  execute: function execute(options) {
+    this.applyDefaults();
+    return Swagger.execute(_objectSpread({
+      spec: this.spec,
+      http: this.http,
+      securities: {
+        authorized: this.authorizations
+      },
+      contextUrl: typeof this.url === 'string' ? this.url : undefined,
+      requestInterceptor: this.requestInterceptor || null,
+      responseInterceptor: this.responseInterceptor || null
+    }, options));
+  },
+  resolve: function resolve() {
+    var _this2 = this;
+
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return Swagger.resolve(_objectSpread({
+      spec: this.spec,
+      url: this.url,
+      http: this.http || this.fetch,
+      allowMetaPatches: this.allowMetaPatches,
+      useCircularStructures: this.useCircularStructures,
+      requestInterceptor: this.requestInterceptor || null,
+      responseInterceptor: this.responseInterceptor || null
+    }, options)).then(function (obj) {
+      _this2.originalSpec = _this2.spec;
+      _this2.spec = obj.spec;
+      _this2.errors = obj.errors;
+      return _this2;
+    });
+  }
+};
+
+Swagger.prototype.applyDefaults = function applyDefaults() {
+  var spec = this.spec;
+  var specUrl = this.url; // TODO: OAS3: support servers here
+
+  if (specUrl && startsWith(specUrl, 'http')) {
+    var parsed = Url.parse(specUrl);
+
+    if (!spec.host) {
+      spec.host = parsed.host;
+    }
+
+    if (!spec.schemes) {
+      spec.schemes = [parsed.protocol.replace(':', '')];
+    }
+
+    if (!spec.basePath) {
+      spec.basePath = '/';
+    }
+  }
+}; // add backwards compatibility with older versions of swagger-ui
+// Refs https://github.com/swagger-api/swagger-ui/issues/6210
+
+
+var helpers = Swagger.helpers;
+export { helpers };
+export default Swagger;

package/es/interfaces.js

@@ -0,0 +1,145 @@
+import _objectSpread from "@babel/runtime-corejs2/helpers/objectSpread2";
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import pick from 'lodash/pick';
+import { eachOperation, opId } from './helpers';
+
+var nullFn = function nullFn() {
+  return null;
+};
+
+var normalizeArray = function normalizeArray(arg) {
+  return _Array$isArray(arg) ? arg : [arg];
+}; // To allow stubbing of functions
+
+
+export var self = {
+  mapTagOperations: mapTagOperations,
+  makeExecute: makeExecute
+}; // Make an execute, bound to arguments defined in mapTagOperation's callback (cb)
+
+export function makeExecute() {
+  var swaggerJs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return function (_ref) {
+    var pathName = _ref.pathName,
+        method = _ref.method,
+        operationId = _ref.operationId;
+    return function (parameters) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return swaggerJs.execute(_objectSpread(_objectSpread({
+        spec: swaggerJs.spec
+      }, pick(swaggerJs, 'requestInterceptor', 'responseInterceptor', 'userFetch')), {}, {
+        pathName: pathName,
+        method: method,
+        parameters: parameters,
+        operationId: operationId
+      }, opts));
+    };
+  };
+} // Creates an interface with tags+operations = execute
+// The shape
+// { apis: { [tag]: { operations: [operation]: { execute }}}}
+// NOTE: this is mostly for compatibility
+
+export function makeApisTagOperationsOperationExecute() {
+  var swaggerJs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // { apis: tag: operations: execute }
+  var cb = self.makeExecute(swaggerJs);
+  var tagOperations = self.mapTagOperations({
+    v2OperationIdCompatibilityMode: swaggerJs.v2OperationIdCompatibilityMode,
+    spec: swaggerJs.spec,
+    cb: cb
+  });
+  var apis = {}; // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+  for (var tag in tagOperations) {
+    apis[tag] = {
+      operations: {}
+    }; // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+    for (var op in tagOperations[tag]) {
+      apis[tag].operations[op] = {
+        execute: tagOperations[tag][op]
+      };
+    }
+  }
+
+  return {
+    apis: apis
+  };
+} // .apis[tag][operationId]:ExecuteFunction interface
+
+export function makeApisTagOperation() {
+  var swaggerJs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var cb = self.makeExecute(swaggerJs);
+  return {
+    apis: self.mapTagOperations({
+      v2OperationIdCompatibilityMode: swaggerJs.v2OperationIdCompatibilityMode,
+      spec: swaggerJs.spec,
+      cb: cb
+    })
+  };
+}
+/**
+ * Iterates over a spec, creating a hash of {[tag]: { [operationId], ... }, ...}
+ * with the value of calling `cb`.
+ *
+ * `spec` is a OAI v2.0 compliant specification object
+ * `cb` is called with ({ spec, operation, path, method })
+ * `defaultTag` will house all non-tagged operations
+ *
+ */
+
+export function mapTagOperations(_ref2) {
+  var spec = _ref2.spec,
+      _ref2$cb = _ref2.cb,
+      cb = _ref2$cb === void 0 ? nullFn : _ref2$cb,
+      _ref2$defaultTag = _ref2.defaultTag,
+      defaultTag = _ref2$defaultTag === void 0 ? 'default' : _ref2$defaultTag,
+      v2OperationIdCompatibilityMode = _ref2.v2OperationIdCompatibilityMode;
+  var operationIdCounter = {};
+  var tagOperations = {}; // Will house all tags + operations
+
+  eachOperation(spec, function (_ref3) {
+    var pathName = _ref3.pathName,
+        method = _ref3.method,
+        operation = _ref3.operation;
+    var tags = operation.tags ? normalizeArray(operation.tags) : [defaultTag];
+    tags.forEach(function (tag) {
+      if (typeof tag !== 'string') {
+        return;
+      }
+
+      tagOperations[tag] = tagOperations[tag] || {};
+      var tagObj = tagOperations[tag];
+      var id = opId(operation, pathName, method, {
+        v2OperationIdCompatibilityMode: v2OperationIdCompatibilityMode
+      });
+      var cbResult = cb({
+        spec: spec,
+        pathName: pathName,
+        method: method,
+        operation: operation,
+        operationId: id
+      });
+
+      if (operationIdCounter[id]) {
+        operationIdCounter[id] += 1;
+        tagObj["".concat(id).concat(operationIdCounter[id])] = cbResult;
+      } else if (typeof tagObj[id] !== 'undefined') {
+        // Bump counter ( for this operationId )
+        var originalCounterValue = operationIdCounter[id] || 1;
+        operationIdCounter[id] = originalCounterValue + 1; // Append _x to the operationId
+
+        tagObj["".concat(id).concat(operationIdCounter[id])] = cbResult; // Rename the first operationId
+
+        var temp = tagObj[id];
+        delete tagObj[id];
+        tagObj["".concat(id).concat(originalCounterValue)] = temp;
+      } else {
+        // Assign callback result ( usually a bound function )
+        tagObj[id] = cbResult;
+      }
+    });
+  });
+  return tagOperations;
+}

package/es/internal/form-data-monkey-patch.js

@@ -0,0 +1,94 @@
+import _classCallCheck from "@babel/runtime-corejs2/helpers/classCallCheck";
+import _createClass from "@babel/runtime-corejs2/helpers/createClass";
+import _get from "@babel/runtime-corejs2/helpers/get";
+import _getPrototypeOf from "@babel/runtime-corejs2/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime-corejs2/helpers/inherits";
+import _createSuper from "@babel/runtime-corejs2/helpers/createSuper";
+import isFunction from 'lodash/isFunction';
+import IsomorphicFormData from 'isomorphic-form-data'; // patches FormData type by mutating it.
+// patch :: FormData -> PatchedFormData
+
+export var patch = function patch(FormData) {
+  var createEntry = function createEntry(field, value) {
+    return {
+      name: field,
+      value: value
+    };
+  };
+  /** We return original type if prototype already contains one of methods we're trying to patch.
+   * Reasoning: if one of the methods already exists, it would access data in other
+   * property than our `_entryList`. That could potentially create nasty
+   * hardly detectable bugs if `form-data` library implements only couple of
+   * methods that it misses, instead of implementing all of them.
+   * Current solution will fail the tests to let us know that form-data library
+   * already implements some of the methods that we try to monkey-patch, and our
+   * monkey-patch code should then compensate the library changes easily.
+   */
+
+
+  if (isFunction(FormData.prototype.set) || isFunction(FormData.prototype.get) || isFunction(FormData.prototype.getAll) || isFunction(FormData.prototype.has)) {
+    return FormData;
+  }
+
+  var PatchedFormData = /*#__PURE__*/function (_FormData) {
+    _inherits(PatchedFormData, _FormData);
+
+    var _super = _createSuper(PatchedFormData);
+
+    function PatchedFormData(form) {
+      var _this;
+
+      _classCallCheck(this, PatchedFormData);
+
+      _this = _super.call(this, form);
+      _this.entryList = [];
+      return _this;
+    }
+
+    _createClass(PatchedFormData, [{
+      key: "append",
+      value: function append(field, value, options) {
+        this.entryList.push(createEntry(field, value));
+        return _get(_getPrototypeOf(PatchedFormData.prototype), "append", this).call(this, field, value, options);
+      }
+    }, {
+      key: "set",
+      value: function set(field, value) {
+        var newEntry = createEntry(field, value);
+        this.entryList = this.entryList.filter(function (entry) {
+          return entry.name !== field;
+        });
+        this.entryList.push(newEntry);
+      }
+    }, {
+      key: "get",
+      value: function get(field) {
+        var foundEntry = this.entryList.find(function (entry) {
+          return entry.name === field;
+        });
+        return foundEntry === undefined ? null : foundEntry;
+      }
+    }, {
+      key: "getAll",
+      value: function getAll(field) {
+        return this.entryList.filter(function (entry) {
+          return entry.name === field;
+        }).map(function (entry) {
+          return entry.value;
+        });
+      }
+    }, {
+      key: "has",
+      value: function has(field) {
+        return this.entryList.some(function (entry) {
+          return entry.name === field;
+        });
+      }
+    }]);
+
+    return PatchedFormData;
+  }(FormData);
+
+  return PatchedFormData;
+};
+export default patch(IsomorphicFormData);

package/es/resolver.js

@@ -0,0 +1,123 @@
+import _regeneratorRuntime from "@babel/runtime-corejs2/regenerator";
+import _asyncToGenerator from "@babel/runtime-corejs2/helpers/asyncToGenerator";
+import Http from './http';
+import mapSpec, { plugins } from './specmap';
+import { normalizeSwagger } from './helpers';
+import { ACCEPT_HEADER_VALUE_FOR_DOCUMENTS } from './constants';
+export function makeFetchJSON(http) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var requestInterceptor = opts.requestInterceptor,
+      responseInterceptor = opts.responseInterceptor; // Set credentials with 'http.withCredentials' value
+
+  var credentials = http.withCredentials ? 'include' : 'same-origin';
+  return function (docPath) {
+    return http({
+      url: docPath,
+      loadSpec: true,
+      requestInterceptor: requestInterceptor,
+      responseInterceptor: responseInterceptor,
+      headers: {
+        Accept: ACCEPT_HEADER_VALUE_FOR_DOCUMENTS
+      },
+      credentials: credentials
+    }).then(function (res) {
+      return res.body;
+    });
+  };
+} // Wipe out the http cache
+
+export function clearCache() {
+  plugins.refs.clearCache();
+}
+export default function resolve(obj) {
+  var fetch = obj.fetch,
+      spec = obj.spec,
+      url = obj.url,
+      mode = obj.mode,
+      _obj$allowMetaPatches = obj.allowMetaPatches,
+      allowMetaPatches = _obj$allowMetaPatches === void 0 ? true : _obj$allowMetaPatches,
+      pathDiscriminator = obj.pathDiscriminator,
+      modelPropertyMacro = obj.modelPropertyMacro,
+      parameterMacro = obj.parameterMacro,
+      requestInterceptor = obj.requestInterceptor,
+      responseInterceptor = obj.responseInterceptor,
+      skipNormalization = obj.skipNormalization,
+      useCircularStructures = obj.useCircularStructures;
+  var http = obj.http,
+      baseDoc = obj.baseDoc; // @TODO Swagger-UI uses baseDoc instead of url, this is to allow both
+  // need to fix and pick one.
+
+  baseDoc = baseDoc || url; // Provide a default fetch implementation
+  // TODO fetch should be removed, and http used instead
+
+  http = fetch || http || Http;
+
+  if (!spec) {
+    return makeFetchJSON(http, {
+      requestInterceptor: requestInterceptor,
+      responseInterceptor: responseInterceptor
+    })(baseDoc).then(doResolve);
+  }
+
+  return doResolve(spec);
+
+  function doResolve(_spec) {
+    if (baseDoc) {
+      plugins.refs.docCache[baseDoc] = _spec;
+    } // Build a json-fetcher ( ie: give it a URL and get json out )
+
+
+    plugins.refs.fetchJSON = makeFetchJSON(http, {
+      requestInterceptor: requestInterceptor,
+      responseInterceptor: responseInterceptor
+    });
+    var plugs = [plugins.refs];
+
+    if (typeof parameterMacro === 'function') {
+      plugs.push(plugins.parameters);
+    }
+
+    if (typeof modelPropertyMacro === 'function') {
+      plugs.push(plugins.properties);
+    }
+
+    if (mode !== 'strict') {
+      plugs.push(plugins.allOf);
+    } // mapSpec is where the hard work happens, see https://github.com/swagger-api/specmap for more details
+
+
+    return mapSpec({
+      spec: _spec,
+      context: {
+        baseDoc: baseDoc
+      },
+      plugins: plugs,
+      allowMetaPatches: allowMetaPatches,
+      // allows adding .meta patches, which include adding `$$ref`s to the spec
+      pathDiscriminator: pathDiscriminator,
+      // for lazy resolution
+      parameterMacro: parameterMacro,
+      modelPropertyMacro: modelPropertyMacro,
+      useCircularStructures: useCircularStructures
+    }).then(skipNormalization ? /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(a) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return", a);
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }() : normalizeSwagger);
+  }
+}

package/es/specmap/helpers.js

@@ -0,0 +1,62 @@
+import _slicedToArray from "@babel/runtime-corejs2/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime-corejs2/helpers/toConsumableArray";
+import traverse from 'traverse';
+import URL from 'url'; // This will match if the direct parent's key exactly matches an item.
+
+var freelyNamedKeyParents = ['properties']; // This will match if the grandparent's key exactly matches an item.
+// NOTE that this is for finding non-free paths!
+
+var nonFreelyNamedKeyGrandparents = ['properties']; // This will match if the joined parent path exactly matches an item.
+//
+// This is mostly useful for filtering out root-level reusable item names,
+// for example `["definitions", "$ref"]`
+
+var freelyNamedPaths = [// Swagger 2.0
+'definitions', 'parameters', 'responses', 'securityDefinitions', // OpenAPI 3.0
+'components/schemas', 'components/responses', 'components/parameters', 'components/securitySchemes']; // This will match if any of these items are substrings of the joined
+// parent path.
+//
+// Warning! These are powerful. Beware of edge cases.
+
+var freelyNamedAncestors = ['schema/example', 'items/example'];
+export function isFreelyNamed(parentPath) {
+  var parentKey = parentPath[parentPath.length - 1];
+  var grandparentKey = parentPath[parentPath.length - 2];
+  var parentStr = parentPath.join('/');
+  return (// eslint-disable-next-line max-len
+    freelyNamedKeyParents.indexOf(parentKey) > -1 && nonFreelyNamedKeyGrandparents.indexOf(grandparentKey) === -1 || freelyNamedPaths.indexOf(parentStr) > -1 || freelyNamedAncestors.some(function (el) {
+      return parentStr.indexOf(el) > -1;
+    })
+  );
+}
+export function generateAbsoluteRefPatches(obj, basePath) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      specmap = _ref.specmap,
+      _ref$getBaseUrlForNod = _ref.getBaseUrlForNodePath,
+      getBaseUrlForNodePath = _ref$getBaseUrlForNod === void 0 ? function (path) {
+    return specmap.getContext([].concat(_toConsumableArray(basePath), _toConsumableArray(path))).baseDoc;
+  } : _ref$getBaseUrlForNod,
+      _ref$targetKeys = _ref.targetKeys,
+      targetKeys = _ref$targetKeys === void 0 ? ['$ref', '$$ref'] : _ref$targetKeys;
+
+  var patches = [];
+  traverse(obj).forEach(function callback() {
+    if (targetKeys.indexOf(this.key) > -1) {
+      var nodePath = this.path; // this node's path, relative to `obj`
+
+      var fullPath = basePath.concat(this.path);
+      var absolutifiedRefValue = absolutifyPointer(this.node, getBaseUrlForNodePath(nodePath));
+      patches.push(specmap.replace(fullPath, absolutifiedRefValue));
+    }
+  });
+  return patches;
+}
+export function absolutifyPointer(pointer, baseUrl) {
+  var _pointer$split = pointer.split('#'),
+      _pointer$split2 = _slicedToArray(_pointer$split, 2),
+      urlPart = _pointer$split2[0],
+      fragmentPart = _pointer$split2[1];
+
+  var newRefUrlPart = URL.resolve(urlPart || '', baseUrl || '');
+  return fragmentPart ? "".concat(newRefUrlPart, "#").concat(fragmentPart) : newRefUrlPart;
+}