swagger-client 3.10.8 → 3.10.12

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

@@ -0,0 +1,138 @@
+"use strict";
+
+exports.__esModule = true;
+exports.path = path;
+exports.query = query;
+exports.header = header;
+exports.cookie = cookie;
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _styleSerializer = _interopRequireWildcard(require("./style-serializer"));
+
+var _contentSerializer = _interopRequireDefault(require("./content-serializer"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function path({
+  req,
+  value,
+  parameter
+}) {
+  const {
+    name,
+    style,
+    explode,
+    content
+  } = parameter;
+
+  if (content) {
+    const effectiveMediaType = Object.keys(content)[0];
+    req.url = req.url.split(`{${name}}`).join((0, _styleSerializer.encodeDisallowedCharacters)((0, _contentSerializer.default)(value, effectiveMediaType), {
+      escape: true
+    }));
+    return;
+  }
+
+  const styledValue = (0, _styleSerializer.default)({
+    key: parameter.name,
+    value,
+    style: style || 'simple',
+    explode: explode || false,
+    escape: true
+  });
+  req.url = req.url.split(`{${name}}`).join(styledValue);
+}
+
+function query({
+  req,
+  value,
+  parameter
+}) {
+  req.query = req.query || {};
+
+  if (parameter.content) {
+    const effectiveMediaType = Object.keys(parameter.content)[0];
+    req.query[parameter.name] = (0, _contentSerializer.default)(value, effectiveMediaType);
+    return;
+  }
+
+  if (value === false) {
+    value = 'false';
+  }
+
+  if (value === 0) {
+    value = '0';
+  }
+
+  if (value) {
+    req.query[parameter.name] = {
+      value,
+      serializationOption: (0, _pick.default)(parameter, ['style', 'explode', 'allowReserved'])
+    };
+  } else if (parameter.allowEmptyValue && value !== undefined) {
+    const paramName = parameter.name;
+    req.query[paramName] = req.query[paramName] || {};
+    req.query[paramName].allowEmptyValue = true;
+  }
+}
+
+const PARAMETER_HEADER_BLACKLIST = ['accept', 'authorization', 'content-type'];
+
+function header({
+  req,
+  parameter,
+  value
+}) {
+  req.headers = req.headers || {};
+
+  if (PARAMETER_HEADER_BLACKLIST.indexOf(parameter.name.toLowerCase()) > -1) {
+    return;
+  }
+
+  if (parameter.content) {
+    const effectiveMediaType = Object.keys(parameter.content)[0];
+    req.headers[parameter.name] = (0, _contentSerializer.default)(value, effectiveMediaType);
+    return;
+  }
+
+  if (typeof value !== 'undefined') {
+    req.headers[parameter.name] = (0, _styleSerializer.default)({
+      key: parameter.name,
+      value,
+      style: parameter.style || 'simple',
+      explode: typeof parameter.explode === 'undefined' ? false : parameter.explode,
+      escape: false
+    });
+  }
+}
+
+function cookie({
+  req,
+  parameter,
+  value
+}) {
+  req.headers = req.headers || {};
+  const type = typeof value;
+
+  if (parameter.content) {
+    const effectiveMediaType = Object.keys(parameter.content)[0];
+    req.headers.Cookie = `${parameter.name}=${(0, _contentSerializer.default)(value, effectiveMediaType)}`;
+    return;
+  }
+
+  if (type !== 'undefined') {
+    const prefix = type === 'object' && !Array.isArray(value) && parameter.explode ? '' : `${parameter.name}=`;
+    req.headers.Cookie = prefix + (0, _styleSerializer.default)({
+      key: parameter.name,
+      value,
+      escape: false,
+      style: parameter.style || 'form',
+      explode: typeof parameter.explode === 'undefined' ? false : parameter.explode
+    });
+  }
+}

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

@@ -0,0 +1,208 @@
+"use strict";
+
+exports.__esModule = true;
+exports.encodeDisallowedCharacters = encodeDisallowedCharacters;
+exports.default = stylize;
+
+const {
+  Buffer
+} = require('buffer');
+
+const isRfc3986Reserved = char => ":/?#[]@!$&'()*+,;=".indexOf(char) > -1;
+
+const isRrc3986Unreserved = char => {
+  return /^[a-z0-9\-._~]+$/i.test(char);
+};
+
+function encodeDisallowedCharacters(str, {
+  escape
+} = {}, parse) {
+  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 [...str].map(char => {
+    if (isRrc3986Unreserved(char)) {
+      return char;
+    }
+
+    if (isRfc3986Reserved(char) && escape === 'unsafe') {
+      return char;
+    }
+
+    const encoded = (Buffer.from(char).toJSON().data || []).map(byte => `0${byte.toString(16).toUpperCase()}`.slice(-2)).map(encodedByte => `%${encodedByte}`).join('');
+    return encoded;
+  }).join('');
+}
+
+function stylize(config) {
+  const {
+    value
+  } = config;
+
+  if (Array.isArray(value)) {
+    return encodeArray(config);
+  }
+
+  if (typeof value === 'object') {
+    return encodeObject(config);
+  }
+
+  return encodePrimitive(config);
+}
+
+function encodeArray({
+  key,
+  value,
+  style,
+  explode,
+  escape
+}) {
+  const valueEncoder = str => encodeDisallowedCharacters(str, {
+    escape
+  });
+
+  if (style === 'simple') {
+    return value.map(val => valueEncoder(val)).join(',');
+  }
+
+  if (style === 'label') {
+    return `.${value.map(val => valueEncoder(val)).join('.')}`;
+  }
+
+  if (style === 'matrix') {
+    return value.map(val => valueEncoder(val)).reduce((prev, curr) => {
+      if (!prev || explode) {
+        return `${prev || ''};${key}=${curr}`;
+      }
+
+      return `${prev},${curr}`;
+    }, '');
+  }
+
+  if (style === 'form') {
+    const after = explode ? `&${key}=` : ',';
+    return value.map(val => valueEncoder(val)).join(after);
+  }
+
+  if (style === 'spaceDelimited') {
+    const after = explode ? `${key}=` : '';
+    return value.map(val => valueEncoder(val)).join(` ${after}`);
+  }
+
+  if (style === 'pipeDelimited') {
+    const after = explode ? `${key}=` : '';
+    return value.map(val => valueEncoder(val)).join(`|${after}`);
+  }
+
+  return undefined;
+}
+
+function encodeObject({
+  key,
+  value,
+  style,
+  explode,
+  escape
+}) {
+  const valueEncoder = str => encodeDisallowedCharacters(str, {
+    escape
+  });
+
+  const valueKeys = Object.keys(value);
+
+  if (style === 'simple') {
+    return valueKeys.reduce((prev, curr) => {
+      const val = valueEncoder(value[curr]);
+      const middleChar = explode ? '=' : ',';
+      const prefix = prev ? `${prev},` : '';
+      return `${prefix}${curr}${middleChar}${val}`;
+    }, '');
+  }
+
+  if (style === 'label') {
+    return valueKeys.reduce((prev, curr) => {
+      const val = valueEncoder(value[curr]);
+      const middleChar = explode ? '=' : '.';
+      const prefix = prev ? `${prev}.` : '.';
+      return `${prefix}${curr}${middleChar}${val}`;
+    }, '');
+  }
+
+  if (style === 'matrix' && explode) {
+    return valueKeys.reduce((prev, curr) => {
+      const val = valueEncoder(value[curr]);
+      const prefix = prev ? `${prev};` : ';';
+      return `${prefix}${curr}=${val}`;
+    }, '');
+  }
+
+  if (style === 'matrix') {
+    // no explode
+    return valueKeys.reduce((prev, curr) => {
+      const val = valueEncoder(value[curr]);
+      const prefix = prev ? `${prev},` : `;${key}=`;
+      return `${prefix}${curr},${val}`;
+    }, '');
+  }
+
+  if (style === 'form') {
+    return valueKeys.reduce((prev, curr) => {
+      const val = valueEncoder(value[curr]);
+      const prefix = prev ? `${prev}${explode ? '&' : ','}` : '';
+      const separator = explode ? '=' : ',';
+      return `${prefix}${curr}${separator}${val}`;
+    }, '');
+  }
+
+  return undefined;
+}
+
+function encodePrimitive({
+  key,
+  value,
+  style,
+  escape
+}) {
+  const valueEncoder = str => encodeDisallowedCharacters(str, {
+    escape
+  });
+
+  if (style === 'simple') {
+    return valueEncoder(value);
+  }
+
+  if (style === 'label') {
+    return `.${valueEncoder(value)}`;
+  }
+
+  if (style === 'matrix') {
+    return `;${key}=${valueEncoder(value)}`;
+  }
+
+  if (style === 'form') {
+    return valueEncoder(value);
+  }
+
+  if (style === 'deepObject') {
+    return valueEncoder(value, {}, true);
+  }
+
+  return undefined;
+}

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

@@ -0,0 +1,120 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = buildRequest;
+exports.applySecurities = applySecurities;
+
+var _btoa = _interopRequireDefault(require("btoa"));
+
+var _assign = _interopRequireDefault(require("lodash/assign"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// This function runs after the common function,
+// `src/execute/index.js#buildRequest`
+function buildRequest(options, req) {
+  const {
+    spec,
+    operation,
+    securities,
+    requestContentType,
+    attachContentTypeForEmptyPayload
+  } = options; // Add securities, which are applicable
+
+  req = applySecurities({
+    request: req,
+    securities,
+    operation,
+    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)) {
+      [req.headers['Content-Type']] = operation.consumes;
+    } else if (Array.isArray(spec.consumes)) {
+      [req.headers['Content-Type']] = spec.consumes;
+    } else if (operation.parameters && operation.parameters.filter(p => p.type === 'file').length) {
+      req.headers['Content-Type'] = 'multipart/form-data';
+    } else if (operation.parameters && operation.parameters.filter(p => p.in === 'formData').length) {
+      req.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+  } else if (requestContentType) {
+    const isBodyParamPresent = operation.parameters && operation.parameters.filter(p => p.in === 'body').length > 0;
+    const isFormDataParamPresent = operation.parameters && operation.parameters.filter(p => 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
+
+
+function applySecurities({
+  request,
+  securities = {},
+  operation = {},
+  spec
+}) {
+  const result = (0, _assign.default)({}, request);
+  const {
+    authorized = {},
+    specSecurity = []
+  } = securities;
+  const security = operation.security || specSecurity;
+  const isAuthorized = authorized && !!Object.keys(authorized).length;
+  const 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(securityObj => {
+    Object.keys(securityObj).forEach(key => {
+      const auth = authorized[key];
+
+      if (!auth) {
+        return;
+      }
+
+      const {
+        token
+      } = auth;
+      const value = auth.value || auth;
+      const schema = securityDef[key];
+      const {
+        type
+      } = schema;
+      const tokenName = schema['x-tokenName'] || 'access_token';
+      const oauthToken = token && token[tokenName];
+      let tokenType = token && token.token_type;
+
+      if (auth) {
+        if (type === 'apiKey') {
+          const 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 {
+            const username = value.username || '';
+            const password = value.password || '';
+            value.base64 = (0, _btoa.default)(`${username}:${password}`);
+            result.headers.authorization = `Basic ${value.base64}`;
+          }
+        } else if (type === 'oauth2' && oauthToken) {
+          tokenType = !tokenType || tokenType.toLowerCase() === 'bearer' ? 'Bearer' : tokenType;
+          result.headers.authorization = `${tokenType} ${oauthToken}`;
+        }
+      }
+    });
+  });
+  return result;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+// These functions will update the request.
+// They'll be given {req, value, paramter, spec, operation}.
+var _default = {
+  body: bodyBuilder,
+  header: headerBuilder,
+  query: queryBuilder,
+  path: pathBuilder,
+  formData: formDataBuilder
+}; // Add the body to the request
+
+exports.default = _default;
+
+function bodyBuilder({
+  req,
+  value
+}) {
+  req.body = value;
+} // Add a form data object.
+
+
+function formDataBuilder({
+  req,
+  value,
+  parameter
+}) {
+  if (value || parameter.allowEmptyValue) {
+    req.form = req.form || {};
+    req.form[parameter.name] = {
+      value,
+      allowEmptyValue: parameter.allowEmptyValue,
+      collectionFormat: parameter.collectionFormat
+    };
+  }
+} // Add a header to the request
+
+
+function headerBuilder({
+  req,
+  parameter,
+  value
+}) {
+  req.headers = req.headers || {};
+
+  if (typeof value !== 'undefined') {
+    req.headers[parameter.name] = value;
+  }
+} // Replace path paramters, with values ( ie: the URL )
+
+
+function pathBuilder({
+  req,
+  value,
+  parameter
+}) {
+  req.url = req.url.split(`{${parameter.name}}`).join(encodeURIComponent(value));
+} // Add a query to the `query` object, which will later be stringified into the URL's search
+
+
+function queryBuilder({
+  req,
+  value,
+  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
+    };
+  } else if (parameter.allowEmptyValue && value !== undefined) {
+    const paramName = parameter.name;
+    req.query[paramName] = req.query[paramName] || {};
+    req.query[paramName].allowEmptyValue = true;
+  }
+}