swagger-client 3.10.8 → 3.10.12

package/es/commonjs.js

@@ -0,0 +1,9 @@
+'use strict'; // eslint-disable-line
+
+var _require = require('./index'),
+    SwaggerClient = _require.default; // add backwards compatibility with older versions of swagger-ui
+// by exporting one single symbol.
+// Refs https://github.com/swagger-api/swagger-ui/issues/6210
+
+
+module.exports = SwaggerClient;

package/es/constants.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export var ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = 'application/json, application/yaml';

package/es/execute/index.js

@@ -0,0 +1,391 @@
+import _slicedToArray from "@babel/runtime-corejs2/helpers/slicedToArray";
+import _JSON$stringify from "@babel/runtime-corejs2/core-js/json/stringify";
+import _objectSpread from "@babel/runtime-corejs2/helpers/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime-corejs2/helpers/objectWithoutProperties";
+import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
+import _Object$assign from "@babel/runtime-corejs2/core-js/object/assign";
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import getIn from 'lodash/get';
+import isPlainObject from 'lodash/isPlainObject';
+import isArray from 'lodash/isArray';
+import url from 'url';
+import cookie from 'cookie';
+import stockHttp, { mergeInQueryOrForm } from '../http';
+import createError from '../specmap/lib/create-error';
+import SWAGGER2_PARAMETER_BUILDERS from './swagger2/parameter-builders';
+import * as OAS3_PARAMETER_BUILDERS from './oas3/parameter-builders';
+import oas3BuildRequest from './oas3/build-request';
+import swagger2BuildRequest from './swagger2/build-request';
+import { getOperationRaw, legacyIdFromPathMethod, isOAS3 } from '../helpers';
+
+var arrayOrEmpty = function arrayOrEmpty(ar) {
+  return _Array$isArray(ar) ? ar : [];
+};
+
+var OperationNotFoundError = createError('OperationNotFoundError', function cb(message, extra, oriError) {
+  this.originalError = oriError;
+
+  _Object$assign(this, extra || {});
+});
+
+var findParametersWithName = function findParametersWithName(name, parameters) {
+  return parameters.filter(function (p) {
+    return p.name === name;
+  });
+}; // removes parameters that have duplicate 'in' and 'name' properties
+
+
+var deduplicateParameters = function deduplicateParameters(parameters) {
+  var paramsMap = {};
+  parameters.forEach(function (p) {
+    if (!paramsMap[p.in]) {
+      paramsMap[p.in] = {};
+    }
+
+    paramsMap[p.in][p.name] = p;
+  });
+  var dedupedParameters = [];
+
+  _Object$keys(paramsMap).forEach(function (i) {
+    _Object$keys(paramsMap[i]).forEach(function (p) {
+      dedupedParameters.push(paramsMap[i][p]);
+    });
+  });
+
+  return dedupedParameters;
+}; // For stubbing in tests
+
+
+export var self = {
+  buildRequest: buildRequest
+}; // Execute request, with the given operationId and parameters
+// pathName/method or operationId is optional
+
+export function execute(_ref) {
+  var userHttp = _ref.http,
+      fetch = _ref.fetch,
+      spec = _ref.spec,
+      operationId = _ref.operationId,
+      pathName = _ref.pathName,
+      method = _ref.method,
+      parameters = _ref.parameters,
+      securities = _ref.securities,
+      extras = _objectWithoutProperties(_ref, ["http", "fetch", "spec", "operationId", "pathName", "method", "parameters", "securities"]);
+
+  // Provide default fetch implementation
+  var http = userHttp || fetch || stockHttp; // Default to _our_ http
+
+  if (pathName && method && !operationId) {
+    operationId = legacyIdFromPathMethod(pathName, method);
+  }
+
+  var request = self.buildRequest(_objectSpread({
+    spec: spec,
+    operationId: operationId,
+    parameters: parameters,
+    securities: securities,
+    http: http
+  }, extras));
+
+  if (request.body && (isPlainObject(request.body) || isArray(request.body))) {
+    request.body = _JSON$stringify(request.body);
+  } // Build request and execute it
+
+
+  return http(request);
+} // Build a request, which can be handled by the `http.js` implementation.
+
+export function buildRequest(options) {
+  var spec = options.spec,
+      operationId = options.operationId,
+      responseContentType = options.responseContentType,
+      scheme = options.scheme,
+      requestInterceptor = options.requestInterceptor,
+      responseInterceptor = options.responseInterceptor,
+      contextUrl = options.contextUrl,
+      userFetch = options.userFetch,
+      server = options.server,
+      serverVariables = options.serverVariables,
+      http = options.http;
+  var parameters = options.parameters,
+      parameterBuilders = options.parameterBuilders;
+  var specIsOAS3 = isOAS3(spec);
+
+  if (!parameterBuilders) {
+    // user did not provide custom parameter builders
+    if (specIsOAS3) {
+      parameterBuilders = OAS3_PARAMETER_BUILDERS;
+    } else {
+      parameterBuilders = SWAGGER2_PARAMETER_BUILDERS;
+    }
+  } // Set credentials with 'http.withCredentials' value
+
+
+  var credentials = http && http.withCredentials ? 'include' : 'same-origin'; // Base Template
+
+  var req = {
+    url: '',
+    credentials: credentials,
+    headers: {},
+    cookies: {}
+  };
+
+  if (requestInterceptor) {
+    req.requestInterceptor = requestInterceptor;
+  }
+
+  if (responseInterceptor) {
+    req.responseInterceptor = responseInterceptor;
+  }
+
+  if (userFetch) {
+    req.userFetch = userFetch;
+  }
+
+  var operationRaw = getOperationRaw(spec, operationId);
+
+  if (!operationRaw) {
+    throw new OperationNotFoundError("Operation ".concat(operationId, " not found"));
+  }
+
+  var _operationRaw$operati = operationRaw.operation,
+      operation = _operationRaw$operati === void 0 ? {} : _operationRaw$operati,
+      method = operationRaw.method,
+      pathName = operationRaw.pathName;
+  req.url += baseUrl({
+    spec: spec,
+    scheme: scheme,
+    contextUrl: contextUrl,
+    server: server,
+    serverVariables: serverVariables,
+    pathName: pathName,
+    method: method
+  }); // Mostly for testing
+
+  if (!operationId) {
+    // Not removing req.cookies causes testing issues and would
+    // change our interface, so we're always sure to remove it.
+    // See the same statement lower down in this function for
+    // more context.
+    delete req.cookies;
+    return req;
+  }
+
+  req.url += pathName; // Have not yet replaced the path parameters
+
+  req.method = "".concat(method).toUpperCase();
+  parameters = parameters || {};
+  var path = spec.paths[pathName] || {};
+
+  if (responseContentType) {
+    req.headers.accept = responseContentType;
+  }
+
+  var combinedParameters = deduplicateParameters([].concat(arrayOrEmpty(operation.parameters)) // operation parameters
+  .concat(arrayOrEmpty(path.parameters))); // path parameters
+  // REVIEW: OAS3: have any key names or parameter shapes changed?
+  // Any new features that need to be plugged in here?
+  // Add values to request
+
+  combinedParameters.forEach(function (parameter) {
+    var builder = parameterBuilders[parameter.in];
+    var value;
+
+    if (parameter.in === 'body' && parameter.schema && parameter.schema.properties) {
+      value = parameters;
+    }
+
+    value = parameter && parameter.name && parameters[parameter.name];
+
+    if (typeof value === 'undefined') {
+      // check for `name-in` formatted key
+      value = parameter && parameter.name && parameters["".concat(parameter.in, ".").concat(parameter.name)];
+    } else if (findParametersWithName(parameter.name, combinedParameters).length > 1) {
+      // value came from `parameters[parameter.name]`
+      // check to see if this is an ambiguous parameter
+      // eslint-disable-next-line no-console
+      console.warn("Parameter '".concat(parameter.name, "' is ambiguous because the defined spec has more than one parameter with the name: '").concat(parameter.name, "' and the passed-in parameter values did not define an 'in' value."));
+    }
+
+    if (value === null) {
+      return;
+    }
+
+    if (typeof parameter.default !== 'undefined' && typeof value === 'undefined') {
+      value = parameter.default;
+    }
+
+    if (typeof value === 'undefined' && parameter.required && !parameter.allowEmptyValue) {
+      throw new Error("Required parameter ".concat(parameter.name, " is not provided"));
+    }
+
+    if (specIsOAS3 && parameter.schema && parameter.schema.type === 'object' && typeof value === 'string') {
+      try {
+        value = JSON.parse(value);
+      } catch (e) {
+        throw new Error('Could not parse object parameter value string as JSON');
+      }
+    }
+
+    if (builder) {
+      builder({
+        req: req,
+        parameter: parameter,
+        value: value,
+        operation: operation,
+        spec: spec
+      });
+    }
+  }); // Do version-specific tasks, then return those results.
+
+  var versionSpecificOptions = _objectSpread(_objectSpread({}, options), {}, {
+    operation: operation
+  });
+
+  if (specIsOAS3) {
+    req = oas3BuildRequest(versionSpecificOptions, req);
+  } else {
+    // If not OAS3, then treat as Swagger2.
+    req = swagger2BuildRequest(versionSpecificOptions, req);
+  } // If the cookie convenience object exists in our request,
+  // serialize its content and then delete the cookie object.
+
+
+  if (req.cookies && _Object$keys(req.cookies).length) {
+    var cookieString = _Object$keys(req.cookies).reduce(function (prev, cookieName) {
+      var cookieValue = req.cookies[cookieName];
+      var prefix = prev ? '&' : '';
+      var stringified = cookie.serialize(cookieName, cookieValue);
+      return prev + prefix + stringified;
+    }, '');
+
+    req.headers.Cookie = cookieString;
+  }
+
+  if (req.cookies) {
+    // even if no cookies were defined, we need to remove
+    // the cookies key from our request, or many many legacy
+    // tests will break.
+    delete req.cookies;
+  } // Will add the query object into the URL, if it exists
+  // ... will also create a FormData instance, if multipart/form-data (eg: a file)
+
+
+  mergeInQueryOrForm(req);
+  return req;
+}
+
+var stripNonAlpha = function stripNonAlpha(str) {
+  return str ? str.replace(/\W/g, '') : null;
+}; // be careful when modifying this! it is a publicly-exposed method.
+
+
+export function baseUrl(obj) {
+  var specIsOAS3 = isOAS3(obj.spec);
+  return specIsOAS3 ? oas3BaseUrl(obj) : swagger2BaseUrl(obj);
+}
+
+function oas3BaseUrl(_ref2) {
+  var spec = _ref2.spec,
+      pathName = _ref2.pathName,
+      method = _ref2.method,
+      server = _ref2.server,
+      contextUrl = _ref2.contextUrl,
+      _ref2$serverVariables = _ref2.serverVariables,
+      serverVariables = _ref2$serverVariables === void 0 ? {} : _ref2$serverVariables;
+  var servers = getIn(spec, ['paths', pathName, (method || '').toLowerCase(), 'servers']) || getIn(spec, ['paths', pathName, 'servers']) || getIn(spec, ['servers']);
+  var selectedServerUrl = '';
+  var selectedServerObj = null;
+
+  if (server && servers && servers.length) {
+    var serverUrls = servers.map(function (srv) {
+      return srv.url;
+    });
+
+    if (serverUrls.indexOf(server) > -1) {
+      selectedServerUrl = server;
+      selectedServerObj = servers[serverUrls.indexOf(server)];
+    }
+  }
+
+  if (!selectedServerUrl && servers && servers.length) {
+    // default to the first server if we don't have one by now
+    selectedServerUrl = servers[0].url; // eslint-disable-line semi
+
+    var _servers = _slicedToArray(servers, 1);
+
+    selectedServerObj = _servers[0];
+  }
+
+  if (selectedServerUrl.indexOf('{') > -1) {
+    // do variable substitution
+    var varNames = getVariableTemplateNames(selectedServerUrl);
+    varNames.forEach(function (vari) {
+      if (selectedServerObj.variables && selectedServerObj.variables[vari]) {
+        // variable is defined in server
+        var variableDefinition = selectedServerObj.variables[vari];
+        var variableValue = serverVariables[vari] || variableDefinition.default;
+        var re = new RegExp("{".concat(vari, "}"), 'g');
+        selectedServerUrl = selectedServerUrl.replace(re, variableValue);
+      }
+    });
+  }
+
+  return buildOas3UrlWithContext(selectedServerUrl, contextUrl);
+}
+
+function buildOas3UrlWithContext() {
+  var ourUrl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var contextUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var parsedUrl = url.parse(ourUrl);
+  var parsedContextUrl = url.parse(contextUrl);
+  var computedScheme = stripNonAlpha(parsedUrl.protocol) || stripNonAlpha(parsedContextUrl.protocol) || '';
+  var computedHost = parsedUrl.host || parsedContextUrl.host;
+  var computedPath = parsedUrl.pathname || '';
+  var res;
+
+  if (computedScheme && computedHost) {
+    res = "".concat(computedScheme, "://").concat(computedHost + computedPath); // If last character is '/', trim it off
+  } else {
+    res = computedPath;
+  }
+
+  return res[res.length - 1] === '/' ? res.slice(0, -1) : res;
+}
+
+function getVariableTemplateNames(str) {
+  var results = [];
+  var re = /{([^}]+)}/g;
+  var text; // eslint-disable-next-line no-cond-assign
+
+  while (text = re.exec(str)) {
+    results.push(text[1]);
+  }
+
+  return results;
+} // Compose the baseUrl ( scheme + host + basePath )
+
+
+function swagger2BaseUrl(_ref3) {
+  var spec = _ref3.spec,
+      scheme = _ref3.scheme,
+      _ref3$contextUrl = _ref3.contextUrl,
+      contextUrl = _ref3$contextUrl === void 0 ? '' : _ref3$contextUrl;
+  var parsedContextUrl = url.parse(contextUrl);
+  var firstSchemeInSpec = _Array$isArray(spec.schemes) ? spec.schemes[0] : null;
+  var computedScheme = scheme || firstSchemeInSpec || stripNonAlpha(parsedContextUrl.protocol) || 'http';
+  var computedHost = spec.host || parsedContextUrl.host || '';
+  var computedPath = spec.basePath || '';
+  var res;
+
+  if (computedScheme && computedHost) {
+    // we have what we need for an absolute URL
+    res = "".concat(computedScheme, "://").concat(computedHost + computedPath);
+  } else {
+    // if not, a relative URL will have to do
+    res = computedPath;
+  } // If last character is '/', trim it off
+
+
+  return res[res.length - 1] === '/' ? res.slice(0, -1) : res;
+}

package/es/execute/oas3/build-request.js

@@ -0,0 +1,149 @@
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import _typeof from "@babel/runtime-corejs2/helpers/typeof";
+import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
+// This function runs after the common function,
+// `src/execute/index.js#buildRequest`
+import assign from 'lodash/assign';
+import get from 'lodash/get';
+import btoa from 'btoa';
+export default function buildRequest(options, req) {
+  var operation = options.operation,
+      requestBody = options.requestBody,
+      securities = options.securities,
+      spec = options.spec,
+      attachContentTypeForEmptyPayload = options.attachContentTypeForEmptyPayload;
+  var requestContentType = options.requestContentType;
+  req = applySecurities({
+    request: req,
+    securities: securities,
+    operation: operation,
+    spec: spec
+  });
+  var requestBodyDef = operation.requestBody || {};
+
+  var requestBodyMediaTypes = _Object$keys(requestBodyDef.content || {});
+
+  var isExplicitContentTypeValid = requestContentType && requestBodyMediaTypes.indexOf(requestContentType) > -1; // for OAS3: set the Content-Type
+
+  if (requestBody || attachContentTypeForEmptyPayload) {
+    // does the passed requestContentType appear in the requestBody definition?
+    if (requestContentType && isExplicitContentTypeValid) {
+      req.headers['Content-Type'] = requestContentType;
+    } else if (!requestContentType) {
+      var firstMediaType = requestBodyMediaTypes[0];
+
+      if (firstMediaType) {
+        req.headers['Content-Type'] = firstMediaType;
+        requestContentType = firstMediaType;
+      }
+    }
+  } else if (requestContentType && isExplicitContentTypeValid) {
+    req.headers['Content-Type'] = requestContentType;
+  } // for OAS3: add requestBody to request
+
+
+  if (requestBody) {
+    if (requestContentType) {
+      if (requestBodyMediaTypes.indexOf(requestContentType) > -1) {
+        // only attach body if the requestBody has a definition for the
+        // contentType that has been explicitly set
+        if (requestContentType === 'application/x-www-form-urlencoded' || requestContentType === 'multipart/form-data') {
+          if (_typeof(requestBody) === 'object') {
+            var encoding = (requestBodyDef.content[requestContentType] || {}).encoding || {};
+            req.form = {};
+
+            _Object$keys(requestBody).forEach(function (k) {
+              req.form[k] = {
+                value: requestBody[k],
+                encoding: encoding[k] || {}
+              };
+            });
+          } else {
+            req.form = requestBody;
+          }
+        } else {
+          req.body = requestBody;
+        }
+      }
+    } else {
+      req.body = requestBody;
+    }
+  }
+
+  return req;
+} // Add security values, to operations - that declare their need on them
+// Adapted from the Swagger2 implementation
+
+export function applySecurities(_ref) {
+  var request = _ref.request,
+      _ref$securities = _ref.securities,
+      securities = _ref$securities === void 0 ? {} : _ref$securities,
+      _ref$operation = _ref.operation,
+      operation = _ref$operation === void 0 ? {} : _ref$operation,
+      spec = _ref.spec;
+  var result = assign({}, request);
+  var _securities$authorize = securities.authorized,
+      authorized = _securities$authorize === void 0 ? {} : _securities$authorize;
+  var security = operation.security || spec.security || [];
+  var isAuthorized = authorized && !!_Object$keys(authorized).length;
+  var securityDef = get(spec, ['components', 'securitySchemes']) || {};
+  result.headers = result.headers || {};
+  result.query = result.query || {};
+
+  if (!_Object$keys(securities).length || !isAuthorized || !security || _Array$isArray(operation.security) && !operation.security.length) {
+    return request;
+  }
+
+  security.forEach(function (securityObj) {
+    _Object$keys(securityObj).forEach(function (key) {
+      var auth = authorized[key];
+      var schema = securityDef[key];
+
+      if (!auth) {
+        return;
+      }
+
+      var value = auth.value || auth;
+      var type = schema.type;
+
+      if (auth) {
+        if (type === 'apiKey') {
+          if (schema.in === 'query') {
+            result.query[schema.name] = value;
+          }
+
+          if (schema.in === 'header') {
+            result.headers[schema.name] = value;
+          }
+
+          if (schema.in === 'cookie') {
+            result.cookies[schema.name] = value;
+          }
+        } else if (type === 'http') {
+          if (/^basic$/i.test(schema.scheme)) {
+            var username = value.username || '';
+            var password = value.password || '';
+            var encoded = btoa("".concat(username, ":").concat(password));
+            result.headers.Authorization = "Basic ".concat(encoded);
+          }
+
+          if (/^bearer$/i.test(schema.scheme)) {
+            result.headers.Authorization = "Bearer ".concat(value);
+          }
+        } else if (type === 'oauth2') {
+          var token = auth.token || {};
+          var tokenName = schema['x-tokenName'] || 'access_token';
+          var tokenValue = token[tokenName];
+          var tokenType = token.token_type;
+
+          if (!tokenType || tokenType.toLowerCase() === 'bearer') {
+            tokenType = 'Bearer';
+          }
+
+          result.headers.Authorization = "".concat(tokenType, " ").concat(tokenValue);
+        }
+      }
+    });
+  });
+  return result;
+}

package/es/execute/oas3/content-serializer.js

@@ -0,0 +1,18 @@
+import _JSON$stringify from "@babel/runtime-corejs2/core-js/json/stringify";
+
+/*
+  Serializer that serializes according to a media type instead of OpenAPI's
+  `style` + `explode` constructs.
+*/
+export default function serialize(value, mediaType) {
+  if (mediaType.includes('application/json')) {
+    if (typeof value === 'string') {
+      // Assume the user has a JSON string
+      return value;
+    }
+
+    return _JSON$stringify(value);
+  }
+
+  return value.toString();
+}

package/es/execute/oas3/parameter-builders.js

@@ -0,0 +1,119 @@
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import _typeof from "@babel/runtime-corejs2/helpers/typeof";
+import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
+import pick from 'lodash/pick';
+import stylize, { encodeDisallowedCharacters } from './style-serializer';
+import serialize from './content-serializer';
+export function path(_ref) {
+  var req = _ref.req,
+      value = _ref.value,
+      parameter = _ref.parameter;
+  var name = parameter.name,
+      style = parameter.style,
+      explode = parameter.explode,
+      content = parameter.content;
+
+  if (content) {
+    var effectiveMediaType = _Object$keys(content)[0];
+
+    req.url = req.url.split("{".concat(name, "}")).join(encodeDisallowedCharacters(serialize(value, effectiveMediaType), {
+      escape: true
+    }));
+    return;
+  }
+
+  var styledValue = stylize({
+    key: parameter.name,
+    value: value,
+    style: style || 'simple',
+    explode: explode || false,
+    escape: true
+  });
+  req.url = req.url.split("{".concat(name, "}")).join(styledValue);
+}
+export function query(_ref2) {
+  var req = _ref2.req,
+      value = _ref2.value,
+      parameter = _ref2.parameter;
+  req.query = req.query || {};
+
+  if (parameter.content) {
+    var effectiveMediaType = _Object$keys(parameter.content)[0];
+
+    req.query[parameter.name] = serialize(value, effectiveMediaType);
+    return;
+  }
+
+  if (value === false) {
+    value = 'false';
+  }
+
+  if (value === 0) {
+    value = '0';
+  }
+
+  if (value) {
+    req.query[parameter.name] = {
+      value: value,
+      serializationOption: pick(parameter, ['style', 'explode', 'allowReserved'])
+    };
+  } else if (parameter.allowEmptyValue && value !== undefined) {
+    var paramName = parameter.name;
+    req.query[paramName] = req.query[paramName] || {};
+    req.query[paramName].allowEmptyValue = true;
+  }
+}
+var PARAMETER_HEADER_BLACKLIST = ['accept', 'authorization', 'content-type'];
+export function header(_ref3) {
+  var req = _ref3.req,
+      parameter = _ref3.parameter,
+      value = _ref3.value;
+  req.headers = req.headers || {};
+
+  if (PARAMETER_HEADER_BLACKLIST.indexOf(parameter.name.toLowerCase()) > -1) {
+    return;
+  }
+
+  if (parameter.content) {
+    var effectiveMediaType = _Object$keys(parameter.content)[0];
+
+    req.headers[parameter.name] = serialize(value, effectiveMediaType);
+    return;
+  }
+
+  if (typeof value !== 'undefined') {
+    req.headers[parameter.name] = stylize({
+      key: parameter.name,
+      value: value,
+      style: parameter.style || 'simple',
+      explode: typeof parameter.explode === 'undefined' ? false : parameter.explode,
+      escape: false
+    });
+  }
+}
+export function cookie(_ref4) {
+  var req = _ref4.req,
+      parameter = _ref4.parameter,
+      value = _ref4.value;
+  req.headers = req.headers || {};
+
+  var type = _typeof(value);
+
+  if (parameter.content) {
+    var effectiveMediaType = _Object$keys(parameter.content)[0];
+
+    req.headers.Cookie = "".concat(parameter.name, "=").concat(serialize(value, effectiveMediaType));
+    return;
+  }
+
+  if (type !== 'undefined') {
+    var prefix = type === 'object' && !_Array$isArray(value) && parameter.explode ? '' : "".concat(parameter.name, "=");
+    req.headers.Cookie = prefix + stylize({
+      key: parameter.name,
+      value: value,
+      escape: false,
+      style: parameter.style || 'form',
+      explode: typeof parameter.explode === 'undefined' ? false : parameter.explode
+    });
+  }
+}