httpsnippet-client-api 5.0.0-beta.1 → 5.0.0-beta.2

package/README.md

@@ -6,7 +6,6 @@ An [HTTPSnippet](https://npm.im/httpsnippet) client for generating snippets for
 
 [![](https://d3vv6lp55qjaqc.cloudfront.net/items/1M3C3j0I0s0j3T362344/Untitled-2.png)](https://readme.io)
 
-
 ## Installation
 
 ```sh
@@ -16,10 +15,10 @@ npm install --save httpsnippet-client-api
 ## Usage
 
 ```js
-const httpsnippet = require('httpsnippet');
-const client = require('httpsnippet-client-api');
+import { HTTPSnippet, addTargetClient } from 'httpsnippet';
+import client = require('httpsnippet-client-api');
 
-HTTPSnippet.addTargetClient('node', client);
+addTargetClient('node', client);
 
 const har = {
   "log": {
@@ -59,7 +58,8 @@ Results in the following:
 const sdk = require('api')('https://api.example.com/openapi.json');
 
 sdk.auth('a5a220e');
-sdk.put('/apiKey')
+sdk
+  .put('/apiKey')
   .then(res => console.log(res))
   .catch(err => console.error(err));
 ```

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { OASDocument } from 'oas/@types/rmoas.types';
+import type { Client } from '@readme/httpsnippet/dist/targets/targets';
+export interface APIOptions {
+    apiDefinition: OASDocument;
+    apiDefinitionUri: string;
+    indent?: string | false;
+    escapeBrackets?: boolean;
+}
+declare const client: Client<APIOptions>;
+export default client;

package/dist/index.js

@@ -0,0 +1,272 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var stringify_object_1 = __importDefault(require("stringify-object"));
+var code_builder_1 = require("@readme/httpsnippet/dist/helpers/code-builder");
+var content_type_1 = __importDefault(require("content-type"));
+var oas_1 = __importDefault(require("oas"));
+function stringify(obj, opts) {
+    if (opts === void 0) { opts = {}; }
+    return (0, stringify_object_1["default"])(obj, __assign({ indent: '  ' }, opts));
+}
+function buildAuthSnippet(authKey) {
+    // Auth key will be an array for Basic auth cases.
+    if (Array.isArray(authKey)) {
+        var auth_1 = [];
+        authKey.forEach(function (token, i) {
+            // If the token part is the last part of the key and it's empty, don't add it to the snippet.
+            if (token.length === 0 && authKey.length > 1 && i === authKey.length - 1) {
+                return;
+            }
+            auth_1.push("'".concat(token.replace(/'/g, "\\'"), "'"));
+        });
+        return "sdk.auth(".concat(auth_1.join(', '), ");");
+    }
+    return "sdk.auth('".concat(authKey.replace(/'/g, "\\'"), "');");
+}
+function getAuthSources(operation) {
+    var matchers = {
+        header: {},
+        query: [],
+        cookie: []
+    };
+    if (operation.getSecurity().length === 0) {
+        return matchers;
+    }
+    var security = operation.prepareSecurity();
+    Object.keys(security).forEach(function (id) {
+        security[id].forEach(function (scheme) {
+            if (scheme.type === 'http') {
+                if (scheme.scheme === 'basic') {
+                    matchers.header.authorization = 'Basic';
+                }
+                else if (scheme.scheme === 'bearer') {
+                    matchers.header.authorization = 'Bearer';
+                }
+            }
+            else if (scheme.type === 'oauth2') {
+                matchers.header.authorization = 'Bearer';
+            }
+            else if (scheme.type === 'apiKey') {
+                if (scheme["in"] === 'query') {
+                    matchers.query.push(scheme.name);
+                }
+                else if (scheme["in"] === 'header') {
+                    // The way that this asterisk header matcher works is that since this `apiKey` goes in a
+                    // named header (`scheme.name`) because the header is the key, we're matching against the
+                    // entire header -- counter to the way that the HTTP basic matcher above works where we
+                    // match and extract the API key from everything after `Basic ` in the `Authorization`
+                    // header.
+                    matchers.header[scheme.name.toLowerCase()] = '*';
+                }
+                else if (scheme["in"] === 'cookie') {
+                    matchers.cookie.push(scheme.name);
+                }
+            }
+        });
+    });
+    return matchers;
+}
+var client = {
+    info: {
+        key: 'api',
+        title: 'API',
+        link: 'https://npm.im/api',
+        description: 'Automatic SDK generation from an OpenAPI definition.'
+    },
+    convert: function (source, options) {
+        var opts = __assign({}, options);
+        if (!('apiDefinitionUri' in opts)) {
+            throw new Error('This HTTP Snippet client must have an `apiDefinitionUri` option supplied to it.');
+        }
+        else if (!('apiDefinition' in opts)) {
+            throw new Error('This HTTP Snippet client must have an `apiDefinition` option supplied to it.');
+        }
+        var method = source.method.toLowerCase();
+        var oas = new oas_1["default"](opts.apiDefinition);
+        var apiDefinition = oas.getDefinition();
+        var foundOperation = oas.findOperation(source.url, method);
+        if (!foundOperation) {
+            throw new Error("Unable to locate a matching operation in the supplied `apiDefinition` for: ".concat(source.method, " ").concat(source.url));
+        }
+        var operationSlugs = foundOperation.url.slugs;
+        var operation = oas.operation(foundOperation.url.nonNormalizedPath, method);
+        var path = operation.path;
+        var authData = [];
+        var authSources = getAuthSources(operation);
+        var _a = new code_builder_1.CodeBuilder({ indent: opts.indent || '  ' }), blank = _a.blank, push = _a.push, join = _a.join;
+        // const code = new CodeBuilder(opts.indent);
+        push("const sdk = require('api')('".concat(opts.apiDefinitionUri, "');"));
+        blank();
+        // If we have multiple servers configured and our source URL differs from the stock URL that we
+        // receive from our `oas` library then the URL either has server variables contained in it (that
+        // don't match the defaults), or the OAS offers alternate server URLs and we should expose that
+        // in the generated snippet.
+        var configData = [];
+        if ((apiDefinition.servers || []).length > 1) {
+            var stockUrl = oas.url();
+            var baseUrl = source.url.replace(path, '');
+            if (baseUrl !== stockUrl) {
+                var serverVars = oas.splitVariables(baseUrl);
+                var serverUrl = serverVars ? oas.url(serverVars.selected, serverVars.variables) : baseUrl;
+                configData.push("sdk.server('".concat(serverUrl, "');"));
+            }
+        }
+        var metadata = {};
+        Object.keys(source.queryObj).forEach(function (param) {
+            if (authSources.query.includes(param)) {
+                authData.push(buildAuthSnippet(source.queryObj[param]));
+                // If this query param is part of an auth source then we don't want it doubled up in the
+                // snippet.
+                return;
+            }
+            metadata[param] = source.queryObj[param];
+        });
+        Object.keys(source.cookiesObj).forEach(function (cookie) {
+            if (authSources.cookie.includes(cookie)) {
+                authData.push(buildAuthSnippet(source.cookiesObj[cookie]));
+                // If this cookie is part of an auth source then we don't want it doubled up.
+                return;
+            }
+            // Note that we may have the potential to overlap any cookie that also shares the name as
+            // another metadata parameter. This problem is currently inherent to `api` and not this
+            // snippet generator.
+            metadata[cookie] = source.cookiesObj[cookie];
+        });
+        // If we have path parameters present, we should only add them in if we have an `operationId` as
+        // we don't want metadata to duplicate what we'll be setting the path in the snippet to.
+        if (operation.hasOperationId()) {
+            Array.from(Object.entries(operationSlugs)).forEach(function (_a) {
+                var param = _a[0], value = _a[1];
+                // The keys in `operationSlugs` will always be prefixed with a `:` in the `oas` library so
+                // we can safely do this substring here without asserting this context.
+                metadata[param.substring(1)] = value;
+            });
+        }
+        if (Object.keys(source.headersObj).length) {
+            var headers_1 = source.headersObj;
+            Object.keys(headers_1).forEach(function (header) {
+                // Headers in HTTPSnippet are case-insensitive so we need to add in some special handling to
+                // make sure we're able to match them properly.
+                var headerLc = header.toLowerCase();
+                if (headerLc in authSources.header) {
+                    // If this header has been set up as an authentication header, let's remove it and add it
+                    // into our auth data so we can build up an `.auth()` snippet for the SDK.
+                    var authScheme = authSources.header[headerLc];
+                    if (authScheme === '*') {
+                        authData.push(buildAuthSnippet(headers_1[header]));
+                    }
+                    else {
+                        // @ts-expect-error `headers[header]` is typed improperly in HTTPSnippet.
+                        var authKey = headers_1[header].replace("".concat(authSources.header[headerLc], " "), '');
+                        if (authScheme.toLowerCase() === 'basic') {
+                            authKey = Buffer.from(authKey, 'base64').toString('ascii');
+                            authKey = authKey.split(':');
+                        }
+                        authData.push(buildAuthSnippet(authKey));
+                    }
+                    delete headers_1[header];
+                }
+                else if (headerLc === 'content-type') {
+                    // `Content-Type` headers are automatically added within the SDK so we can filter them out
+                    // if they don't have parameters attached to them.
+                    // @ts-expect-error `headers[header]` is typed improperly in HTTPSnippet.
+                    var parsedContentType = content_type_1["default"].parse(headers_1[header]);
+                    if (!Object.keys(parsedContentType.parameters).length) {
+                        delete headers_1[header];
+                    }
+                }
+                else if (headerLc === 'accept') {
+                    // If the `Accept` header here is not the default or first `Accept` header for the
+                    // operations' request body then we should add it otherwise we can let the SDK handle it
+                    // itself.
+                    if (headers_1[header] === operation.getContentType()) {
+                        delete headers_1[header];
+                    }
+                }
+            });
+            if (Object.keys(headers_1).length > 0) {
+                metadata = Object.assign(metadata, headers_1);
+            }
+        }
+        var body;
+        switch (source.postData.mimeType) {
+            case 'application/x-www-form-urlencoded':
+                body = source.postData.paramsObj;
+                break;
+            case 'application/json':
+                if (source.postData.jsonObj) {
+                    body = source.postData.jsonObj;
+                }
+                break;
+            case 'multipart/form-data':
+                if (source.postData.params) {
+                    body = {};
+                    // If there's a `Content-Type` header present in the metadata, but it's for the
+                    // `multipart/form-data` request then dump it off the snippet. We shouldn't offload that
+                    // unnecessary bloat of multipart boundaries to the user, instead letting the SDK handle it
+                    // automatically.
+                    if ('content-type' in metadata && metadata['content-type'].indexOf('multipart/form-data') === 0) {
+                        delete metadata['content-type'];
+                    }
+                    source.postData.params.forEach(function (param) {
+                        if (param.fileName) {
+                            body[param.name] = param.fileName;
+                        }
+                        else {
+                            body[param.name] = param.value;
+                        }
+                    });
+                }
+                break;
+            default:
+                if (source.postData.text) {
+                    body = source.postData.text;
+                }
+        }
+        var args = [];
+        var accessor = method;
+        if (operation.hasOperationId()) {
+            accessor = operation.getOperationId({ camelCase: true });
+        }
+        else {
+            // Since we're not using an operationId as our primary accessor we need to take the current
+            // operation that we're working with and transpile back our path parameters on top of it.
+            var slugs = Object.fromEntries(Object.keys(operationSlugs).map(function (slug) { return [slug.replace(/:(.*)/, '$1'), operationSlugs[slug]]; }));
+            args.push("'".concat(decodeURIComponent(oas.replaceUrl(path, slugs)), "'"));
+        }
+        // If we're going to be rendering out body params and metadata we should cut their character
+        // limit in half because we'll be rendering them in their own lines.
+        var inlineCharacterLimit = typeof body !== 'undefined' && Object.keys(metadata).length > 0 ? 40 : 80;
+        if (typeof body !== 'undefined') {
+            args.push(stringify(body, { inlineCharacterLimit: inlineCharacterLimit }));
+        }
+        if (Object.keys(metadata).length > 0) {
+            args.push(stringify(metadata, { inlineCharacterLimit: inlineCharacterLimit }));
+        }
+        if (authData.length) {
+            push(authData.join('\n'));
+        }
+        if (configData.length) {
+            push(configData.join('\n'));
+        }
+        push("sdk.".concat(accessor, "(").concat(args.join(', '), ")"));
+        push('.then(res => console.log(res))', 1);
+        push('.catch(err => console.error(err));', 1);
+        return join();
+    }
+};
+exports["default"] = client;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "httpsnippet-client-api",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.2",
   "description": "An HTTPSnippet client for generating snippets for the `api` module.",
-  "main": "src/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "lint": "eslint .",
-    "pretest": "npm run lint",
-    "prettier": "prettier --list-different --write \"./**/**.js\"",
-    "test": "nyc mocha \"test/**/*.test.js\"",
-    "test:watch": "nyc mocha \"test/**/*.test.js\" --watch"
+    "build": "tsc",
+    "prebuild": "rm -rf dist/",
+    "prepack": "npm run build",
+    "test": "nyc mocha \"test/**/*.test.ts\""
   },
   "repository": {
     "type": "git",
@@ -28,24 +28,30 @@
     "stringify-object": "^3.3.0"
   },
   "peerDependencies": {
-    "@readme/httpsnippet": "^3.0.0",
+    "@readme/httpsnippet": "^4.0.3",
     "oas": "^18.0.1"
   },
   "devDependencies": {
-    "@readme/eslint-config": "^8.7.3",
     "@readme/oas-examples": "^5.4.1",
     "@readme/openapi-parser": "^2.2.0",
-    "api": "^5.0.0-beta.1",
+    "@types/content-type": "^1.1.5",
+    "@types/stringify-object": "^4.0.1",
+    "api": "^5.0.0-beta.2",
     "chai": "^4.3.6",
-    "eslint": "^8.14.0",
     "fetch-mock": "^9.11.0",
     "isomorphic-fetch": "^3.0.0",
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
-    "prettier": "^2.6.2",
     "sinon": "^14.0.0",
-    "sinon-chai": "^3.7.0"
+    "sinon-chai": "^3.7.0",
+    "typescript": "^4.7.4"
   },
   "prettier": "@readme/eslint-config/prettier",
-  "gitHead": "5970a1f16a6444733f53da28f6d01c5d544372c3"
+  "nyc": {
+    "exclude": [
+      "dist/",
+      "test/"
+    ]
+  },
+  "gitHead": "aa738b1bf46b447afed38507d3fc49acbbad6309"
 }

package/src/index.ts

@@ -0,0 +1,308 @@
+import type { Operation } from 'oas';
+import type { HttpMethods, OASDocument } from 'oas/@types/rmoas.types';
+import type { Client } from '@readme/httpsnippet/dist/targets/targets';
+import stringifyObject from 'stringify-object';
+import { CodeBuilder } from '@readme/httpsnippet/dist/helpers/code-builder';
+import contentType from 'content-type';
+import Oas from 'oas';
+
+// This should really be an exported type in `oas`.
+type SecurityType = 'Basic' | 'Bearer' | 'Query' | 'Header' | 'Cookie' | 'OAuth2' | 'http' | 'apiKey';
+
+function stringify(obj: any, opts = {}) {
+  return stringifyObject(obj, { indent: '  ', ...opts });
+}
+
+function buildAuthSnippet(authKey: string | string[]) {
+  // Auth key will be an array for Basic auth cases.
+  if (Array.isArray(authKey)) {
+    const auth: string[] = [];
+    authKey.forEach((token, i) => {
+      // If the token part is the last part of the key and it's empty, don't add it to the snippet.
+      if (token.length === 0 && authKey.length > 1 && i === authKey.length - 1) {
+        return;
+      }
+
+      auth.push(`'${token.replace(/'/g, "\\'")}'`);
+    });
+
+    return `sdk.auth(${auth.join(', ')});`;
+  }
+
+  return `sdk.auth('${authKey.replace(/'/g, "\\'")}');`;
+}
+
+function getAuthSources(operation: Operation) {
+  const matchers: { header: Record<string, string>; query: string[]; cookie: string[] } = {
+    header: {},
+    query: [],
+    cookie: [],
+  };
+
+  if (operation.getSecurity().length === 0) {
+    return matchers;
+  }
+
+  const security = operation.prepareSecurity();
+  Object.keys(security).forEach((id: SecurityType) => {
+    security[id].forEach(scheme => {
+      if (scheme.type === 'http') {
+        if (scheme.scheme === 'basic') {
+          matchers.header.authorization = 'Basic';
+        } else if (scheme.scheme === 'bearer') {
+          matchers.header.authorization = 'Bearer';
+        }
+      } else if (scheme.type === 'oauth2') {
+        matchers.header.authorization = 'Bearer';
+      } else if (scheme.type === 'apiKey') {
+        if (scheme.in === 'query') {
+          matchers.query.push(scheme.name);
+        } else if (scheme.in === 'header') {
+          // The way that this asterisk header matcher works is that since this `apiKey` goes in a
+          // named header (`scheme.name`) because the header is the key, we're matching against the
+          // entire header -- counter to the way that the HTTP basic matcher above works where we
+          // match and extract the API key from everything after `Basic ` in the `Authorization`
+          // header.
+          matchers.header[scheme.name.toLowerCase()] = '*';
+        } else if (scheme.in === 'cookie') {
+          matchers.cookie.push(scheme.name);
+        }
+      }
+    });
+  });
+
+  return matchers;
+}
+
+export interface APIOptions {
+  apiDefinition: OASDocument;
+  apiDefinitionUri: string;
+  indent?: string | false;
+  escapeBrackets?: boolean;
+}
+
+const client: Client<APIOptions> = {
+  info: {
+    key: 'api',
+    title: 'API',
+    link: 'https://npm.im/api',
+    description: 'Automatic SDK generation from an OpenAPI definition.',
+  },
+  convert: (source, options) => {
+    const opts = {
+      ...options,
+    };
+
+    if (!('apiDefinitionUri' in opts)) {
+      throw new Error('This HTTP Snippet client must have an `apiDefinitionUri` option supplied to it.');
+    } else if (!('apiDefinition' in opts)) {
+      throw new Error('This HTTP Snippet client must have an `apiDefinition` option supplied to it.');
+    }
+
+    const method = source.method.toLowerCase() as HttpMethods;
+    const oas = new Oas(opts.apiDefinition);
+    const apiDefinition = oas.getDefinition();
+    const foundOperation = oas.findOperation(source.url, method);
+    if (!foundOperation) {
+      throw new Error(
+        `Unable to locate a matching operation in the supplied \`apiDefinition\` for: ${source.method} ${source.url}`
+      );
+    }
+
+    const operationSlugs = foundOperation.url.slugs;
+    const operation = oas.operation(foundOperation.url.nonNormalizedPath, method);
+    const path = operation.path;
+    const authData: string[] = [];
+    const authSources = getAuthSources(operation);
+
+    const { blank, push, join } = new CodeBuilder({ indent: opts.indent || '  ' });
+    // const code = new CodeBuilder(opts.indent);
+
+    push(`const sdk = require('api')('${opts.apiDefinitionUri}');`);
+    blank();
+
+    // If we have multiple servers configured and our source URL differs from the stock URL that we
+    // receive from our `oas` library then the URL either has server variables contained in it (that
+    // don't match the defaults), or the OAS offers alternate server URLs and we should expose that
+    // in the generated snippet.
+    const configData = [];
+    if ((apiDefinition.servers || []).length > 1) {
+      const stockUrl = oas.url();
+      const baseUrl = source.url.replace(path, '');
+      if (baseUrl !== stockUrl) {
+        const serverVars = oas.splitVariables(baseUrl);
+        const serverUrl = serverVars ? oas.url(serverVars.selected, serverVars.variables) : baseUrl;
+
+        configData.push(`sdk.server('${serverUrl}');`);
+      }
+    }
+
+    let metadata: Record<string, string | string[]> = {};
+    Object.keys(source.queryObj).forEach(param => {
+      if (authSources.query.includes(param)) {
+        authData.push(buildAuthSnippet(source.queryObj[param]));
+
+        // If this query param is part of an auth source then we don't want it doubled up in the
+        // snippet.
+        return;
+      }
+
+      metadata[param] = source.queryObj[param];
+    });
+
+    Object.keys(source.cookiesObj).forEach(cookie => {
+      if (authSources.cookie.includes(cookie)) {
+        authData.push(buildAuthSnippet(source.cookiesObj[cookie]));
+
+        // If this cookie is part of an auth source then we don't want it doubled up.
+        return;
+      }
+
+      // Note that we may have the potential to overlap any cookie that also shares the name as
+      // another metadata parameter. This problem is currently inherent to `api` and not this
+      // snippet generator.
+      metadata[cookie] = source.cookiesObj[cookie];
+    });
+
+    // If we have path parameters present, we should only add them in if we have an `operationId` as
+    // we don't want metadata to duplicate what we'll be setting the path in the snippet to.
+    if (operation.hasOperationId()) {
+      Array.from(Object.entries(operationSlugs)).forEach(([param, value]) => {
+        // The keys in `operationSlugs` will always be prefixed with a `:` in the `oas` library so
+        // we can safely do this substring here without asserting this context.
+        metadata[param.substring(1)] = value;
+      });
+    }
+
+    if (Object.keys(source.headersObj).length) {
+      const headers = source.headersObj;
+
+      Object.keys(headers).forEach(header => {
+        // Headers in HTTPSnippet are case-insensitive so we need to add in some special handling to
+        // make sure we're able to match them properly.
+        const headerLc = header.toLowerCase();
+
+        if (headerLc in authSources.header) {
+          // If this header has been set up as an authentication header, let's remove it and add it
+          // into our auth data so we can build up an `.auth()` snippet for the SDK.
+          const authScheme = authSources.header[headerLc];
+          if (authScheme === '*') {
+            authData.push(buildAuthSnippet(headers[header]));
+          } else {
+            // @ts-expect-error `headers[header]` is typed improperly in HTTPSnippet.
+            let authKey = headers[header].replace(`${authSources.header[headerLc]} `, '');
+            if (authScheme.toLowerCase() === 'basic') {
+              authKey = Buffer.from(authKey, 'base64').toString('ascii');
+              authKey = authKey.split(':');
+            }
+
+            authData.push(buildAuthSnippet(authKey));
+          }
+
+          delete headers[header];
+        } else if (headerLc === 'content-type') {
+          // `Content-Type` headers are automatically added within the SDK so we can filter them out
+          // if they don't have parameters attached to them.
+          // @ts-expect-error `headers[header]` is typed improperly in HTTPSnippet.
+          const parsedContentType = contentType.parse(headers[header]);
+          if (!Object.keys(parsedContentType.parameters).length) {
+            delete headers[header];
+          }
+        } else if (headerLc === 'accept') {
+          // If the `Accept` header here is not the default or first `Accept` header for the
+          // operations' request body then we should add it otherwise we can let the SDK handle it
+          // itself.
+          if (headers[header] === operation.getContentType()) {
+            delete headers[header];
+          }
+        }
+      });
+
+      if (Object.keys(headers).length > 0) {
+        metadata = Object.assign(metadata, headers);
+      }
+    }
+
+    let body: any;
+    switch (source.postData.mimeType) {
+      case 'application/x-www-form-urlencoded':
+        body = source.postData.paramsObj;
+        break;
+
+      case 'application/json':
+        if (source.postData.jsonObj) {
+          body = source.postData.jsonObj;
+        }
+        break;
+
+      case 'multipart/form-data':
+        if (source.postData.params) {
+          body = {};
+
+          // If there's a `Content-Type` header present in the metadata, but it's for the
+          // `multipart/form-data` request then dump it off the snippet. We shouldn't offload that
+          // unnecessary bloat of multipart boundaries to the user, instead letting the SDK handle it
+          // automatically.
+          if ('content-type' in metadata && metadata['content-type'].indexOf('multipart/form-data') === 0) {
+            delete metadata['content-type'];
+          }
+
+          source.postData.params.forEach(function (param) {
+            if (param.fileName) {
+              body[param.name] = param.fileName;
+            } else {
+              body[param.name] = param.value;
+            }
+          });
+        }
+        break;
+
+      default:
+        if (source.postData.text) {
+          body = source.postData.text;
+        }
+    }
+
+    const args = [];
+
+    let accessor: string = method;
+    if (operation.hasOperationId()) {
+      accessor = operation.getOperationId({ camelCase: true });
+    } else {
+      // Since we're not using an operationId as our primary accessor we need to take the current
+      // operation that we're working with and transpile back our path parameters on top of it.
+      const slugs = Object.fromEntries(
+        Object.keys(operationSlugs).map(slug => [slug.replace(/:(.*)/, '$1'), operationSlugs[slug]])
+      );
+
+      args.push(`'${decodeURIComponent(oas.replaceUrl(path, slugs))}'`);
+    }
+
+    // If we're going to be rendering out body params and metadata we should cut their character
+    // limit in half because we'll be rendering them in their own lines.
+    const inlineCharacterLimit = typeof body !== 'undefined' && Object.keys(metadata).length > 0 ? 40 : 80;
+    if (typeof body !== 'undefined') {
+      args.push(stringify(body, { inlineCharacterLimit }));
+    }
+
+    if (Object.keys(metadata).length > 0) {
+      args.push(stringify(metadata, { inlineCharacterLimit }));
+    }
+
+    if (authData.length) {
+      push(authData.join('\n'));
+    }
+
+    if (configData.length) {
+      push(configData.join('\n'));
+    }
+
+    push(`sdk.${accessor}(${args.join(', ')})`);
+    push('.then(res => console.log(res))', 1);
+    push('.catch(err => console.error(err));', 1);
+
+    return join();
+  },
+};
+
+export default client;

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "baseUrl": "./src",
+    "declaration": true,
+    "esModuleInterop": true,
+    "lib": ["dom", "es2020"],
+    "noImplicitAny": true,
+    "outDir": "dist/"
+  },
+  "include": ["./src/**/*"]
+}

package/src/index.js

@@ -1,288 +0,0 @@
-const stringifyObject = require('stringify-object');
-const CodeBuilder = require('@readme/httpsnippet/src/helpers/code-builder');
-const contentType = require('content-type');
-const Oas = require('oas').default;
-
-function stringify(obj, opts = {}) {
-  return stringifyObject(obj, { indent: '  ', ...opts });
-}
-
-function buildAuthSnippet(authKey) {
-  // Auth key will be an array for Basic auth cases.
-  if (Array.isArray(authKey)) {
-    const auth = [];
-    authKey.forEach((token, i) => {
-      // If the token part is the last part of the key and it's empty, don't add it to the snippet.
-      if (token.length === 0 && authKey.length > 1 && i === authKey.length - 1) {
-        return;
-      }
-
-      auth.push(`'${token.replace(/'/g, "\\'")}'`);
-    });
-
-    return `sdk.auth(${auth.join(', ')});`;
-  }
-
-  return `sdk.auth('${authKey.replace(/'/g, "\\'")}');`;
-}
-
-function getAuthSources(operation) {
-  const matchers = {
-    header: [],
-    query: [],
-    cookie: [],
-  };
-
-  if (operation.getSecurity().length === 0) {
-    return matchers;
-  }
-
-  const security = operation.prepareSecurity();
-  Object.keys(security).forEach(id => {
-    security[id].forEach(scheme => {
-      if (scheme.type === 'http') {
-        if (scheme.scheme === 'basic') {
-          matchers.header.authorization = 'Basic';
-        } else if (scheme.scheme === 'bearer') {
-          matchers.header.authorization = 'Bearer';
-        }
-      } else if (scheme.type === 'oauth2') {
-        matchers.header.authorization = 'Bearer';
-      } else if (scheme.type === 'apiKey') {
-        if (scheme.in === 'query') {
-          matchers.query.push(scheme.name);
-        } else if (scheme.in === 'header') {
-          // The way that this asterisk header matcher works is that since this `apiKey` goes in a
-          // named header (`scheme.name`) because the header is the key, we're matching against the
-          // entire header -- counter to the way that the HTTP basic matcher above works where we
-          // match and extract the API key from everything after `Basic ` in the `Authorization`
-          // header.
-          matchers.header[scheme.name.toLowerCase()] = '*';
-        } else if (scheme.in === 'cookie') {
-          matchers.cookie.push(scheme.name);
-        }
-      }
-    });
-  });
-
-  return matchers;
-}
-
-module.exports = function (source, options) {
-  const opts = { indent: '  ', ...options };
-
-  if (!('apiDefinitionUri' in opts)) {
-    throw new Error('This HTTP Snippet client must have an `apiDefinitionUri` option supplied to it.');
-  } else if (!('apiDefinition' in opts)) {
-    throw new Error('This HTTP Snippet client must have an `apiDefinition` option supplied to it.');
-  }
-
-  const method = source.method.toLowerCase();
-  const oas = new Oas(opts.apiDefinition);
-  const apiDefinition = oas.getDefinition();
-  const foundOperation = oas.findOperation(source.url, method);
-  if (!foundOperation) {
-    throw new Error(
-      `Unable to locate a matching operation in the supplied \`apiDefinition\` for: ${source.method} ${source.url}`
-    );
-  }
-
-  const operationSlugs = foundOperation.url.slugs;
-  const operation = oas.operation(foundOperation.url.nonNormalizedPath, method);
-  const path = operation.path;
-  const authData = [];
-  const authSources = getAuthSources(operation);
-
-  const code = new CodeBuilder(opts.indent);
-
-  code.push(`const sdk = require('api')('${opts.apiDefinitionUri}');`);
-  code.blank();
-
-  // If we have multiple servers configured and our source URL differs from the stock URL that we
-  // receive from our `oas` library then the URL either has server variables contained in it (that
-  // don't match the defaults), or the OAS offers alternate server URLs and we should expose that
-  // in the generated snippet.
-  const configData = [];
-  if ((apiDefinition.servers || []).length > 1) {
-    const stockUrl = oas.url();
-    const baseUrl = source.url.replace(path, '');
-    if (baseUrl !== stockUrl) {
-      const serverVars = oas.splitVariables(baseUrl);
-      const serverUrl = serverVars ? oas.url(serverVars.selected, serverVars.variables) : baseUrl;
-
-      configData.push(`sdk.server('${serverUrl}');`);
-    }
-  }
-
-  let metadata = {};
-  Object.keys(source.queryObj).forEach(param => {
-    if (authSources.query.includes(param)) {
-      authData.push(buildAuthSnippet(source.queryObj[param]));
-
-      // If this query param is part of an auth source then we don't want it doubled up in the
-      // snippet.
-      return;
-    }
-
-    metadata[param] = source.queryObj[param];
-  });
-
-  Object.keys(source.cookiesObj).forEach(cookie => {
-    if (authSources.cookie.includes(cookie)) {
-      authData.push(buildAuthSnippet(source.cookiesObj[cookie]));
-
-      // If this cookie is part of an auth source then we don't want it doubled up.
-      return;
-    }
-
-    // Note that we may have the potential to overlap any cookie that also shares the name as
-    // another metadata parameter. This problem is currently inherent to `api` and not this
-    // snippet generator.
-    metadata[cookie] = source.cookiesObj[cookie];
-  });
-
-  // If we have path parameters present, we should only add them in if we have an `operationId` as
-  // we don't want metadata to duplicate what we'll be setting the path in the snippet to.
-  if (operation.hasOperationId()) {
-    Array.from(Object.entries(operationSlugs)).forEach(([param, value]) => {
-      // The keys in `operationSlugs` will always be prefixed with a `:` in the `oas` library so
-      // we can safely do this substring here without asserting this context.
-      metadata[param.substring(1)] = value;
-    });
-  }
-
-  if (Object.keys(source.headersObj).length) {
-    const headers = source.headersObj;
-
-    Object.keys(headers).forEach(header => {
-      // Headers in HTTPSnippet are case-insensitive so we need to add in some special handling to
-      // make sure we're able to match them properly.
-      const headerLc = header.toLowerCase();
-
-      if (headerLc in authSources.header) {
-        // If this header has been set up as an authentication header, let's remove it and add it
-        // into our auth data so we can build up an `.auth()` snippet for the SDK.
-        const authScheme = authSources.header[headerLc];
-        if (authScheme === '*') {
-          authData.push(buildAuthSnippet(headers[header]));
-        } else {
-          let authKey = headers[header].replace(`${authSources.header[headerLc]} `, '');
-          if (authScheme.toLowerCase() === 'basic') {
-            authKey = Buffer.from(authKey, 'base64').toString('ascii');
-            authKey = authKey.split(':');
-          }
-
-          authData.push(buildAuthSnippet(authKey));
-        }
-
-        delete headers[header];
-      } else if (headerLc === 'content-type') {
-        // `Content-Type` headers are automatically added within the SDK so we can filter them out
-        // if they don't have parameters attached to them.
-        const parsedContentType = contentType.parse(headers[header]);
-        if (!Object.keys(parsedContentType.parameters).length) {
-          delete headers[header];
-        }
-      } else if (headerLc === 'accept') {
-        // If the `Accept` header here is not the default or first `Accept` header for the
-        // operations' request body then we should add it otherwise we can let the SDK handle it
-        // itself.
-        if (headers[header] === operation.getContentType()) {
-          delete headers[header];
-        }
-      }
-    });
-
-    if (Object.keys(headers).length > 0) {
-      metadata = Object.assign(metadata, headers);
-    }
-  }
-
-  let body;
-  switch (source.postData.mimeType) {
-    case 'application/x-www-form-urlencoded':
-      body = source.postData.paramsObj;
-      break;
-
-    case 'application/json':
-      if (source.postData.jsonObj) {
-        body = source.postData.jsonObj;
-      }
-      break;
-
-    case 'multipart/form-data':
-      if (source.postData.params) {
-        body = {};
-
-        // If there's a `Content-Type` header present in the metadata, but it's for the
-        // `multipart/form-data` request then dump it off the snippet. We shouldn't offload that
-        // unnecessary bloat of multipart boundaries to the user, instead letting the SDK handle it
-        // automatically.
-        if ('content-type' in metadata && metadata['content-type'].indexOf('multipart/form-data') === 0) {
-          delete metadata['content-type'];
-        }
-
-        source.postData.params.forEach(function (param) {
-          if (param.fileName) {
-            body[param.name] = param.fileName;
-          } else {
-            body[param.name] = param.value;
-          }
-        });
-      }
-      break;
-
-    default:
-      if (source.postData.text) {
-        body = source.postData.text;
-      }
-  }
-
-  const args = [];
-
-  let accessor = method;
-  if (operation.hasOperationId()) {
-    accessor = operation.getOperationId({ camelCase: true });
-  } else {
-    // Since we're not using an operationId as our primary accessor we need to take the current
-    // operation that we're working with and transpile back our path parameters on top of it.
-    const slugs = Object.fromEntries(
-      Object.keys(operationSlugs).map(slug => [slug.replace(/:(.*)/, '$1'), operationSlugs[slug]])
-    );
-
-    args.push(`'${decodeURIComponent(oas.replaceUrl(path, slugs))}'`);
-  }
-
-  // If we're going to be rendering out body params and metadata we should cut their character
-  // limit in half because we'll be rendering them in their own lines.
-  const inlineCharacterLimit = typeof body !== 'undefined' && Object.keys(metadata).length > 0 ? 40 : 80;
-  if (typeof body !== 'undefined') {
-    args.push(stringify(body, { inlineCharacterLimit }));
-  }
-
-  if (Object.keys(metadata).length > 0) {
-    args.push(stringify(metadata, { inlineCharacterLimit }));
-  }
-
-  if (authData.length) {
-    code.push(authData.join('\n'));
-  }
-
-  if (configData.length) {
-    code.push(configData.join('\n'));
-  }
-
-  code
-    .push(`sdk.${accessor}(${args.join(', ')})`)
-    .push(1, '.then(res => console.log(res))')
-    .push(1, '.catch(err => console.error(err));');
-
-  return code.join();
-};
-
-module.exports.info = {
-  key: 'api',
-  title: 'API',
-  link: 'https://npm.im/api',
-  description: 'Automatic SDK generation from an OpenAPI definition.',
-};