swagger-client 3.10.8 → 3.10.12

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

@@ -0,0 +1,232 @@
+import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
+import _typeof from "@babel/runtime-corejs2/helpers/typeof";
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import _toConsumableArray from "@babel/runtime-corejs2/helpers/toConsumableArray";
+
+var _require = require('buffer'),
+    Buffer = _require.Buffer;
+
+var isRfc3986Reserved = function isRfc3986Reserved(char) {
+  return ":/?#[]@!$&'()*+,;=".indexOf(char) > -1;
+};
+
+var isRrc3986Unreserved = function isRrc3986Unreserved(char) {
+  return /^[a-z0-9\-._~]+$/i.test(char);
+};
+
+export function encodeDisallowedCharacters(str) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      escape = _ref.escape;
+
+  var parse = arguments.length > 2 ? arguments[2] : undefined;
+
+  if (typeof str === 'number') {
+    str = str.toString();
+  }
+
+  if (typeof str !== 'string' || !str.length) {
+    return str;
+  }
+
+  if (!escape) {
+    return str;
+  }
+
+  if (parse) {
+    return JSON.parse(str);
+  } // In ES6 you can do this quite easily by using the new ... spread operator.
+  // This causes the string iterator (another new ES6 feature) to be used internally,
+  // and because that iterator is designed to deal with
+  // code points rather than UCS-2/UTF-16 code units.
+
+
+  return _toConsumableArray(str).map(function (char) {
+    if (isRrc3986Unreserved(char)) {
+      return char;
+    }
+
+    if (isRfc3986Reserved(char) && escape === 'unsafe') {
+      return char;
+    }
+
+    var encoded = (Buffer.from(char).toJSON().data || []).map(function (byte) {
+      return "0".concat(byte.toString(16).toUpperCase()).slice(-2);
+    }).map(function (encodedByte) {
+      return "%".concat(encodedByte);
+    }).join('');
+    return encoded;
+  }).join('');
+}
+export default function stylize(config) {
+  var value = config.value;
+
+  if (_Array$isArray(value)) {
+    return encodeArray(config);
+  }
+
+  if (_typeof(value) === 'object') {
+    return encodeObject(config);
+  }
+
+  return encodePrimitive(config);
+}
+
+function encodeArray(_ref2) {
+  var key = _ref2.key,
+      value = _ref2.value,
+      style = _ref2.style,
+      explode = _ref2.explode,
+      escape = _ref2.escape;
+
+  var valueEncoder = function valueEncoder(str) {
+    return encodeDisallowedCharacters(str, {
+      escape: escape
+    });
+  };
+
+  if (style === 'simple') {
+    return value.map(function (val) {
+      return valueEncoder(val);
+    }).join(',');
+  }
+
+  if (style === 'label') {
+    return ".".concat(value.map(function (val) {
+      return valueEncoder(val);
+    }).join('.'));
+  }
+
+  if (style === 'matrix') {
+    return value.map(function (val) {
+      return valueEncoder(val);
+    }).reduce(function (prev, curr) {
+      if (!prev || explode) {
+        return "".concat(prev || '', ";").concat(key, "=").concat(curr);
+      }
+
+      return "".concat(prev, ",").concat(curr);
+    }, '');
+  }
+
+  if (style === 'form') {
+    var after = explode ? "&".concat(key, "=") : ',';
+    return value.map(function (val) {
+      return valueEncoder(val);
+    }).join(after);
+  }
+
+  if (style === 'spaceDelimited') {
+    var _after = explode ? "".concat(key, "=") : '';
+
+    return value.map(function (val) {
+      return valueEncoder(val);
+    }).join(" ".concat(_after));
+  }
+
+  if (style === 'pipeDelimited') {
+    var _after2 = explode ? "".concat(key, "=") : '';
+
+    return value.map(function (val) {
+      return valueEncoder(val);
+    }).join("|".concat(_after2));
+  }
+
+  return undefined;
+}
+
+function encodeObject(_ref3) {
+  var key = _ref3.key,
+      value = _ref3.value,
+      style = _ref3.style,
+      explode = _ref3.explode,
+      escape = _ref3.escape;
+
+  var valueEncoder = function valueEncoder(str) {
+    return encodeDisallowedCharacters(str, {
+      escape: escape
+    });
+  };
+
+  var valueKeys = _Object$keys(value);
+
+  if (style === 'simple') {
+    return valueKeys.reduce(function (prev, curr) {
+      var val = valueEncoder(value[curr]);
+      var middleChar = explode ? '=' : ',';
+      var prefix = prev ? "".concat(prev, ",") : '';
+      return "".concat(prefix).concat(curr).concat(middleChar).concat(val);
+    }, '');
+  }
+
+  if (style === 'label') {
+    return valueKeys.reduce(function (prev, curr) {
+      var val = valueEncoder(value[curr]);
+      var middleChar = explode ? '=' : '.';
+      var prefix = prev ? "".concat(prev, ".") : '.';
+      return "".concat(prefix).concat(curr).concat(middleChar).concat(val);
+    }, '');
+  }
+
+  if (style === 'matrix' && explode) {
+    return valueKeys.reduce(function (prev, curr) {
+      var val = valueEncoder(value[curr]);
+      var prefix = prev ? "".concat(prev, ";") : ';';
+      return "".concat(prefix).concat(curr, "=").concat(val);
+    }, '');
+  }
+
+  if (style === 'matrix') {
+    // no explode
+    return valueKeys.reduce(function (prev, curr) {
+      var val = valueEncoder(value[curr]);
+      var prefix = prev ? "".concat(prev, ",") : ";".concat(key, "=");
+      return "".concat(prefix).concat(curr, ",").concat(val);
+    }, '');
+  }
+
+  if (style === 'form') {
+    return valueKeys.reduce(function (prev, curr) {
+      var val = valueEncoder(value[curr]);
+      var prefix = prev ? "".concat(prev).concat(explode ? '&' : ',') : '';
+      var separator = explode ? '=' : ',';
+      return "".concat(prefix).concat(curr).concat(separator).concat(val);
+    }, '');
+  }
+
+  return undefined;
+}
+
+function encodePrimitive(_ref4) {
+  var key = _ref4.key,
+      value = _ref4.value,
+      style = _ref4.style,
+      escape = _ref4.escape;
+
+  var valueEncoder = function valueEncoder(str) {
+    return encodeDisallowedCharacters(str, {
+      escape: escape
+    });
+  };
+
+  if (style === 'simple') {
+    return valueEncoder(value);
+  }
+
+  if (style === 'label') {
+    return ".".concat(valueEncoder(value));
+  }
+
+  if (style === 'matrix') {
+    return ";".concat(key, "=").concat(valueEncoder(value));
+  }
+
+  if (style === 'form') {
+    return valueEncoder(value);
+  }
+
+  if (style === 'deepObject') {
+    return valueEncoder(value, {}, true);
+  }
+
+  return undefined;
+}

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

@@ -0,0 +1,119 @@
+import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
+import _slicedToArray from "@babel/runtime-corejs2/helpers/slicedToArray";
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import btoa from 'btoa';
+import assign from 'lodash/assign'; // This function runs after the common function,
+// `src/execute/index.js#buildRequest`
+
+export default function buildRequest(options, req) {
+  var spec = options.spec,
+      operation = options.operation,
+      securities = options.securities,
+      requestContentType = options.requestContentType,
+      attachContentTypeForEmptyPayload = options.attachContentTypeForEmptyPayload; // Add securities, which are applicable
+
+  req = applySecurities({
+    request: req,
+    securities: securities,
+    operation: operation,
+    spec: spec
+  });
+
+  if (req.body || req.form || attachContentTypeForEmptyPayload) {
+    // all following conditionals are Swagger2 only
+    if (requestContentType) {
+      req.headers['Content-Type'] = requestContentType;
+    } else if (_Array$isArray(operation.consumes)) {
+      var _operation$consumes = _slicedToArray(operation.consumes, 1);
+
+      req.headers['Content-Type'] = _operation$consumes[0];
+    } else if (_Array$isArray(spec.consumes)) {
+      var _spec$consumes = _slicedToArray(spec.consumes, 1);
+
+      req.headers['Content-Type'] = _spec$consumes[0];
+    } else if (operation.parameters && operation.parameters.filter(function (p) {
+      return p.type === 'file';
+    }).length) {
+      req.headers['Content-Type'] = 'multipart/form-data';
+    } else if (operation.parameters && operation.parameters.filter(function (p) {
+      return p.in === 'formData';
+    }).length) {
+      req.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+  } else if (requestContentType) {
+    var isBodyParamPresent = operation.parameters && operation.parameters.filter(function (p) {
+      return p.in === 'body';
+    }).length > 0;
+    var isFormDataParamPresent = operation.parameters && operation.parameters.filter(function (p) {
+      return p.in === 'formData';
+    }).length > 0;
+
+    if (isBodyParamPresent || isFormDataParamPresent) {
+      req.headers['Content-Type'] = requestContentType;
+    }
+  }
+
+  return req;
+} // Add security values, to operations - that declare their need on them
+
+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,
+      _securities$specSecur = securities.specSecurity,
+      specSecurity = _securities$specSecur === void 0 ? [] : _securities$specSecur;
+  var security = operation.security || specSecurity;
+  var isAuthorized = authorized && !!_Object$keys(authorized).length;
+  var securityDef = spec.securityDefinitions;
+  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];
+
+      if (!auth) {
+        return;
+      }
+
+      var token = auth.token;
+      var value = auth.value || auth;
+      var schema = securityDef[key];
+      var type = schema.type;
+      var tokenName = schema['x-tokenName'] || 'access_token';
+      var oauthToken = token && token[tokenName];
+      var tokenType = token && token.token_type;
+
+      if (auth) {
+        if (type === 'apiKey') {
+          var inType = schema.in === 'query' ? 'query' : 'headers';
+          result[inType] = result[inType] || {};
+          result[inType][schema.name] = value;
+        } else if (type === 'basic') {
+          if (value.header) {
+            result.headers.authorization = value.header;
+          } else {
+            var username = value.username || '';
+            var password = value.password || '';
+            value.base64 = btoa("".concat(username, ":").concat(password));
+            result.headers.authorization = "Basic ".concat(value.base64);
+          }
+        } else if (type === 'oauth2' && oauthToken) {
+          tokenType = !tokenType || tokenType.toLowerCase() === 'bearer' ? 'Bearer' : tokenType;
+          result.headers.authorization = "".concat(tokenType, " ").concat(oauthToken);
+        }
+      }
+    });
+  });
+  return result;
+}

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

@@ -0,0 +1,78 @@
+// These functions will update the request.
+// They'll be given {req, value, paramter, spec, operation}.
+export default {
+  body: bodyBuilder,
+  header: headerBuilder,
+  query: queryBuilder,
+  path: pathBuilder,
+  formData: formDataBuilder
+}; // Add the body to the request
+
+function bodyBuilder(_ref) {
+  var req = _ref.req,
+      value = _ref.value;
+  req.body = value;
+} // Add a form data object.
+
+
+function formDataBuilder(_ref2) {
+  var req = _ref2.req,
+      value = _ref2.value,
+      parameter = _ref2.parameter;
+
+  if (value || parameter.allowEmptyValue) {
+    req.form = req.form || {};
+    req.form[parameter.name] = {
+      value: value,
+      allowEmptyValue: parameter.allowEmptyValue,
+      collectionFormat: parameter.collectionFormat
+    };
+  }
+} // Add a header to the request
+
+
+function headerBuilder(_ref3) {
+  var req = _ref3.req,
+      parameter = _ref3.parameter,
+      value = _ref3.value;
+  req.headers = req.headers || {};
+
+  if (typeof value !== 'undefined') {
+    req.headers[parameter.name] = value;
+  }
+} // Replace path paramters, with values ( ie: the URL )
+
+
+function pathBuilder(_ref4) {
+  var req = _ref4.req,
+      value = _ref4.value,
+      parameter = _ref4.parameter;
+  req.url = req.url.split("{".concat(parameter.name, "}")).join(encodeURIComponent(value));
+} // Add a query to the `query` object, which will later be stringified into the URL's search
+
+
+function queryBuilder(_ref5) {
+  var req = _ref5.req,
+      value = _ref5.value,
+      parameter = _ref5.parameter;
+  req.query = req.query || {};
+
+  if (value === false && parameter.type === 'boolean') {
+    value = 'false';
+  }
+
+  if (value === 0 && ['number', 'integer'].indexOf(parameter.type) > -1) {
+    value = '0';
+  }
+
+  if (value) {
+    req.query[parameter.name] = {
+      collectionFormat: parameter.collectionFormat,
+      value: value
+    };
+  } else if (parameter.allowEmptyValue && value !== undefined) {
+    var paramName = parameter.name;
+    req.query[paramName] = req.query[paramName] || {};
+    req.query[paramName].allowEmptyValue = true;
+  }
+}

package/es/helpers.js

@@ -0,0 +1,272 @@
+import _createForOfIteratorHelper from "@babel/runtime-corejs2/helpers/createForOfIteratorHelper";
+import _typeof from "@babel/runtime-corejs2/helpers/typeof";
+import isObject from 'lodash/isObject';
+import startsWith from 'lodash/startsWith';
+
+var toLower = function toLower(str) {
+  return String.prototype.toLowerCase.call(str);
+};
+
+var escapeString = function escapeString(str) {
+  return str.replace(/[^\w]/gi, '_');
+}; // Spec version detection
+
+
+export function isOAS3(spec) {
+  var oasVersion = spec.openapi;
+
+  if (!oasVersion) {
+    return false;
+  }
+
+  return startsWith(oasVersion, '3');
+}
+export function isSwagger2(spec) {
+  var swaggerVersion = spec.swagger;
+
+  if (!swaggerVersion) {
+    return false;
+  }
+
+  return startsWith(swaggerVersion, '2');
+} // Strategy for determining operationId
+
+export function opId(operation, pathName) {
+  var method = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+  var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      v2OperationIdCompatibilityMode = _ref.v2OperationIdCompatibilityMode;
+
+  if (!operation || _typeof(operation) !== 'object') {
+    return null;
+  }
+
+  var idWithoutWhitespace = (operation.operationId || '').replace(/\s/g, '');
+
+  if (idWithoutWhitespace.length) {
+    return escapeString(operation.operationId);
+  }
+
+  return idFromPathMethod(pathName, method, {
+    v2OperationIdCompatibilityMode: v2OperationIdCompatibilityMode
+  });
+} // Create a generated operationId from pathName + method
+
+export function idFromPathMethod(pathName, method) {
+  var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      v2OperationIdCompatibilityMode = _ref2.v2OperationIdCompatibilityMode;
+
+  if (v2OperationIdCompatibilityMode) {
+    var res = "".concat(method.toLowerCase(), "_").concat(pathName).replace(/[\s!@#$%^&*()_+=[{\]};:<>|./?,\\'""-]/g, '_');
+    res = res || "".concat(pathName.substring(1), "_").concat(method);
+    return res.replace(/((_){2,})/g, '_').replace(/^(_)*/g, '').replace(/([_])*$/g, '');
+  }
+
+  return "".concat(toLower(method)).concat(escapeString(pathName));
+}
+export function legacyIdFromPathMethod(pathName, method) {
+  return "".concat(toLower(method), "-").concat(pathName);
+} // Get the operation, based on operationId ( just return the object, no inheritence )
+
+export function getOperationRaw(spec, id) {
+  if (!spec || !spec.paths) {
+    return null;
+  }
+
+  return findOperation(spec, function (_ref3) {
+    var pathName = _ref3.pathName,
+        method = _ref3.method,
+        operation = _ref3.operation;
+
+    if (!operation || _typeof(operation) !== 'object') {
+      return false;
+    }
+
+    var rawOperationId = operation.operationId; // straight from the source
+
+    var operationId = opId(operation, pathName, method);
+    var legacyOperationId = legacyIdFromPathMethod(pathName, method);
+    return [operationId, legacyOperationId, rawOperationId].some(function (val) {
+      return val && val === id;
+    });
+  });
+} // Will stop iterating over the operations and return the operationObj
+// as soon as predicate returns true
+
+export function findOperation(spec, predicate) {
+  return eachOperation(spec, predicate, true) || null;
+} // iterate over each operation, and fire a callback with details
+// `find=true` will stop iterating, when the cb returns truthy
+
+export function eachOperation(spec, cb, find) {
+  if (!spec || _typeof(spec) !== 'object' || !spec.paths || _typeof(spec.paths) !== 'object') {
+    return null;
+  }
+
+  var paths = spec.paths; // Iterate over the spec, collecting operations
+  // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+  for (var pathName in paths) {
+    // eslint-disable-next-line no-restricted-syntax, guard-for-in
+    for (var method in paths[pathName]) {
+      if (method.toUpperCase() === 'PARAMETERS') {
+        continue; // eslint-disable-line no-continue
+      }
+
+      var operation = paths[pathName][method];
+
+      if (!operation || _typeof(operation) !== 'object') {
+        continue; // eslint-disable-line no-continue
+      }
+
+      var operationObj = {
+        spec: spec,
+        pathName: pathName,
+        method: method.toUpperCase(),
+        operation: operation
+      };
+      var cbValue = cb(operationObj);
+
+      if (find && cbValue) {
+        return operationObj;
+      }
+    }
+  }
+
+  return undefined;
+} // REVIEW: OAS3: identify normalization steps that need changes
+// ...maybe create `normalizeOAS3`?
+
+export function normalizeSwagger(parsedSpec) {
+  var spec = parsedSpec.spec;
+  var paths = spec.paths;
+  var map = {};
+
+  if (!paths || spec.$$normalized) {
+    return parsedSpec;
+  } // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+
+  for (var pathName in paths) {
+    var path = paths[pathName];
+
+    if (!isObject(path)) {
+      continue; // eslint-disable-line no-continue
+    }
+
+    var pathParameters = path.parameters; // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+    var _loop = function _loop(method) {
+      var operation = path[method];
+
+      if (!isObject(operation)) {
+        return "continue"; // eslint-disable-line no-continue
+      }
+
+      var oid = opId(operation, pathName, method);
+
+      if (oid) {
+        if (map[oid]) {
+          map[oid].push(operation);
+        } else {
+          map[oid] = [operation];
+        }
+
+        var opList = map[oid];
+
+        if (opList.length > 1) {
+          opList.forEach(function (o, i) {
+            // eslint-disable-next-line no-underscore-dangle
+            o.__originalOperationId = o.__originalOperationId || o.operationId;
+            o.operationId = "".concat(oid).concat(i + 1);
+          });
+        } else if (typeof operation.operationId !== 'undefined') {
+          // Ensure we always add the normalized operation ID if one already exists
+          // ( potentially different, given that we normalize our IDs)
+          // ... _back_ to the spec. Otherwise, they might not line up
+          var obj = opList[0]; // eslint-disable-next-line no-underscore-dangle
+
+          obj.__originalOperationId = obj.__originalOperationId || operation.operationId;
+          obj.operationId = oid;
+        }
+      }
+
+      if (method !== 'parameters') {
+        // Add inherited consumes, produces, parameters, securities
+        var inheritsList = [];
+        var toBeInherit = {}; // Global-levels
+        // eslint-disable-next-line no-restricted-syntax
+
+        for (var key in spec) {
+          if (key === 'produces' || key === 'consumes' || key === 'security') {
+            toBeInherit[key] = spec[key];
+            inheritsList.push(toBeInherit);
+          }
+        } // Path-levels
+
+
+        if (pathParameters) {
+          toBeInherit.parameters = pathParameters;
+          inheritsList.push(toBeInherit);
+        }
+
+        if (inheritsList.length) {
+          // eslint-disable-next-line no-restricted-syntax
+          var _iterator = _createForOfIteratorHelper(inheritsList),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var inherits = _step.value;
+
+              // eslint-disable-next-line no-restricted-syntax
+              for (var inheritName in inherits) {
+                if (!operation[inheritName]) {
+                  operation[inheritName] = inherits[inheritName];
+                } else if (inheritName === 'parameters') {
+                  // eslint-disable-next-line no-restricted-syntax
+                  var _iterator2 = _createForOfIteratorHelper(inherits[inheritName]),
+                      _step2;
+
+                  try {
+                    var _loop2 = function _loop2() {
+                      var param = _step2.value;
+                      var exists = operation[inheritName].some(function (opParam) {
+                        return opParam.name && opParam.name === param.name || opParam.$ref && opParam.$ref === param.$ref || opParam.$$ref && opParam.$$ref === param.$$ref || opParam === param;
+                      });
+
+                      if (!exists) {
+                        operation[inheritName].push(param);
+                      }
+                    };
+
+                    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                      _loop2();
+                    }
+                  } catch (err) {
+                    _iterator2.e(err);
+                  } finally {
+                    _iterator2.f();
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+      }
+    };
+
+    for (var method in path) {
+      var _ret = _loop(method);
+
+      if (_ret === "continue") continue;
+    }
+  }
+
+  spec.$$normalized = true;
+  return parsedSpec;
+}