swagger-client 3.10.8 → 3.10.12

package/lib/http.js

@@ -0,0 +1,470 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = http;
+exports.serializeRes = serializeRes;
+exports.serializeHeaders = serializeHeaders;
+exports.isFile = isFile;
+exports.encodeFormOrQuery = encodeFormOrQuery;
+exports.mergeInQueryOrForm = mergeInQueryOrForm;
+exports.makeHttp = makeHttp;
+exports.shouldDownloadAsText = exports.self = void 0;
+
+require("cross-fetch/polyfill");
+
+var _qs = _interopRequireDefault(require("qs"));
+
+var _jsYaml = _interopRequireDefault(require("js-yaml"));
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _isFunction = _interopRequireDefault(require("lodash/isFunction"));
+
+var _buffer = require("buffer");
+
+var _formDataMonkeyPatch = _interopRequireDefault(require("./internal/form-data-monkey-patch"));
+
+var _styleSerializer = require("./execute/oas3/style-serializer");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* global fetch */
+// For testing
+const self = {
+  serializeRes,
+  mergeInQueryOrForm
+}; // Handles fetch-like syntax and the case where there is only one object passed-in
+// (which will have the URL as a property). Also serilizes the response.
+
+exports.self = self;
+
+async function http(url, request = {}) {
+  if (typeof url === 'object') {
+    request = url;
+    url = request.url;
+  }
+
+  request.headers = request.headers || {}; // Serializes query, for convenience
+  // Should be the last thing we do, as its hard to mutate the URL with
+  // the search string, but much easier to manipulate the req.query object
+
+  self.mergeInQueryOrForm(request); // Newlines in header values cause weird error messages from `window.fetch`,
+  // so let's massage them out.
+  // Context: https://stackoverflow.com/a/50709178
+
+  if (request.headers) {
+    Object.keys(request.headers).forEach(headerName => {
+      const value = request.headers[headerName];
+
+      if (typeof value === 'string') {
+        request.headers[headerName] = value.replace(/\n+/g, ' ');
+      }
+    });
+  } // Wait for the request interceptor, if it was provided
+  // WARNING: don't put anything between this and the request firing unless
+  // you have a good reason!
+
+
+  if (request.requestInterceptor) {
+    request = (await request.requestInterceptor(request)) || request;
+  } // for content-type=multipart\/form-data remove content-type from request before fetch
+  // so that correct one with `boundary` is set
+
+
+  const contentType = request.headers['content-type'] || request.headers['Content-Type'];
+
+  if (/multipart\/form-data/i.test(contentType)) {
+    delete request.headers['content-type'];
+    delete request.headers['Content-Type'];
+  } // eslint-disable-next-line no-undef
+
+
+  let res;
+
+  try {
+    res = await (request.userFetch || fetch)(request.url, request);
+    res = await self.serializeRes(res, url, request);
+
+    if (request.responseInterceptor) {
+      res = (await request.responseInterceptor(res)) || res;
+    }
+  } catch (resError) {
+    if (!res) {
+      // res is completely absent, so we can't construct our own error
+      // so we'll just throw the error we got
+      throw resError;
+    }
+
+    const error = new Error(res.statusText);
+    error.status = res.status;
+    error.statusCode = res.status;
+    error.responseError = resError;
+    throw error;
+  }
+
+  if (!res.ok) {
+    const error = new Error(res.statusText);
+    error.status = res.status;
+    error.statusCode = res.status;
+    error.response = res;
+    throw error;
+  }
+
+  return res;
+} // exported for testing
+
+
+const shouldDownloadAsText = (contentType = '') => /(json|xml|yaml|text)\b/.test(contentType);
+
+exports.shouldDownloadAsText = shouldDownloadAsText;
+
+function parseBody(body, contentType) {
+  if (contentType && (contentType.indexOf('application/json') === 0 || contentType.indexOf('+json') > 0)) {
+    return JSON.parse(body);
+  }
+
+  return _jsYaml.default.safeLoad(body);
+} // Serialize the response, returns a promise with headers and the body part of the hash
+
+
+function serializeRes(oriRes, url, {
+  loadSpec = false
+} = {}) {
+  const res = {
+    ok: oriRes.ok,
+    url: oriRes.url || url,
+    status: oriRes.status,
+    statusText: oriRes.statusText,
+    headers: serializeHeaders(oriRes.headers)
+  };
+  const contentType = res.headers['content-type'];
+  const useText = loadSpec || shouldDownloadAsText(contentType);
+  const getBody = useText ? oriRes.text : oriRes.blob || oriRes.buffer;
+  return getBody.call(oriRes).then(body => {
+    res.text = body;
+    res.data = body;
+
+    if (useText) {
+      try {
+        const obj = parseBody(body, contentType);
+        res.body = obj;
+        res.obj = obj;
+      } catch (e) {
+        res.parseError = e;
+      }
+    }
+
+    return res;
+  });
+}
+
+function serializeHeaderValue(value) {
+  const isMulti = value.includes(', ');
+  return isMulti ? value.split(', ') : value;
+} // Serialize headers into a hash, where mutliple-headers result in an array.
+//
+// eg: Cookie: one
+//     Cookie: two
+//  =  { Cookie: [ "one", "two" ]
+
+
+function serializeHeaders(headers = {}) {
+  if (!(0, _isFunction.default)(headers.entries)) return {};
+  return Array.from(headers.entries()).reduce((acc, [header, value]) => {
+    acc[header] = serializeHeaderValue(value);
+    return acc;
+  }, {});
+}
+
+function isFile(obj, navigatorObj) {
+  if (!navigatorObj && typeof navigator !== 'undefined') {
+    // eslint-disable-next-line no-undef
+    navigatorObj = navigator;
+  }
+
+  if (navigatorObj && navigatorObj.product === 'ReactNative') {
+    if (obj && typeof obj === 'object' && typeof obj.uri === 'string') {
+      return true;
+    }
+
+    return false;
+  }
+
+  if (typeof File !== 'undefined' && obj instanceof File) {
+    // eslint-disable-line no-undef
+    return true;
+  }
+
+  if (typeof Blob !== 'undefined' && obj instanceof Blob) {
+    // eslint-disable-line no-undef
+    return true;
+  }
+
+  if (typeof _buffer.Buffer !== 'undefined' && obj instanceof _buffer.Buffer) {
+    return true;
+  }
+
+  return obj !== null && typeof obj === 'object' && typeof obj.pipe === 'function';
+}
+
+function isArrayOfFile(obj, navigatorObj) {
+  return Array.isArray(obj) && obj.some(v => isFile(v, navigatorObj));
+}
+
+const STYLE_SEPARATORS = {
+  form: ',',
+  spaceDelimited: '%20',
+  pipeDelimited: '|'
+};
+const SEPARATORS = {
+  csv: ',',
+  ssv: '%20',
+  tsv: '%09',
+  pipes: '|'
+}; // Formats a key-value and returns an array of key-value pairs.
+//
+// Return value example 1: [['color', 'blue']]
+// Return value example 2: [['color', 'blue,black,brown']]
+// Return value example 3: [['color', ['blue', 'black', 'brown']]]
+// Return value example 4: [['color', 'R,100,G,200,B,150']]
+// Return value example 5: [['R', '100'], ['G', '200'], ['B', '150']]
+// Return value example 6: [['color[R]', '100'], ['color[G]', '200'], ['color[B]', '150']]
+
+function formatKeyValue(key, input, skipEncoding = false) {
+  const {
+    collectionFormat,
+    allowEmptyValue,
+    serializationOption,
+    encoding
+  } = input; // `input` can be string
+
+  const value = typeof input === 'object' && !Array.isArray(input) ? input.value : input;
+  const encodeFn = skipEncoding ? k => k.toString() : k => encodeURIComponent(k);
+  const encodedKey = encodeFn(key);
+
+  if (typeof value === 'undefined' && allowEmptyValue) {
+    return [[encodedKey, '']];
+  } // file
+
+
+  if (isFile(value) || isArrayOfFile(value)) {
+    return [[encodedKey, value]];
+  } // for OAS 3 Parameter Object for serialization
+
+
+  if (serializationOption) {
+    return formatKeyValueBySerializationOption(key, value, skipEncoding, serializationOption);
+  } // for OAS 3 Encoding Object
+
+
+  if (encoding) {
+    if ([typeof encoding.style, typeof encoding.explode, typeof encoding.allowReserved].some(type => type !== 'undefined')) {
+      return formatKeyValueBySerializationOption(key, value, skipEncoding, (0, _pick.default)(encoding, ['style', 'explode', 'allowReserved']));
+    }
+
+    if (encoding.contentType) {
+      if (encoding.contentType === 'application/json') {
+        // If value is a string, assume value is already a JSON string
+        const json = typeof value === 'string' ? value : JSON.stringify(value);
+        return [[encodedKey, encodeFn(json)]];
+      }
+
+      return [[encodedKey, encodeFn(value.toString())]];
+    } // Primitive
+
+
+    if (typeof value !== 'object') {
+      return [[encodedKey, encodeFn(value)]];
+    } // Array of primitives
+
+
+    if (Array.isArray(value) && value.every(v => typeof v !== 'object')) {
+      return [[encodedKey, value.map(encodeFn).join(',')]];
+    } // Array or object
+
+
+    return [[encodedKey, encodeFn(JSON.stringify(value))]];
+  } // for OAS 2 Parameter Object
+  // Primitive
+
+
+  if (typeof value !== 'object') {
+    return [[encodedKey, encodeFn(value)]];
+  } // Array
+
+
+  if (Array.isArray(value)) {
+    if (collectionFormat === 'multi') {
+      // In case of multipart/formdata, it is used as array.
+      // Otherwise, the caller will convert it to a query by qs.stringify.
+      return [[encodedKey, value.map(encodeFn)]];
+    }
+
+    return [[encodedKey, value.map(encodeFn).join(SEPARATORS[collectionFormat || 'csv'])]];
+  } // Object
+
+
+  return [[encodedKey, '']];
+}
+
+function formatKeyValueBySerializationOption(key, value, skipEncoding, serializationOption) {
+  const style = serializationOption.style || 'form';
+  const explode = typeof serializationOption.explode === 'undefined' ? style === 'form' : serializationOption.explode; // eslint-disable-next-line no-nested-ternary
+
+  const escape = skipEncoding ? false : serializationOption && serializationOption.allowReserved ? 'unsafe' : 'reserved';
+
+  const encodeFn = v => (0, _styleSerializer.encodeDisallowedCharacters)(v, {
+    escape
+  });
+
+  const encodeKeyFn = skipEncoding ? k => k : k => (0, _styleSerializer.encodeDisallowedCharacters)(k, {
+    escape
+  }); // Primitive
+
+  if (typeof value !== 'object') {
+    return [[encodeKeyFn(key), encodeFn(value)]];
+  } // Array
+
+
+  if (Array.isArray(value)) {
+    if (explode) {
+      // In case of multipart/formdata, it is used as array.
+      // Otherwise, the caller will convert it to a query by qs.stringify.
+      return [[encodeKeyFn(key), value.map(encodeFn)]];
+    }
+
+    return [[encodeKeyFn(key), value.map(encodeFn).join(STYLE_SEPARATORS[style])]];
+  } // Object
+
+
+  if (style === 'deepObject') {
+    return Object.keys(value).map(valueKey => [encodeKeyFn(`${key}[${valueKey}]`), encodeFn(value[valueKey])]);
+  }
+
+  if (explode) {
+    return Object.keys(value).map(valueKey => [encodeKeyFn(valueKey), encodeFn(value[valueKey])]);
+  }
+
+  return [[encodeKeyFn(key), Object.keys(value).map(valueKey => [`${encodeKeyFn(valueKey)},${encodeFn(value[valueKey])}`]).join(',')]];
+}
+
+function buildFormData(reqForm) {
+  /**
+   * Build a new FormData instance, support array as field value
+   * OAS2.0 - when collectionFormat is multi
+   * OAS3.0 - when explode of Encoding Object is true
+   * @param {Object} reqForm - ori req.form
+   * @return {FormData} - new FormData instance
+   */
+  return Object.entries(reqForm).reduce((formData, [name, input]) => {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [key, value] of formatKeyValue(name, input, true)) {
+      if (Array.isArray(value)) {
+        // eslint-disable-next-line no-restricted-syntax
+        for (const v of value) {
+          formData.append(key, v);
+        }
+      } else {
+        formData.append(key, value);
+      }
+    }
+
+    return formData;
+  }, new _formDataMonkeyPatch.default());
+} // Encodes an object using appropriate serializer.
+
+
+function encodeFormOrQuery(data) {
+  /**
+   * Encode parameter names and values
+   * @param {Object} result - parameter names and values
+   * @param {string} parameterName - Parameter name
+   * @return {object} encoded parameter names and values
+   */
+  const encodedQuery = Object.keys(data).reduce((result, parameterName) => {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [key, value] of formatKeyValue(parameterName, data[parameterName])) {
+      result[key] = value;
+    }
+
+    return result;
+  }, {});
+  return _qs.default.stringify(encodedQuery, {
+    encode: false,
+    indices: false
+  }) || '';
+} // If the request has a `query` object, merge it into the request.url, and delete the object
+// If file and/or multipart, also create FormData instance
+
+
+function mergeInQueryOrForm(req = {}) {
+  const {
+    url = '',
+    query,
+    form
+  } = req;
+
+  const joinSearch = (...strs) => {
+    const search = strs.filter(a => a).join('&'); // Only truthy value
+
+    return search ? `?${search}` : ''; // Only add '?' if there is a str
+  };
+
+  if (form) {
+    const hasFile = Object.keys(form).some(key => {
+      const {
+        value
+      } = form[key];
+      return isFile(value) || isArrayOfFile(value);
+    });
+    const contentType = req.headers['content-type'] || req.headers['Content-Type'];
+
+    if (hasFile || /multipart\/form-data/i.test(contentType)) {
+      req.body = buildFormData(req.form);
+    } else {
+      req.body = encodeFormOrQuery(form);
+    }
+
+    delete req.form;
+  }
+
+  if (query) {
+    const [baseUrl, oriSearch] = url.split('?');
+    let newStr = '';
+
+    if (oriSearch) {
+      const oriQuery = _qs.default.parse(oriSearch);
+
+      const keysToRemove = Object.keys(query);
+      keysToRemove.forEach(key => delete oriQuery[key]);
+      newStr = _qs.default.stringify(oriQuery, {
+        encode: true
+      });
+    }
+
+    const finalStr = joinSearch(newStr, encodeFormOrQuery(query));
+    req.url = baseUrl + finalStr;
+    delete req.query;
+  }
+
+  return req;
+} // Wrap a http function ( there are otherways to do this, consider this deprecated )
+
+
+function makeHttp(httpFn, preFetch, postFetch) {
+  postFetch = postFetch || (a => a);
+
+  preFetch = preFetch || (a => a);
+
+  return req => {
+    if (typeof req === 'string') {
+      req = {
+        url: req
+      };
+    }
+
+    self.mergeInQueryOrForm(req);
+    req = preFetch(req);
+    return postFetch(httpFn(req));
+  };
+}

package/lib/index.js

@@ -0,0 +1,142 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.helpers = void 0;
+
+var _assign = _interopRequireDefault(require("lodash/assign"));
+
+var _startsWith = _interopRequireDefault(require("lodash/startsWith"));
+
+var _url = _interopRequireDefault(require("url"));
+
+var _http = _interopRequireWildcard(require("./http"));
+
+var _resolver = _interopRequireWildcard(require("./resolver"));
+
+var _subtreeResolver = _interopRequireDefault(require("./subtree-resolver"));
+
+var _interfaces = require("./interfaces");
+
+var _execute = require("./execute");
+
+var _helpers = require("./helpers");
+
+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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+Swagger.http = _http.default;
+Swagger.makeHttp = _http.makeHttp.bind(null, Swagger.http);
+Swagger.resolve = _resolver.default;
+Swagger.resolveSubtree = _subtreeResolver.default;
+Swagger.execute = _execute.execute;
+Swagger.serializeRes = _http.serializeRes;
+Swagger.serializeHeaders = _http.serializeHeaders;
+Swagger.clearCache = _resolver.clearCache;
+Swagger.makeApisTagOperation = _interfaces.makeApisTagOperation;
+Swagger.buildRequest = _execute.buildRequest;
+Swagger.helpers = {
+  opId: _helpers.opId
+};
+Swagger.getBaseUrl = _execute.baseUrl;
+
+function Swagger(url, opts = {}) {
+  // Allow url as a separate argument
+  if (typeof url === 'string') {
+    opts.url = url;
+  } else {
+    opts = url;
+  }
+
+  if (!(this instanceof Swagger)) {
+    return new Swagger(opts);
+  }
+
+  (0, _assign.default)(this, opts);
+  const prom = this.resolve().then(() => {
+    if (!this.disableInterfaces) {
+      (0, _assign.default)(this, Swagger.makeApisTagOperation(this));
+    }
+
+    return this;
+  }); // Expose this instance on the promise that gets returned
+
+  prom.client = this;
+  return prom;
+}
+
+Swagger.prototype = {
+  http: _http.default,
+
+  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(options = {}) {
+    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(obj => {
+      this.originalSpec = this.spec;
+      this.spec = obj.spec;
+      this.errors = obj.errors;
+      return this;
+    });
+  }
+
+};
+
+Swagger.prototype.applyDefaults = function applyDefaults() {
+  const {
+    spec
+  } = this;
+  const specUrl = this.url; // TODO: OAS3: support servers here
+
+  if (specUrl && (0, _startsWith.default)(specUrl, 'http')) {
+    const parsed = _url.default.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
+
+
+const {
+  helpers
+} = Swagger;
+exports.helpers = helpers;
+var _default = Swagger;
+exports.default = _default;