@readme/api-core 7.0.0-alpha.1 → 7.0.0-alpha.3

package/dist/errors/fetchError.js

@@ -1,36 +1,26 @@
 "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;
+class FetchError extends Error {
+    /** HTTP Status */
+    status;
+    /** The content of the response. */
+    data;
+    /** The Headers of the response. */
+    headers;
+    /** The raw `Response` object. */
+    res;
+    constructor(status, data, headers, res) {
+        super(res.statusText);
+        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;
+        Object.setPrototypeOf(this, FetchError.prototype);
     }
-    return FetchError;
-}(Error));
+}
 exports.default = FetchError;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type Oas from 'oas';
-import type { Operation } from 'oas';
-import type { HttpMethods } from 'oas/dist/rmoas.types';
+import type Operation from 'oas/operation';
+import type { HttpMethods } from 'oas/rmoas.types';
 import getJSONSchemaDefaults from './lib/getJSONSchemaDefaults';
 import parseResponse from './lib/parseResponse';
 import prepareAuth from './lib/prepareAuth';

package/dist/index.js

@@ -1,164 +1,96 @@
 "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"));
+const oas_to_har_1 = __importDefault(require("@readme/oas-to-har"));
+const fetch_har_1 = __importDefault(require("fetch-har"));
+const fetchError_1 = __importDefault(require("./errors/fetchError"));
+const getJSONSchemaDefaults_1 = __importDefault(require("./lib/getJSONSchemaDefaults"));
 exports.getJSONSchemaDefaults = getJSONSchemaDefaults_1.default;
-var parseResponse_1 = __importDefault(require("./lib/parseResponse"));
+const parseResponse_1 = __importDefault(require("./lib/parseResponse"));
 exports.parseResponse = parseResponse_1.default;
-var prepareAuth_1 = __importDefault(require("./lib/prepareAuth"));
+const prepareAuth_1 = __importDefault(require("./lib/prepareAuth"));
 exports.prepareAuth = prepareAuth_1.default;
-var prepareParams_1 = __importDefault(require("./lib/prepareParams"));
+const prepareParams_1 = __importDefault(require("./lib/prepareParams"));
 exports.prepareParams = prepareParams_1.default;
-var prepareServer_1 = __importDefault(require("./lib/prepareServer"));
+const 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 = {};
+class APICore {
+    spec;
+    auth = [];
+    server = false;
+    config = {};
+    userAgent;
+    constructor(spec, userAgent) {
         if (spec)
             this.spec = spec;
         if (userAgent)
             this.userAgent = userAgent;
     }
-    APICore.prototype.setSpec = function (spec) {
+    setSpec(spec) {
         this.spec = spec;
-    };
-    APICore.prototype.setConfig = function (config) {
+    }
+    setConfig(config) {
         this.config = config;
         return this;
-    };
-    APICore.prototype.setUserAgent = function (userAgent) {
+    }
+    setUserAgent(userAgent) {
         this.userAgent = userAgent;
         return this;
-    };
-    APICore.prototype.setAuth = function () {
-        var values = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            values[_i] = arguments[_i];
-        }
+    }
+    setAuth(...values) {
         this.auth = values;
         return this;
-    };
-    APICore.prototype.setServer = function (url, variables) {
-        if (variables === void 0) { variables = {}; }
-        this.server = { url: url, variables: variables };
+    }
+    setServer(url, variables = {}) {
+        this.server = { url, 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);
-                            }
-                        });
-                    })];
+    }
+    async fetch(path, method, body, metadata) {
+        const operation = this.spec.operation(path, method);
+        return this.fetchOperation(operation, body, metadata);
+    }
+    async fetchOperation(operation, body, metadata) {
+        return (0, prepareParams_1.default)(operation, body, metadata).then(params => {
+            const data = { ...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) {
+                const 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
+            const har = (0, oas_to_har_1.default)(this.spec, operation, data, (0, prepareAuth_1.default)(this.auth, operation));
+            let timeoutSignal;
+            const init = {};
+            if (this.config.timeout) {
+                const controller = new AbortController();
+                timeoutSignal = setTimeout(() => controller.abort(), this.config.timeout);
+                init.signal = controller.signal;
+            }
+            return (0, fetch_har_1.default)(har, {
+                files: data.files || {},
+                init,
+                userAgent: this.userAgent,
+            })
+                .then(async (res) => {
+                const parsed = await (0, parseResponse_1.default)(res);
+                if (res.status >= 400 && res.status <= 599) {
+                    throw new fetchError_1.default(parsed.status, parsed.data, parsed.headers, parsed.res);
+                }
+                return parsed;
+            })
+                .finally(() => {
+                if (this.config.timeout) {
+                    clearTimeout(timeoutSignal);
+                }
             });
         });
-    };
-    return APICore;
-}());
+    }
+}
 exports.default = APICore;

package/dist/lib/getJSONSchemaDefaults.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaWrapper } from 'oas/dist/operation/get-parameters-as-json-schema';
+import type { SchemaWrapper } from 'oas/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.

package/dist/lib/getJSONSchemaDefaults.js

@@ -3,7 +3,7 @@ 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"));
+const 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.
@@ -16,34 +16,32 @@ var json_schema_traverse_1 = __importDefault(require("json-schema-traverse"));
  */
 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) {
+        .map(({ type: payloadType, schema: jsonSchema }) => {
+        const defaults = {};
+        (0, json_schema_traverse_1.default)(jsonSchema, (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 (Array.isArray(parentSchema?.required) && parentSchema?.required.includes(String(indexProperty))) {
                 if (schema.type === 'object' && indexProperty) {
                     defaults[indexProperty] = {};
                 }
-                var destination_1 = defaults;
+                let destination = defaults;
                 if (parentPointer) {
                     // To map nested objects correct we need to pick apart the parent pointer.
                     parentPointer
                         .replace(/\/properties/g, '')
                         .split('/')
-                        .forEach(function (subSchema) {
+                        .forEach((subSchema) => {
                         if (subSchema === '') {
                             return;
                         }
-                        destination_1 = (destination_1 === null || destination_1 === void 0 ? void 0 : destination_1[subSchema]) || {};
+                        destination = destination?.[subSchema] || {};
                     });
                 }
                 if (schema.default !== undefined) {
                     if (indexProperty !== undefined) {
-                        destination_1[indexProperty] = schema.default;
+                        destination[indexProperty] = schema.default;
                     }
                 }
             }
@@ -51,11 +49,11 @@ function getJSONSchemaDefaults(jsonSchemas) {
         if (!Object.keys(defaults).length) {
             return {};
         }
-        return _b = {},
+        return {
             // @todo should we filter out empty and undefined objects from here with `remove-undefined-objects`?
-            _b[payloadType] = defaults,
-            _b;
+            [payloadType]: defaults,
+        };
     })
-        .reduce(function (prev, next) { return Object.assign(prev, next); });
+        .reduce((prev, next) => Object.assign(prev, next));
 }
 exports.default = getJSONSchemaDefaults;

package/dist/lib/parseResponse.js

@@ -1,71 +1,25 @@
 "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,
-                        }];
-            }
-        });
-    });
+const utils_1 = require("oas/utils");
+async function parseResponse(response) {
+    const contentType = response.headers.get('Content-Type');
+    const isJSON = contentType && (utils_1.matchesMimeType.json(contentType) || utils_1.matchesMimeType.wildcard(contentType));
+    const responseBody = await response.text();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let data = responseBody;
+    if (isJSON) {
+        try {
+            data = JSON.parse(responseBody);
+        }
+        catch (e) {
+            // If our JSON parsing failed then we can just return plaintext instead.
+        }
+    }
+    return {
+        data,
+        status: response.status,
+        headers: response.headers,
+        res: response,
+    };
 }
 exports.default = parseResponse;

package/dist/lib/prepareAuth.d.ts

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

package/dist/lib/prepareAuth.js

@@ -4,27 +4,27 @@ function prepareAuth(authKey, operation) {
     if (authKey.length === 0) {
         return {};
     }
-    var preparedAuth = {};
-    var security = operation.getSecurity();
+    const preparedAuth = {};
+    const 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; })) {
+    if (security.every(s => 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) {
+    const usableSecurity = security
+        .map(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();
+    const usableSecuritySchemes = usableSecurity.map(s => Object.keys(s)).reduce((prev, next) => prev.concat(next), []);
+    const 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.
@@ -33,12 +33,12 @@ function prepareAuth(authKey, operation) {
         }
         // 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) {
+        const schemes = preparedSecurity.Basic.filter(s => usableSecuritySchemes.includes(s._key));
+        if (!schemes.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] = {
+        const scheme = schemes.shift();
+        preparedAuth[scheme._key] = {
             user: authKey[0],
             pass: authKey.length === 2 ? authKey[1] : '',
         };
@@ -48,14 +48,11 @@ function prepareAuth(authKey, operation) {
     // 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();
+    const usableScheme = usableSecuritySchemes[0];
+    const schemes = Object.entries(preparedSecurity)
+        .map(([, ps]) => ps.filter(s => usableScheme === s._key))
+        .reduce((prev, next) => prev.concat(next), []);
+    const scheme = schemes.shift();
     switch (scheme.type) {
         case 'http':
             if (scheme.scheme === 'basic') {
@@ -77,7 +74,7 @@ function prepareAuth(authKey, operation) {
             }
             break;
         default:
-            throw new Error("Sorry, this API currently uses a security scheme, ".concat(scheme.type, ", which this library doesn't yet support."));
+            throw new Error(`Sorry, this API currently uses a security scheme, ${scheme.type}, which this library doesn't yet support.`);
     }
     return preparedAuth;
 }

package/dist/lib/prepareParams.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { Operation } from 'oas';
+import type Operation from 'oas/operation';
 /**
  * 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