swagger-client 3.10.8 → 3.10.12

package/lib/interfaces.js

@@ -0,0 +1,159 @@
+"use strict";
+
+exports.__esModule = true;
+exports.makeExecute = makeExecute;
+exports.makeApisTagOperationsOperationExecute = makeApisTagOperationsOperationExecute;
+exports.makeApisTagOperation = makeApisTagOperation;
+exports.mapTagOperations = mapTagOperations;
+exports.self = void 0;
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _helpers = require("./helpers");
+
+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; }
+
+const nullFn = () => null;
+
+const normalizeArray = arg => {
+  return Array.isArray(arg) ? arg : [arg];
+}; // To allow stubbing of functions
+
+
+const self = {
+  mapTagOperations,
+  makeExecute
+}; // Make an execute, bound to arguments defined in mapTagOperation's callback (cb)
+
+exports.self = self;
+
+function makeExecute(swaggerJs = {}) {
+  return ({
+    pathName,
+    method,
+    operationId
+  }) => (parameters, opts = {}) => {
+    return swaggerJs.execute(_objectSpread(_objectSpread({
+      spec: swaggerJs.spec
+    }, (0, _pick.default)(swaggerJs, 'requestInterceptor', 'responseInterceptor', 'userFetch')), {}, {
+      pathName,
+      method,
+      parameters,
+      operationId
+    }, opts));
+  };
+} // Creates an interface with tags+operations = execute
+// The shape
+// { apis: { [tag]: { operations: [operation]: { execute }}}}
+// NOTE: this is mostly for compatibility
+
+
+function makeApisTagOperationsOperationExecute(swaggerJs = {}) {
+  // { apis: tag: operations: execute }
+  const cb = self.makeExecute(swaggerJs);
+  const tagOperations = self.mapTagOperations({
+    v2OperationIdCompatibilityMode: swaggerJs.v2OperationIdCompatibilityMode,
+    spec: swaggerJs.spec,
+    cb
+  });
+  const apis = {}; // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+  for (const tag in tagOperations) {
+    apis[tag] = {
+      operations: {}
+    }; // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+    for (const op in tagOperations[tag]) {
+      apis[tag].operations[op] = {
+        execute: tagOperations[tag][op]
+      };
+    }
+  }
+
+  return {
+    apis
+  };
+} // .apis[tag][operationId]:ExecuteFunction interface
+
+
+function makeApisTagOperation(swaggerJs = {}) {
+  const cb = self.makeExecute(swaggerJs);
+  return {
+    apis: self.mapTagOperations({
+      v2OperationIdCompatibilityMode: swaggerJs.v2OperationIdCompatibilityMode,
+      spec: swaggerJs.spec,
+      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
+ *
+ */
+
+
+function mapTagOperations({
+  spec,
+  cb = nullFn,
+  defaultTag = 'default',
+  v2OperationIdCompatibilityMode
+}) {
+  const operationIdCounter = {};
+  const tagOperations = {}; // Will house all tags + operations
+
+  (0, _helpers.eachOperation)(spec, ({
+    pathName,
+    method,
+    operation
+  }) => {
+    const tags = operation.tags ? normalizeArray(operation.tags) : [defaultTag];
+    tags.forEach(tag => {
+      if (typeof tag !== 'string') {
+        return;
+      }
+
+      tagOperations[tag] = tagOperations[tag] || {};
+      const tagObj = tagOperations[tag];
+      const id = (0, _helpers.opId)(operation, pathName, method, {
+        v2OperationIdCompatibilityMode
+      });
+      const cbResult = cb({
+        spec,
+        pathName,
+        method,
+        operation,
+        operationId: id
+      });
+
+      if (operationIdCounter[id]) {
+        operationIdCounter[id] += 1;
+        tagObj[`${id}${operationIdCounter[id]}`] = cbResult;
+      } else if (typeof tagObj[id] !== 'undefined') {
+        // Bump counter ( for this operationId )
+        const originalCounterValue = operationIdCounter[id] || 1;
+        operationIdCounter[id] = originalCounterValue + 1; // Append _x to the operationId
+
+        tagObj[`${id}${operationIdCounter[id]}`] = cbResult; // Rename the first operationId
+
+        const temp = tagObj[id];
+        delete tagObj[id];
+        tagObj[`${id}${originalCounterValue}`] = temp;
+      } else {
+        // Assign callback result ( usually a bound function )
+        tagObj[id] = cbResult;
+      }
+    });
+  });
+  return tagOperations;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.patch = void 0;
+
+var _isFunction = _interopRequireDefault(require("lodash/isFunction"));
+
+var _isomorphicFormData = _interopRequireDefault(require("isomorphic-form-data"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// patches FormData type by mutating it.
+// patch :: FormData -> PatchedFormData
+const patch = FormData => {
+  const createEntry = (field, value) => ({
+    name: field,
+    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 ((0, _isFunction.default)(FormData.prototype.set) || (0, _isFunction.default)(FormData.prototype.get) || (0, _isFunction.default)(FormData.prototype.getAll) || (0, _isFunction.default)(FormData.prototype.has)) {
+    return FormData;
+  }
+
+  class PatchedFormData extends FormData {
+    constructor(form) {
+      super(form);
+      this.entryList = [];
+    }
+
+    append(field, value, options) {
+      this.entryList.push(createEntry(field, value));
+      return super.append(field, value, options);
+    }
+
+    set(field, value) {
+      const newEntry = createEntry(field, value);
+      this.entryList = this.entryList.filter(entry => {
+        return entry.name !== field;
+      });
+      this.entryList.push(newEntry);
+    }
+
+    get(field) {
+      const foundEntry = this.entryList.find(entry => {
+        return entry.name === field;
+      });
+      return foundEntry === undefined ? null : foundEntry;
+    }
+
+    getAll(field) {
+      return this.entryList.filter(entry => {
+        return entry.name === field;
+      }).map(entry => {
+        return entry.value;
+      });
+    }
+
+    has(field) {
+      return this.entryList.some(entry => {
+        return entry.name === field;
+      });
+    }
+
+  }
+
+  return PatchedFormData;
+};
+
+exports.patch = patch;
+
+var _default = patch(_isomorphicFormData.default);
+
+exports.default = _default;

package/lib/resolver.js

@@ -0,0 +1,125 @@
+"use strict";
+
+exports.__esModule = true;
+exports.makeFetchJSON = makeFetchJSON;
+exports.clearCache = clearCache;
+exports.default = resolve;
+
+var _http = _interopRequireDefault(require("./http"));
+
+var _specmap = _interopRequireWildcard(require("./specmap"));
+
+var _helpers = require("./helpers");
+
+var _constants = require("./constants");
+
+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 makeFetchJSON(http, opts = {}) {
+  const {
+    requestInterceptor,
+    responseInterceptor
+  } = opts; // Set credentials with 'http.withCredentials' value
+
+  const credentials = http.withCredentials ? 'include' : 'same-origin';
+  return docPath => {
+    return http({
+      url: docPath,
+      loadSpec: true,
+      requestInterceptor,
+      responseInterceptor,
+      headers: {
+        Accept: _constants.ACCEPT_HEADER_VALUE_FOR_DOCUMENTS
+      },
+      credentials
+    }).then(res => {
+      return res.body;
+    });
+  };
+} // Wipe out the http cache
+
+
+function clearCache() {
+  _specmap.plugins.refs.clearCache();
+}
+
+function resolve(obj) {
+  const {
+    fetch,
+    spec,
+    url,
+    mode,
+    allowMetaPatches = true,
+    pathDiscriminator,
+    modelPropertyMacro,
+    parameterMacro,
+    requestInterceptor,
+    responseInterceptor,
+    skipNormalization,
+    useCircularStructures
+  } = obj;
+  let {
+    http,
+    baseDoc
+  } = obj; // @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.default;
+
+  if (!spec) {
+    return makeFetchJSON(http, {
+      requestInterceptor,
+      responseInterceptor
+    })(baseDoc).then(doResolve);
+  }
+
+  return doResolve(spec);
+
+  function doResolve(_spec) {
+    if (baseDoc) {
+      _specmap.plugins.refs.docCache[baseDoc] = _spec;
+    } // Build a json-fetcher ( ie: give it a URL and get json out )
+
+
+    _specmap.plugins.refs.fetchJSON = makeFetchJSON(http, {
+      requestInterceptor,
+      responseInterceptor
+    });
+    const plugs = [_specmap.plugins.refs];
+
+    if (typeof parameterMacro === 'function') {
+      plugs.push(_specmap.plugins.parameters);
+    }
+
+    if (typeof modelPropertyMacro === 'function') {
+      plugs.push(_specmap.plugins.properties);
+    }
+
+    if (mode !== 'strict') {
+      plugs.push(_specmap.plugins.allOf);
+    } // mapSpec is where the hard work happens, see https://github.com/swagger-api/specmap for more details
+
+
+    return (0, _specmap.default)({
+      spec: _spec,
+      context: {
+        baseDoc
+      },
+      plugins: plugs,
+      allowMetaPatches,
+      // allows adding .meta patches, which include adding `$$ref`s to the spec
+      pathDiscriminator,
+      // for lazy resolution
+      parameterMacro,
+      modelPropertyMacro,
+      useCircularStructures
+    }).then(skipNormalization ? async a => a : _helpers.normalizeSwagger);
+  }
+}

package/lib/specmap/helpers.js

@@ -0,0 +1,65 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isFreelyNamed = isFreelyNamed;
+exports.generateAbsoluteRefPatches = generateAbsoluteRefPatches;
+exports.absolutifyPointer = absolutifyPointer;
+
+var _traverse = _interopRequireDefault(require("traverse"));
+
+var _url = _interopRequireDefault(require("url"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// This will match if the direct parent's key exactly matches an item.
+const freelyNamedKeyParents = ['properties']; // This will match if the grandparent's key exactly matches an item.
+// NOTE that this is for finding non-free paths!
+
+const 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"]`
+
+const 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.
+
+const freelyNamedAncestors = ['schema/example', 'items/example'];
+
+function isFreelyNamed(parentPath) {
+  const parentKey = parentPath[parentPath.length - 1];
+  const grandparentKey = parentPath[parentPath.length - 2];
+  const parentStr = parentPath.join('/');
+  return (// eslint-disable-next-line max-len
+    freelyNamedKeyParents.indexOf(parentKey) > -1 && nonFreelyNamedKeyGrandparents.indexOf(grandparentKey) === -1 || freelyNamedPaths.indexOf(parentStr) > -1 || freelyNamedAncestors.some(el => parentStr.indexOf(el) > -1)
+  );
+}
+
+function generateAbsoluteRefPatches(obj, basePath, {
+  specmap,
+  getBaseUrlForNodePath = path => specmap.getContext([...basePath, ...path]).baseDoc,
+  targetKeys = ['$ref', '$$ref']
+} = {}) {
+  const patches = [];
+  (0, _traverse.default)(obj).forEach(function callback() {
+    if (targetKeys.indexOf(this.key) > -1) {
+      const nodePath = this.path; // this node's path, relative to `obj`
+
+      const fullPath = basePath.concat(this.path);
+      const absolutifiedRefValue = absolutifyPointer(this.node, getBaseUrlForNodePath(nodePath));
+      patches.push(specmap.replace(fullPath, absolutifiedRefValue));
+    }
+  });
+  return patches;
+}
+
+function absolutifyPointer(pointer, baseUrl) {
+  const [urlPart, fragmentPart] = pointer.split('#');
+
+  const newRefUrlPart = _url.default.resolve(urlPart || '', baseUrl || '');
+
+  return fragmentPart ? `${newRefUrlPart}#${fragmentPart}` : newRefUrlPart;
+}