api 4.5.1 → 5.0.0-beta.2

package/dist/cli/storage.js

@@ -0,0 +1,264 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var ssri_1 = __importDefault(require("ssri"));
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var make_dir_1 = __importDefault(require("make-dir"));
+var packageInfo_1 = require("../packageInfo");
+var fetcher_1 = __importDefault(require("../fetcher"));
+var Storage = /** @class */ (function () {
+    function Storage(source, identifier) {
+        Storage.setStorageDir();
+        this.fetcher = new fetcher_1["default"](source);
+        this.source = source;
+        this.identifier = identifier;
+        // This should default to false so we have awareness if we've looked at the lockfile yet.
+        Storage.lockfile = false;
+    }
+    Storage.getLockfilePath = function () {
+        return path_1["default"].join(Storage.dir, 'api.json');
+    };
+    Storage.getAPIsDir = function () {
+        return path_1["default"].join(Storage.dir, 'apis');
+    };
+    Storage.setStorageDir = function (dir) {
+        if (dir) {
+            Storage.dir = dir;
+            return;
+        }
+        else if (Storage.dir) {
+            // If we already have a storage dir set and aren't explicitly it to something new then we
+            // shouldn't overwrite what we've already got.
+            return;
+        }
+        Storage.dir = make_dir_1["default"].sync(path_1["default"].join(process.cwd(), '.api'));
+        make_dir_1["default"].sync(Storage.getAPIsDir());
+    };
+    /**
+     * Reset the state of the entire storage system.
+     *
+     * This will completely destroy the contents of the `.api/` directory!
+     */
+    Storage.reset = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Storage.getLockfilePath()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, fs_1["default"].promises.writeFile(Storage.getLockfilePath(), JSON.stringify(Storage.getDefaultLockfile(), null, 2))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!Storage.getAPIsDir()) return [3 /*break*/, 5];
+                        return [4 /*yield*/, fs_1["default"].promises.rm(Storage.getAPIsDir(), { recursive: true })];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, fs_1["default"].promises.mkdir(Storage.getAPIsDir(), { recursive: true })];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Storage.getDefaultLockfile = function () {
+        return {
+            version: '1.0',
+            apis: []
+        };
+    };
+    Storage.generateIntegrityHash = function (definition) {
+        return ssri_1["default"]
+            .fromData(JSON.stringify(definition), {
+            algorithms: ['sha512']
+        })
+            .toString();
+    };
+    Storage.getLockfile = function () {
+        if (typeof Storage.lockfile === 'object') {
+            return Storage.lockfile;
+        }
+        if (fs_1["default"].existsSync(Storage.getLockfilePath())) {
+            var file = fs_1["default"].readFileSync(Storage.getLockfilePath(), 'utf8');
+            Storage.lockfile = JSON.parse(file);
+        }
+        else {
+            Storage.lockfile = Storage.getDefaultLockfile();
+        }
+        return Storage.lockfile;
+    };
+    Storage.isInLockFile = function (search) {
+        // Because this method may run before we initialize a new storage object we should make sure
+        // that we have a storage directory present.
+        Storage.setStorageDir();
+        if (!search.identifier && !search.source) {
+            throw new TypeError('An `identifier` or `source` must be supplied to this method to search in the lockfile.');
+        }
+        var lockfile = Storage.getLockfile();
+        if (typeof lockfile !== 'object' || lockfile === null || !lockfile.apis) {
+            return false;
+        }
+        var res = lockfile.apis.find(function (a) {
+            if (search.identifier) {
+                return a.identifier === search.identifier;
+            }
+            return a.source === search.source;
+        });
+        return res === undefined ? false : res;
+    };
+    Storage.prototype.setIdentifier = function (identifier) {
+        this.identifier = identifier;
+    };
+    /**
+     * Determine if the current spec + identifier we're working with is already in the lockfile.
+     */
+    Storage.prototype.isInLockfile = function () {
+        return Boolean(this.getFromLockfile());
+    };
+    /**
+     * Retrieve the lockfile record for the current spec + identifier if it exists in the lockfile.
+     */
+    Storage.prototype.getFromLockfile = function () {
+        var _this = this;
+        var lockfile = Storage.getLockfile();
+        return lockfile.apis.find(function (a) { return a.identifier === _this.identifier; });
+    };
+    Storage.prototype.getIdentifierStorageDir = function () {
+        if (!this.isInLockfile()) {
+            throw new Error("".concat(this.source, " has not been saved to storage yet and must do so before being retrieved."));
+        }
+        return path_1["default"].join(Storage.getAPIsDir(), this.identifier);
+    };
+    Storage.prototype.getAPIDefinition = function () {
+        var file = fs_1["default"].readFileSync(path_1["default"].join(this.getIdentifierStorageDir(), 'openapi.json'), 'utf8');
+        return JSON.parse(file);
+    };
+    Storage.prototype.saveSourceFiles = function (files) {
+        var _this = this;
+        if (!this.isInLockfile()) {
+            throw new Error("".concat(this.source, " has not been saved to storage yet and must do so before being retrieved."));
+        }
+        return new Promise(function (resolve) {
+            var savedSource = [];
+            Object.entries(files).forEach(function (_a) {
+                var fileName = _a[0], contents = _a[1];
+                var sourceFilePath = path_1["default"].join(_this.getIdentifierStorageDir(), fileName);
+                fs_1["default"].writeFileSync(sourceFilePath, contents);
+                savedSource.push(sourceFilePath);
+            });
+            resolve(savedSource);
+        });
+    };
+    Storage.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetcher.load().then(function (spec) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, this.save(spec)];
+                    }); }); })];
+            });
+        });
+    };
+    /**
+     * @example <caption>Storage directory structure</caption>
+     * .api/
+     * ├── api.json             // The `package-lock.json` equivalent that records everything that's
+     * |                        // installed, when it was installed, what the original source was,
+     * |                        // and what version of `api` was used.
+     * └── apis/
+     *     ├── readme/
+     *     |   ├── node_modules/
+     *     │   ├── index.js     // We may offer the option to export a raw TS file for folks who want
+     *     |   |                // that, but for now it'll be a compiled JS file.
+     *     │   ├── index.d.ts   // All types for their SDK, ready to use in an IDE.
+     *     │   |── openapi.json
+     *     │   └── package.json
+     *     └── petstore/
+     *         ├── node_modules/
+     *         ├── index.js
+     *         ├── index.d.ts
+     *         ├── openapi.json
+     *         └── package.json
+     *
+     * @param spec
+     */
+    Storage.prototype.save = function (spec) {
+        if (!this.identifier) {
+            throw new TypeError('An identifier must be set before saving the API definition into storage.');
+        }
+        // Create our main `.api/` directory.
+        if (!fs_1["default"].existsSync(Storage.dir)) {
+            fs_1["default"].mkdirSync(Storage.dir, { recursive: true });
+        }
+        // Create the `.api/apis/` diretory where we'll be storing API definitions.
+        if (!fs_1["default"].existsSync(Storage.getAPIsDir())) {
+            fs_1["default"].mkdirSync(Storage.getAPIsDir(), { recursive: true });
+        }
+        if (!this.isInLockfile()) {
+            // This API doesn't exist within our storage system yet so we need to record it in the
+            // lockfile.
+            var identifierStorageDir = path_1["default"].join(Storage.getAPIsDir(), this.identifier);
+            var saved = JSON.stringify(spec, null, 2);
+            // Create the `.api/apis/<identifier>` directory where we'll be storing this API definition
+            // and eventually its codegen'd SDK.
+            if (!fs_1["default"].existsSync(identifierStorageDir)) {
+                fs_1["default"].mkdirSync(identifierStorageDir, { recursive: true });
+            }
+            Storage.lockfile.apis.push({
+                identifier: this.identifier,
+                source: this.source,
+                integrity: Storage.generateIntegrityHash(spec),
+                installerVersion: packageInfo_1.PACKAGE_VERSION
+            });
+            fs_1["default"].writeFileSync(path_1["default"].join(identifierStorageDir, 'openapi.json'), saved);
+            fs_1["default"].writeFileSync(Storage.getLockfilePath(), JSON.stringify(Storage.lockfile, null, 2));
+        }
+        else {
+            // Is this the same spec that we already have? Should we update it? // @todo
+        }
+        return spec;
+    };
+    return Storage;
+}());
+exports["default"] = Storage;

package/dist/core/getJSONSchemaDefaults.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaWrapper } from 'oas/@types/operation/get-parameters-as-json-schema';
+/**
+ * Run through a JSON Schema object and compose up an object containing default data for any schema
+ * property that is required and also has a defined default.
+ *
+ * Code partially adapted from the `json-schema-default` package but modified to only return
+ * defaults of required properties.
+ *
+ * @todo This is a good candidate to be moved into a core `oas` library method.
+ * @see {@link https://github.com/mdornseif/json-schema-default}
+ * @param jsonSchemas
+ */
+export default function getJSONSchemaDefaults(jsonSchemas: SchemaWrapper[]): {
+    [x: string]: Record<string, unknown>;
+};

package/dist/core/getJSONSchemaDefaults.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var json_schema_traverse_1 = __importDefault(require("json-schema-traverse"));
+/**
+ * Run through a JSON Schema object and compose up an object containing default data for any schema
+ * property that is required and also has a defined default.
+ *
+ * Code partially adapted from the `json-schema-default` package but modified to only return
+ * defaults of required properties.
+ *
+ * @todo This is a good candidate to be moved into a core `oas` library method.
+ * @see {@link https://github.com/mdornseif/json-schema-default}
+ * @param jsonSchemas
+ */
+function getJSONSchemaDefaults(jsonSchemas) {
+    return jsonSchemas
+        .map(function (_a) {
+        var _b;
+        var payloadType = _a.type, jsonSchema = _a.schema;
+        var defaults = {};
+        (0, json_schema_traverse_1["default"])(jsonSchema, function (schema, pointer, rootSchema, parentPointer, parentKeyword, parentSchema, indexProperty) {
+            if (!pointer.startsWith('/properties/')) {
+                return;
+            }
+            if (Array.isArray(parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.required) && parentSchema.required.includes(indexProperty)) {
+                if (schema.type === 'object' && indexProperty) {
+                    defaults[indexProperty] = {};
+                }
+                var destination_1 = defaults;
+                if (parentPointer) {
+                    // To map nested objects correct we need to pick apart the parent pointer.
+                    parentPointer
+                        .replace(/\/properties/g, '')
+                        .split('/')
+                        .forEach(function (subSchema) {
+                        if (subSchema === '') {
+                            return;
+                        }
+                        destination_1 = (destination_1 === null || destination_1 === void 0 ? void 0 : destination_1[subSchema]) || {};
+                    });
+                }
+                if (schema["default"] !== undefined) {
+                    if (indexProperty !== undefined) {
+                        destination_1[indexProperty] = schema["default"];
+                    }
+                }
+            }
+        });
+        if (!Object.keys(defaults).length) {
+            return {};
+        }
+        return _b = {},
+            // @todo should we filter out empty and undefined objects from here with `remove-undefined-objects`?
+            _b[payloadType] = defaults,
+            _b;
+    })
+        .reduce(function (prev, next) { return Object.assign(prev, next); });
+}
+exports["default"] = getJSONSchemaDefaults;

package/dist/core/index.d.ts

@@ -0,0 +1,32 @@
+import type Oas from 'oas';
+import type { Operation } from 'oas';
+import type { HttpMethods } from 'oas/@types/rmoas.types';
+import 'isomorphic-fetch';
+import getJSONSchemaDefaults from './getJSONSchemaDefaults';
+import parseResponse from './parseResponse';
+import prepareAuth from './prepareAuth';
+import prepareParams from './prepareParams';
+import prepareServer from './prepareServer';
+export interface ConfigOptions {
+    /**
+     * By default we parse the response based on the `Content-Type` header of the request. You can
+     * disable this functionality by negating this option.
+     */
+    parseResponse: boolean;
+}
+export { getJSONSchemaDefaults, parseResponse, prepareAuth, prepareParams, prepareServer };
+export default class APICore {
+    spec: Oas;
+    private auth;
+    private server;
+    private config;
+    private userAgent;
+    constructor(spec?: Oas, userAgent?: string);
+    setSpec(spec: Oas): void;
+    setConfig(config: ConfigOptions): this;
+    setUserAgent(userAgent: string): this;
+    setAuth(...values: string[] | number[]): this;
+    setServer(url: string, variables?: Record<string, string | number>): this;
+    fetch(path: string, method: HttpMethods, body?: unknown, metadata?: Record<string, unknown>): Promise<any>;
+    fetchOperation(operation: Operation, body?: unknown, metadata?: Record<string, unknown>): Promise<any>;
+}

package/dist/core/index.js

@@ -0,0 +1,143 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.prepareServer = exports.prepareParams = exports.prepareAuth = exports.parseResponse = exports.getJSONSchemaDefaults = void 0;
+require("isomorphic-fetch");
+var fetch_har_1 = __importDefault(require("fetch-har"));
+var oas_to_har_1 = __importDefault(require("@readme/oas-to-har"));
+var form_data_encoder_1 = require("form-data-encoder");
+var getJSONSchemaDefaults_1 = __importDefault(require("./getJSONSchemaDefaults"));
+exports.getJSONSchemaDefaults = getJSONSchemaDefaults_1["default"];
+var parseResponse_1 = __importDefault(require("./parseResponse"));
+exports.parseResponse = parseResponse_1["default"];
+var prepareAuth_1 = __importDefault(require("./prepareAuth"));
+exports.prepareAuth = prepareAuth_1["default"];
+var prepareParams_1 = __importDefault(require("./prepareParams"));
+exports.prepareParams = prepareParams_1["default"];
+var prepareServer_1 = __importDefault(require("./prepareServer"));
+exports.prepareServer = prepareServer_1["default"];
+var APICore = /** @class */ (function () {
+    function APICore(spec, userAgent) {
+        this.auth = [];
+        this.server = false;
+        this.config = { parseResponse: true };
+        this.spec = spec;
+        this.userAgent = userAgent;
+    }
+    APICore.prototype.setSpec = function (spec) {
+        this.spec = spec;
+    };
+    APICore.prototype.setConfig = function (config) {
+        this.config = config;
+        return this;
+    };
+    APICore.prototype.setUserAgent = function (userAgent) {
+        this.userAgent = userAgent;
+        return this;
+    };
+    APICore.prototype.setAuth = function () {
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            values[_i] = arguments[_i];
+        }
+        this.auth = values;
+        return this;
+    };
+    APICore.prototype.setServer = function (url, variables) {
+        if (variables === void 0) { variables = {}; }
+        this.server = { url: url, variables: variables };
+        return this;
+    };
+    APICore.prototype.fetch = function (path, method, body, metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var operation;
+            return __generator(this, function (_a) {
+                operation = this.spec.operation(path, method);
+                return [2 /*return*/, this.fetchOperation(operation, body, metadata)];
+            });
+        });
+    };
+    APICore.prototype.fetchOperation = function (operation, body, metadata) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, prepareParams_1["default"])(operation, body, metadata).then(function (params) {
+                        var data = __assign({}, params);
+                        // If `sdk.server()` has been issued data then we need to do some extra work to figure out
+                        // how to use that supplied server, and also handle any server variables that were sent
+                        // alongside it.
+                        if (_this.server) {
+                            var preparedServer = (0, prepareServer_1["default"])(_this.spec, _this.server.url, _this.server.variables);
+                            if (preparedServer) {
+                                data.server = preparedServer;
+                            }
+                        }
+                        var har = (0, oas_to_har_1["default"])(_this.spec, operation, data, (0, prepareAuth_1["default"])(_this.auth, operation));
+                        return (0, fetch_har_1["default"])(har, {
+                            userAgent: _this.userAgent,
+                            files: data.files || {},
+                            multipartEncoder: form_data_encoder_1.FormDataEncoder
+                        }).then(function (res) {
+                            if (res.status >= 400 && res.status <= 599) {
+                                throw res;
+                            }
+                            if (_this.config.parseResponse === false)
+                                return res;
+                            return (0, parseResponse_1["default"])(res);
+                        });
+                    })];
+            });
+        });
+    };
+    return APICore;
+}());
+exports["default"] = APICore;

package/dist/core/parseResponse.d.ts

@@ -0,0 +1 @@
+export default function getResponseBody(response: Response): Promise<any>;

package/dist/core/parseResponse.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+var oas_1 = require("oas");
+var matchesMimeType = oas_1.utils.matchesMimeType;
+function getResponseBody(response) {
+    return __awaiter(this, void 0, void 0, function () {
+        var contentType, isJSON, responseBody;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    contentType = response.headers.get('Content-Type');
+                    isJSON = contentType && (matchesMimeType.json(contentType) || matchesMimeType.wildcard(contentType));
+                    return [4 /*yield*/, response.text()];
+                case 1:
+                    responseBody = _a.sent();
+                    if (isJSON) {
+                        try {
+                            return [2 /*return*/, JSON.parse(responseBody)];
+                        }
+                        catch (e) {
+                            // If our JSON parsing failed then we can just return plaintext instead.
+                        }
+                    }
+                    return [2 /*return*/, responseBody];
+            }
+        });
+    });
+}
+exports["default"] = getResponseBody;

package/dist/core/prepareAuth.d.ts

@@ -0,0 +1,5 @@
+import type { Operation } from 'oas';
+export default function prepareAuth(authKey: (number | string)[], operation: Operation): Record<string, string | number | {
+    user: string | number;
+    pass: string | number;
+}>;

package/dist/core/prepareAuth.js

@@ -0,0 +1,55 @@
+"use strict";
+exports.__esModule = true;
+function prepareAuth(authKey, operation) {
+    if (authKey.length === 0) {
+        return {};
+    }
+    var preparedAuth = {};
+    var security = operation.prepareSecurity();
+    var securitySchemes = Object.keys(security);
+    if (securitySchemes.length === 0) {
+        // If there's no auth configured on this operation, don't prepare anything (even if it was
+        // supplied by the user).
+        return {};
+    }
+    var securityType = securitySchemes[0];
+    var schemes = security[securityType];
+    if (schemes.length > 1) {
+        throw new Error("Sorry, this API currently requires multiple forms of authentication which we don't yet support.");
+    }
+    var scheme = schemes[0];
+    switch (scheme.type) {
+        case 'http':
+            if (scheme.scheme === 'basic') {
+                preparedAuth[scheme._key] = {
+                    user: authKey[0],
+                    pass: authKey.length === 2 ? authKey[1] : ''
+                };
+            }
+            else if (scheme.scheme === 'bearer') {
+                if (authKey.length > 1) {
+                    throw new Error('Multiple auth tokens were supplied for the auth on this endpoint, but only a single token is needed.');
+                }
+                preparedAuth[scheme._key] = authKey[0];
+            }
+            break;
+        case 'oauth2':
+            if (authKey.length > 1) {
+                throw new Error('Multiple auth tokens were supplied for the auth on this endpoint, but only a single token is needed.');
+            }
+            preparedAuth[scheme._key] = authKey[0];
+            break;
+        case 'apiKey':
+            if (authKey.length > 1) {
+                throw new Error('Multiple auth keys were supplied for the auth on this endpoint, but only a single key is needed.');
+            }
+            if (scheme["in"] === 'query' || scheme["in"] === 'header' || scheme["in"] === 'cookie') {
+                preparedAuth[scheme._key] = authKey[0];
+            }
+            break;
+        default:
+            throw new Error("Sorry, this API currently supports a scheme, ".concat(scheme.type, ", that we don't yet support."));
+    }
+    return preparedAuth;
+}
+exports["default"] = prepareAuth;