api 5.0.0-beta.2 → 5.0.0

package/dist/cli/commands/install.js

@@ -40,15 +40,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 exports.__esModule = true;
 var commander_1 = require("commander");
-var ora_1 = __importDefault(require("ora"));
+var figures_1 = __importDefault(require("figures"));
 var oas_1 = __importDefault(require("oas"));
-var codegen_1 = __importDefault(require("../codegen"));
+var ora_1 = __importDefault(require("ora"));
+var validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
 var fetcher_1 = __importDefault(require("../../fetcher"));
-var storage_1 = __importDefault(require("../storage"));
-var logger_1 = __importDefault(require("../logger"));
+var codegen_1 = __importDefault(require("../codegen"));
 var prompt_1 = __importDefault(require("../lib/prompt"));
-var figures_1 = __importDefault(require("figures"));
-var validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
+var logger_1 = __importDefault(require("../logger"));
+var storage_1 = __importDefault(require("../storage"));
 // @todo log logs to `.api/.logs` and have `.logs` ignored
 var cmd = new commander_1.Command();
 cmd

package/dist/cli/storage.d.ts

@@ -1,4 +1,4 @@
-import type { OASDocument } from 'oas/@types/rmoas.types';
+import type { OASDocument } from 'oas/dist/rmoas.types';
 import Fetcher from '../fetcher';
 export default class Storage {
     static dir: string;

package/dist/cli/storage.js

@@ -39,12 +39,12 @@ 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 ssri_1 = __importDefault(require("ssri"));
 var fetcher_1 = __importDefault(require("../fetcher"));
+var packageInfo_1 = require("../packageInfo");
 var Storage = /** @class */ (function () {
     function Storage(source, identifier) {
         Storage.setStorageDir();

package/dist/core/errors/fetchError.d.ts

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

package/dist/core/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 __());
+    };
+})();
+exports.__esModule = 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/core/getJSONSchemaDefaults.d.ts

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

package/dist/core/index.d.ts

@@ -1,6 +1,6 @@
 import type Oas from 'oas';
 import type { Operation } from 'oas';
-import type { HttpMethods } from 'oas/@types/rmoas.types';
+import type { HttpMethods } from 'oas/dist/rmoas.types';
 import 'isomorphic-fetch';
 import getJSONSchemaDefaults from './getJSONSchemaDefaults';
 import parseResponse from './parseResponse';
@@ -9,11 +9,19 @@ 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.
+     * Override the default `fetch` request timeout of 30 seconds. This number should be represented
+     * in milliseconds.
      */
-    parseResponse: boolean;
+    timeout?: number;
 }
+export declare type FetchResponse<status, data> = {
+    data: data;
+    status: status;
+    headers: Headers;
+    res: Response;
+};
+declare type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
+export declare 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;

package/dist/core/index.js

@@ -51,10 +51,13 @@ var __importDefault = (this && this.__importDefault) || function (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 fetch_har_1 = __importDefault(require("fetch-har"));
 var form_data_encoder_1 = require("form-data-encoder");
+require("isomorphic-fetch");
+// `AbortController` was shipped in Node 15 so when Node 14 is EOL'd we can drop this dependency.
+var node_abort_controller_1 = require("node-abort-controller");
+var fetchError_1 = __importDefault(require("./errors/fetchError"));
 var getJSONSchemaDefaults_1 = __importDefault(require("./getJSONSchemaDefaults"));
 exports.getJSONSchemaDefaults = getJSONSchemaDefaults_1["default"];
 var parseResponse_1 = __importDefault(require("./parseResponse"));
@@ -69,7 +72,7 @@ var APICore = /** @class */ (function () {
     function APICore(spec, userAgent) {
         this.auth = [];
         this.server = false;
-        this.config = { parseResponse: true };
+        this.config = {};
         this.spec = spec;
         this.userAgent = userAgent;
     }
@@ -121,18 +124,40 @@ var APICore = /** @class */ (function () {
                                 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 node_abort_controller_1.AbortController();
+                            timeoutSignal = setTimeout(function () { return controller_1.abort(); }, _this.config.timeout);
+                            // @todo Typing on `AbortController` coming out of `node-abort-controler` isn't right so when
+                            // we eventually drop that dependency we can remove the `as any` here.
+                            init.signal = controller_1.signal;
+                        }
                         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;
+                            init: init,
+                            multipartEncoder: form_data_encoder_1.FormDataEncoder,
+                            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);
                             }
-                            if (_this.config.parseResponse === false)
-                                return res;
-                            return (0, parseResponse_1["default"])(res);
                         });
                     })];
             });

package/dist/core/parseResponse.d.ts

@@ -1 +1,6 @@
-export default function getResponseBody(response: Response): Promise<any>;
+export default function getResponseBody(response: Response): Promise<{
+    data: string;
+    status: number;
+    headers: Headers;
+    res: Response;
+}>;

package/dist/core/parseResponse.js

@@ -40,7 +40,7 @@ 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;
+        var contentType, isJSON, responseBody, data;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -49,15 +49,21 @@ function getResponseBody(response) {
                     return [4 /*yield*/, response.text()];
                 case 1:
                     responseBody = _a.sent();
+                    data = responseBody;
                     if (isJSON) {
                         try {
-                            return [2 /*return*/, JSON.parse(responseBody)];
+                            data = JSON.parse(responseBody);
                         }
                         catch (e) {
                             // If our JSON parsing failed then we can just return plaintext instead.
                         }
                     }
-                    return [2 /*return*/, responseBody];
+                    return [2 /*return*/, {
+                            data: data,
+                            status: response.status,
+                            headers: response.headers,
+                            res: response
+                        }];
             }
         });
     });

package/dist/core/prepareAuth.js

@@ -5,19 +5,57 @@ function prepareAuth(authKey, operation) {
         return {};
     }
     var preparedAuth = {};
-    var security = operation.prepareSecurity();
-    var securitySchemes = Object.keys(security);
-    if (securitySchemes.length === 0) {
+    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 {};
     }
-    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.");
+    // 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.");
     }
-    var scheme = schemes[0];
+    // 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') {
@@ -27,28 +65,19 @@ function prepareAuth(authKey, operation) {
                 };
             }
             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."));
+            throw new Error("Sorry, this API currently uses a security scheme, ".concat(scheme.type, ", which this library doesn't yet support."));
     }
     return preparedAuth;
 }

package/dist/core/prepareParams.d.ts

@@ -5,9 +5,6 @@ import type { Operation } from 'oas';
  * operation to see what's what and prepare any available parameters to be used in an API request
  * with `@readme/oas-to-har`.
  *
- * @param operation
- * @param body
- * @param metadata
  */
 export default function prepareParams(operation: Operation, body?: unknown, metadata?: Record<string, unknown>): Promise<{
     body?: any;

package/dist/core/prepareParams.js

@@ -39,21 +39,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-var lodash_merge_1 = __importDefault(require("lodash.merge"));
 var promises_1 = __importDefault(require("fs/promises"));
 var path_1 = __importDefault(require("path"));
 var stream_1 = __importDefault(require("stream"));
-var get_stream_1 = __importDefault(require("get-stream"));
-var sync_1 = __importDefault(require("datauri/sync"));
+var caseless_1 = __importDefault(require("caseless"));
 var parser_1 = __importDefault(require("datauri/parser"));
+var sync_1 = __importDefault(require("datauri/sync"));
+var get_stream_1 = __importDefault(require("get-stream"));
+var lodash_merge_1 = __importDefault(require("lodash.merge"));
+var remove_undefined_objects_1 = __importDefault(require("remove-undefined-objects"));
 var getJSONSchemaDefaults_1 = __importDefault(require("./getJSONSchemaDefaults"));
+// These headers are normally only defined by the OpenAPI definition but we allow the user to
+// manually supply them in their `metadata` parameter if they wish.
+var specialHeaders = ['accept', 'authorization'];
 /**
  * Extract all available parameters from an operations Parameter Object into a digestable array
  * that we can use to apply to the request.
  *
  * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#parameterObject}
  * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameterObject}
- * @param parameters
  */
 function digestParameters(parameters) {
     return parameters.reduce(function (prev, param) {
@@ -94,8 +98,6 @@ function merge(src, target) {
  * Ingest a file path or readable stream into a common object that we can later use to process it
  * into a parameters object for making an API request.
  *
- * @param paramName
- * @param file
  */
 function processFile(paramName, file) {
     if (typeof file === 'string') {
@@ -149,23 +151,48 @@ function processFile(paramName, file) {
  * operation to see what's what and prepare any available parameters to be used in an API request
  * with `@readme/oas-to-har`.
  *
- * @param operation
- * @param body
- * @param metadata
  */
 function prepareParams(operation, body, metadata) {
     var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function () {
-        var metadataIntersected, digestedParameters, hasDigestedParams, jsonSchema, jsonSchemaDefaults, params, intersection, payloadJsonSchema, conversions_1;
+        var metadataIntersected, digestedParameters, jsonSchema, throwNoParamsError, bodyParams_1, jsonSchemaDefaults, params, headerParams_1, intersection, payloadJsonSchema, conversions_1;
         return __generator(this, function (_e) {
             switch (_e.label) {
                 case 0:
                     metadataIntersected = false;
                     digestedParameters = digestParameters(operation.getParameters());
-                    hasDigestedParams = !!Object.keys(digestedParameters).length;
-                    jsonSchema = operation.getParametersAsJsonSchema();
+                    jsonSchema = operation.getParametersAsJSONSchema();
+                    /**
+                     * It might be common for somebody to run `sdk.findPetsByStatus({ status: 'available' }, {})`, in
+                     * which case we want to filter out the second (metadata) parameter and treat the first parameter
+                     * as the metadata instead. If we don't do this, their supplied `status` metadata will be treated
+                     * as a body parameter, and because there's no `status` body parameter, and no supplied metadata
+                     * (because it's an empty object), the request won't send a payload.
+                     *
+                     * @see {@link https://github.com/readmeio/api/issues/449}
+                     */
+                    // eslint-disable-next-line no-param-reassign
+                    metadata = (0, remove_undefined_objects_1["default"])(metadata);
                     if (!jsonSchema && (body !== undefined || metadata !== undefined)) {
-                        throw new Error("You supplied metadata and/or body data for this operation but it doesn't have any documented parameters or request payloads. If you think this is an error please contact support for the API you're using.");
+                        throwNoParamsError = true;
+                        // If this operation doesn't have any parameters for us to transform to JSON Schema but they've
+                        // sent us either an `Accept` or `Authorization` header (or both) we should let them do that.
+                        // We should, however, only do this check for the `body` parameter as if they've sent this
+                        // request both `body` and `metadata` we can reject it outright as the operation won't have any
+                        // body data.
+                        if (body !== undefined) {
+                            if (typeof body === 'object' && body !== null && !Array.isArray(body)) {
+                                if (Object.keys(body).length <= 2) {
+                                    bodyParams_1 = (0, caseless_1["default"])(body);
+                                    if (specialHeaders.some(function (header) { return bodyParams_1.has(header); })) {
+                                        throwNoParamsError = false;
+                                    }
+                                }
+                            }
+                        }
+                        if (throwNoParamsError) {
+                            throw new Error("You supplied metadata and/or body data for this operation but it doesn't have any documented parameters or request payloads. If you think this is an error please contact support for the API you're using.");
+                        }
                     }
                     jsonSchemaDefaults = jsonSchema ? (0, getJSONSchemaDefaults_1["default"])(jsonSchema) : {};
                     params = jsonSchemaDefaults;
@@ -179,31 +206,43 @@ function prepareParams(operation, body, metadata) {
                             params.body = merge(params.body, body);
                         }
                         else if (typeof metadata === 'undefined') {
-                            // No metadata was explicitly provided so we need to analyze the body to determine if it's a
-                            // body or should be actually be treated as metadata.
-                            if (!hasDigestedParams) {
-                                // If no parameters were able to be digested it's because this operation has none so then
-                                // we just have to assume that what the user supplied was for a body and not metadata. This
-                                // might lead to unwanted false positives if the API definition isn't accurate but short of
-                                // throwing an error (one that the user would have no control over resolving anyways) there
-                                // isn't anything we can do about it.
-                                params.body = merge(params.body, body);
-                            }
-                            else {
-                                intersection = Object.keys(body).filter(function (value) { return Object.keys(digestedParameters).includes(value); }).length;
-                                if (intersection && intersection / Object.keys(body).length > 0.25) {
-                                    /* eslint-disable no-param-reassign */
-                                    // If more than 25% of the body intersects with the parameters that we've got on hand,
-                                    // then we should treat it as a metadata object and organize into parameters.
-                                    metadataIntersected = true;
-                                    metadata = merge(params.body, body);
-                                    body = undefined;
-                                    /* eslint-enable no-param-reassign */
+                            headerParams_1 = (0, caseless_1["default"])({});
+                            Object.entries(digestedParameters).forEach(function (_a) {
+                                var paramName = _a[0], param = _a[1];
+                                // Headers are sent case-insensitive so we need to make sure that we're properly
+                                // matching them when detecting what our incoming payload looks like.
+                                if (param["in"] === 'header') {
+                                    headerParams_1.set(paramName, '');
                                 }
-                                else {
-                                    // For all other cases, we should just treat the supplied body as a body.
-                                    params.body = merge(params.body, body);
+                            });
+                            // `Accept` and `Authorization` headers can't be defined as normal parameters but we should
+                            // always allow the user to supply them if they wish.
+                            specialHeaders.forEach(function (header) {
+                                if (!headerParams_1.has(header)) {
+                                    headerParams_1.set(header, '');
+                                }
+                            });
+                            intersection = Object.keys(body).filter(function (value) {
+                                if (Object.keys(digestedParameters).includes(value)) {
+                                    return true;
+                                }
+                                else if (headerParams_1.has(value)) {
+                                    return true;
                                 }
+                                return false;
+                            }).length;
+                            if (intersection && intersection / Object.keys(body).length > 0.25) {
+                                /* eslint-disable no-param-reassign */
+                                // If more than 25% of the body intersects with the parameters that we've got on hand,
+                                // then we should treat it as a metadata object and organize into parameters.
+                                metadataIntersected = true;
+                                metadata = merge(params.body, body);
+                                body = undefined;
+                                /* eslint-enable no-param-reassign */
+                            }
+                            else {
+                                // For all other cases, we should just treat the supplied body as a body.
+                                params.body = merge(params.body, body);
                             }
                         }
                         else {
@@ -278,7 +317,7 @@ function prepareParams(operation, body, metadata) {
                     // Only spend time trying to organize metadata into parameters if we were able to digest
                     // parameters out of the operation schema. If we couldn't digest anything, but metadata was
                     // supplied then we wouldn't know how to send it in the request!
-                    if (hasDigestedParams) {
+                    if (typeof metadata !== 'undefined') {
                         if (!('cookie' in params))
                             params.cookie = {};
                         if (!('header' in params))
@@ -290,8 +329,17 @@ function prepareParams(operation, body, metadata) {
                         Object.entries(digestedParameters).forEach(function (_a) {
                             var paramName = _a[0], param = _a[1];
                             var value;
-                            if (typeof metadata === 'object' && !isEmpty(metadata) && paramName in metadata) {
-                                value = metadata[paramName];
+                            var metadataHeaderParam;
+                            if (typeof metadata === 'object' && !isEmpty(metadata)) {
+                                if (paramName in metadata) {
+                                    value = metadata[paramName];
+                                }
+                                else if (param["in"] === 'header') {
+                                    // Headers are sent case-insensitive so we need to make sure that we're properly
+                                    // matching them when detecting what our incoming payload looks like.
+                                    metadataHeaderParam = Object.keys(metadata).find(function (k) { return k.toLowerCase() === paramName.toLowerCase(); });
+                                    value = metadata[metadataHeaderParam];
+                                }
                             }
                             if (value === undefined) {
                                 return;
@@ -307,8 +355,8 @@ function prepareParams(operation, body, metadata) {
                                     delete metadata[paramName];
                                     break;
                                 case 'header':
-                                    params.header[paramName] = value;
-                                    delete metadata[paramName];
+                                    params.header[paramName.toLowerCase()] = value;
+                                    delete metadata[metadataHeaderParam];
                                     break;
                                 case 'cookie':
                                     params.cookie[paramName] = value;
@@ -332,6 +380,19 @@ function prepareParams(operation, body, metadata) {
                             if (operation.isFormUrlEncoded()) {
                                 params.formData = merge(params.formData, metadata);
                             }
+                            else if (typeof metadata === 'object') {
+                                // If the user supplied an `accept` or `authorization` header themselves we should allow it
+                                // through. Normally these headers are automatically handled by `@readme/oas-to-har` but in
+                                // the event that maybe the user wants to return XML for an API that normally returns JSON
+                                // or specify a custom auth header (maybe we can't handle their auth case right) this is the
+                                // only way with this library that they can do that.
+                                specialHeaders.forEach(function (headerName) {
+                                    var headerParam = Object.keys(metadata).find(function (m) { return m.toLowerCase() === headerName; });
+                                    if (headerParam) {
+                                        params.header[headerName] = metadata[headerParam];
+                                    }
+                                });
+                            }
                             else {
                                 // Any other remaining unused metadata will be unused because we don't know where to place
                                 // it in the request.

package/dist/fetcher.d.ts

@@ -1,4 +1,4 @@
-import type { OASDocument } from 'oas/@types/rmoas.types';
+import type { OASDocument } from 'oas/dist/rmoas.types';
 import 'isomorphic-fetch';
 export default class Fetcher {
     uri: string | OASDocument;

package/dist/fetcher.js

@@ -39,11 +39,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-require("isomorphic-fetch");
-var openapi_parser_1 = __importDefault(require("@readme/openapi-parser"));
-var js_yaml_1 = __importDefault(require("js-yaml"));
 var fs_1 = __importDefault(require("fs"));
 var path_1 = __importDefault(require("path"));
+var openapi_parser_1 = __importDefault(require("@readme/openapi-parser"));
+require("isomorphic-fetch");
+var js_yaml_1 = __importDefault(require("js-yaml"));
 var Fetcher = /** @class */ (function () {
     function Fetcher(uri) {
         if (typeof uri === 'string') {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { OASDocument } from 'oas/@types/rmoas.types';
+import type { OASDocument } from 'oas/dist/rmoas.types';
 interface SDKOptions {
     cacheDir?: string;
 }