@readme/api-core 7.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,18 @@
+Copyright © 2023 ReadMe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# @readme/api-core
+
+<p align="center">
+  <a href="https://npm.im/@readme/api-core"><img src="https://img.shields.io/npm/v/@readme/api-core?style=for-the-badge" alt="NPM Version"></a>
+  <a href="https://npm.im/@readme/api-core"><img src="https://img.shields.io/node/v/@readme/api-core?style=for-the-badge" alt="Node Version"></a>
+  <a href="https://npm.im/@readme/api-core"><img src="https://img.shields.io/npm/l/@readme/api-core?style=for-the-badge" alt="MIT License"></a>
+  <a href="https://github.com/readmeio/api"><img src="https://img.shields.io/github/actions/workflow/status/readmeio/api/ci.yml?branch=main&style=for-the-badge" alt="Build status"></a>
+</p>
+
+<p align="center">
+The magic behind <code>api</code> 🧙
+</p>
+
+<p align="center">
+Check out <a href="https://api.readme.dev">api.readme.dev</a> for more details.
+</p>

package/dist/errors/fetchError.d.ts

@@ -0,0 +1,12 @@
+declare class FetchError<Status = number, Data = unknown> extends Error {
+    /** HTTP Status */
+    status: Status;
+    /** The content of the response. */
+    data: Data;
+    /** The Headers of the response. */
+    headers: Headers;
+    /** The raw `Response` object. */
+    res: Response;
+    constructor(status: Status, data: Data, headers: Headers, res: Response);
+}
+export default FetchError;

package/dist/errors/fetchError.js

@@ -0,0 +1,36 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FetchError = /** @class */ (function (_super) {
+    __extends(FetchError, _super);
+    function FetchError(status, data, headers, res) {
+        var _this = _super.call(this, res.statusText) || this;
+        _this.name = 'FetchError';
+        _this.status = status;
+        _this.data = data;
+        _this.headers = headers;
+        _this.res = res;
+        // We could fix this by updating our target to ES2015 but because we support exporting to CJS
+        // we can't.
+        //
+        // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+        Object.setPrototypeOf(_this, FetchError.prototype);
+        return _this;
+    }
+    return FetchError;
+}(Error));
+exports.default = FetchError;

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import type Oas from 'oas';
+import type { Operation } from 'oas';
+import type { HttpMethods } from 'oas/dist/rmoas.types';
+import getJSONSchemaDefaults from './lib/getJSONSchemaDefaults';
+import parseResponse from './lib/parseResponse';
+import prepareAuth from './lib/prepareAuth';
+import prepareParams from './lib/prepareParams';
+import prepareServer from './lib/prepareServer';
+export interface ConfigOptions {
+    /**
+     * Override the default `fetch` request timeout of 30 seconds. This number should be represented
+     * in milliseconds.
+     */
+    timeout?: number;
+}
+export interface FetchResponse<HTTPStatus, Data> {
+    data: Data;
+    headers: Headers;
+    res: Response;
+    status: HTTPStatus;
+}
+type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
+export type HTTPMethodRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
+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<HTTPStatus extends number = number>(path: string, method: HttpMethods, body?: unknown, metadata?: Record<string, unknown>): Promise<{
+        data: any;
+        status: HTTPStatus;
+        headers: Headers;
+        res: Response;
+    }>;
+    fetchOperation<HTTPStatus extends number = number>(operation: Operation, body?: unknown, metadata?: Record<string, unknown>): Promise<{
+        data: any;
+        status: HTTPStatus;
+        headers: Headers;
+        res: Response;
+    }>;
+}

package/dist/index.js

@@ -0,0 +1,164 @@
+"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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareServer = exports.prepareParams = exports.prepareAuth = exports.parseResponse = exports.getJSONSchemaDefaults = void 0;
+var oas_to_har_1 = __importDefault(require("@readme/oas-to-har"));
+var fetch_har_1 = __importDefault(require("fetch-har"));
+var fetchError_1 = __importDefault(require("./errors/fetchError"));
+var getJSONSchemaDefaults_1 = __importDefault(require("./lib/getJSONSchemaDefaults"));
+exports.getJSONSchemaDefaults = getJSONSchemaDefaults_1.default;
+var parseResponse_1 = __importDefault(require("./lib/parseResponse"));
+exports.parseResponse = parseResponse_1.default;
+var prepareAuth_1 = __importDefault(require("./lib/prepareAuth"));
+exports.prepareAuth = prepareAuth_1.default;
+var prepareParams_1 = __importDefault(require("./lib/prepareParams"));
+exports.prepareParams = prepareParams_1.default;
+var prepareServer_1 = __importDefault(require("./lib/prepareServer"));
+exports.prepareServer = prepareServer_1.default;
+var APICore = /** @class */ (function () {
+    function APICore(spec, userAgent) {
+        this.auth = [];
+        this.server = false;
+        this.config = {};
+        if (spec)
+            this.spec = spec;
+        if (userAgent)
+            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;
+                            }
+                        }
+                        // @ts-expect-error `this.auth` typing is off. FIXME
+                        var har = (0, oas_to_har_1.default)(_this.spec, operation, data, (0, prepareAuth_1.default)(_this.auth, operation));
+                        var timeoutSignal;
+                        var init = {};
+                        if (_this.config.timeout) {
+                            var controller_1 = new AbortController();
+                            timeoutSignal = setTimeout(function () { return controller_1.abort(); }, _this.config.timeout);
+                            init.signal = controller_1.signal;
+                        }
+                        return (0, fetch_har_1.default)(har, {
+                            files: data.files || {},
+                            init: init,
+                            userAgent: _this.userAgent,
+                        })
+                            .then(function (res) { return __awaiter(_this, void 0, void 0, function () {
+                            var parsed;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, parseResponse_1.default)(res)];
+                                    case 1:
+                                        parsed = _a.sent();
+                                        if (res.status >= 400 && res.status <= 599) {
+                                            throw new fetchError_1.default(parsed.status, parsed.data, parsed.headers, parsed.res);
+                                        }
+                                        return [2 /*return*/, parsed];
+                                }
+                            });
+                        }); })
+                            .finally(function () {
+                            if (_this.config.timeout) {
+                                clearTimeout(timeoutSignal);
+                            }
+                        });
+                    })];
+            });
+        });
+    };
+    return APICore;
+}());
+exports.default = APICore;

package/dist/lib/getJSONSchemaDefaults.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaWrapper } from 'oas/dist/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}
+ */
+export default function getJSONSchemaDefaults(jsonSchemas: SchemaWrapper[]): {
+    [x: string]: Record<string, unknown>;
+};

package/dist/lib/getJSONSchemaDefaults.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: 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}
+ */
+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 === null || parentSchema === void 0 ? void 0 : parentSchema.required.includes(String(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/lib/parseResponse.d.ts

@@ -0,0 +1,6 @@
+export default function parseResponse<HTTPStatus extends number = number>(response: Response): Promise<{
+    data: any;
+    status: HTTPStatus;
+    headers: Headers;
+    res: Response;
+}>;

package/dist/lib/parseResponse.js

@@ -0,0 +1,71 @@
+"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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var oas_1 = require("oas");
+var matchesMimeType = oas_1.utils.matchesMimeType;
+function parseResponse(response) {
+    return __awaiter(this, void 0, void 0, function () {
+        var contentType, isJSON, responseBody, data;
+        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();
+                    data = responseBody;
+                    if (isJSON) {
+                        try {
+                            data = JSON.parse(responseBody);
+                        }
+                        catch (e) {
+                            // If our JSON parsing failed then we can just return plaintext instead.
+                        }
+                    }
+                    return [2 /*return*/, {
+                            data: data,
+                            status: response.status,
+                            headers: response.headers,
+                            res: response,
+                        }];
+            }
+        });
+    });
+}
+exports.default = parseResponse;

package/dist/lib/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 | {
+    pass: string | number;
+    user: string | number;
+}>;

package/dist/lib/prepareAuth.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function prepareAuth(authKey, operation) {
+    if (authKey.length === 0) {
+        return {};
+    }
+    var preparedAuth = {};
+    var security = operation.getSecurity();
+    if (security.length === 0) {
+        // If there's no auth configured on this operation, don't prepare anything (even if it was
+        // supplied by the user).
+        return {};
+    }
+    // Does this operation require multiple forms of auth?
+    if (security.every(function (s) { return Object.keys(s).length > 1; })) {
+        throw new Error("Sorry, this operation currently requires multiple forms of authentication which this library doesn't yet support.");
+    }
+    // Since we can only handle single auth security configurations, let's pull those out. This code
+    // is a bit opaque but `security` here may look like `[{ basic: [] }, { oauth2: [], basic: []}]`
+    // and are filtering it down to only single-auth requirements of `[{ basic: [] }]`.
+    var usableSecurity = security
+        .map(function (s) {
+        return Object.keys(s).length === 1 ? s : false;
+    })
+        .filter(Boolean);
+    var usableSecuritySchemes = usableSecurity.map(function (s) { return Object.keys(s); }).reduce(function (prev, next) { return prev.concat(next); }, []);
+    var preparedSecurity = operation.prepareSecurity();
+    // If we have two auth tokens present let's look for Basic Auth in their configuration.
+    if (authKey.length >= 2) {
+        // If this operation doesn't support HTTP Basic auth but we have two tokens, that's a paddlin.
+        if (!('Basic' in preparedSecurity)) {
+            throw new Error('Multiple auth tokens were supplied for this endpoint but only a single token is needed.');
+        }
+        // If we have two auth keys for Basic Auth but Basic isn't a usable security scheme (maybe it's
+        // part of an AND or auth configuration -- which we don't support) then we need to error out.
+        var schemes_1 = preparedSecurity.Basic.filter(function (s) { return usableSecuritySchemes.includes(s._key); });
+        if (!schemes_1.length) {
+            throw new Error('Credentials for Basic Authentication were supplied but this operation requires another form of auth in that case, which this library does not yet support. This operation does, however, allow supplying a single auth token.');
+        }
+        var scheme_1 = schemes_1.shift();
+        preparedAuth[scheme_1._key] = {
+            user: authKey[0],
+            pass: authKey.length === 2 ? authKey[1] : '',
+        };
+        return preparedAuth;
+    }
+    // If we know we don't need to use HTTP Basic auth because we have a username+password then we
+    // can pick the first usable security scheme available and try to use that. This might not always
+    // be the auth scheme that the user wants, but we don't have any other way for the user to tell
+    // us what they want with the current `sdk.auth()` API.
+    var usableScheme = usableSecuritySchemes[0];
+    var schemes = Object.entries(preparedSecurity)
+        .map(function (_a) {
+        var ps = _a[1];
+        return ps.filter(function (s) { return usableScheme === s._key; });
+    })
+        .reduce(function (prev, next) { return prev.concat(next); }, []);
+    var scheme = schemes.shift();
+    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') {
+                preparedAuth[scheme._key] = authKey[0];
+            }
+            break;
+        case 'oauth2':
+            preparedAuth[scheme._key] = authKey[0];
+            break;
+        case 'apiKey':
+            if (scheme.in === 'query' || scheme.in === 'header' || scheme.in === 'cookie') {
+                preparedAuth[scheme._key] = authKey[0];
+            }
+            break;
+        default:
+            throw new Error("Sorry, this API currently uses a security scheme, ".concat(scheme.type, ", which this library doesn't yet support."));
+    }
+    return preparedAuth;
+}
+exports.default = prepareAuth;

package/dist/lib/prepareParams.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import type { Operation } from 'oas';
+/**
+ * With potentially supplied body and/or metadata we need to run through them against a given API
+ * operation to see what's what and prepare any available parameters to be used in an API request
+ * with `@readme/oas-to-har`.
+ *
+ */
+export default function prepareParams(operation: Operation, body?: unknown, metadata?: Record<string, unknown>): Promise<{
+    body?: any;
+    cookie?: Record<string, string | number | boolean> | undefined;
+    files?: Record<string, Buffer> | undefined;
+    formData?: any;
+    header?: Record<string, string | number | boolean> | undefined;
+    path?: Record<string, string | number | boolean> | undefined;
+    query?: Record<string, string | number | boolean> | undefined;
+    server?: {
+        selected: number;
+        variables: Record<string, string | number>;
+    } | undefined;
+}>;