api 4.5.1 → 5.0.0-beta.2

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2020 ReadMe
+Copyright © 2022 ReadMe
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the “Software”), to deal in

package/README.md

@@ -1,180 +1,50 @@
-# 🚀 api
+<p align="center">
+  <img width="400" src="https://raw.githubusercontent.com/readmeio/api/main/docs/images/logo.svg" />
+</p>
 
-[![npm](https://img.shields.io/npm/v/api)](https://npm.im/api) [![Build](https://github.com/readmeio/api/workflows/CI/badge.svg)](https://github.com/readmeio/api)
+<p align="center">
+  Magical SDK generation from an OpenAPI definition 🪄
+</p>
 
-Automatic SDK generation from an OpenAPI definition.
+<p align="center">
+  <a href="https://npm.im/api"><img src="https://img.shields.io/npm/v/api.svg?style=for-the-badge" alt="NPM Version"></a>
+  <a href="https://npm.im/api"><img src="https://img.shields.io/node/v/api.svg?style=for-the-badge" alt="Node Version"></a>
+  <a href="https://npm.im/api"><img src="https://img.shields.io/npm/l/api.svg?style=for-the-badge" alt="MIT License"></a>
+  <a href="https://github.com/readmeio/api"><img src="https://img.shields.io/github/workflow/status/readmeio/api/CI.svg?style=for-the-badge" alt="Build status"></a>
+</p>
 
-* [Installation](#installation)
-* [Usage](#usage)
-    * [Authentication](#authentication)
-    * [Parameters and Payloads](#parameters-and-payloads)
-    * [HTTP requests](#http-requests)
-    * [Server configurations](#server-configurations)
-* [How does it work?](#how-does-it-work)
-* [Interested in contributing?](#interested-in-contributing)
-* [FAQ](#faq)
+- [Installation](https://api.readme.dev/docs/installation)
+- [Usage](https://api.readme.dev/docs/usage)
+  - [Authentication](https://api.readme.dev/docs/authentication)
+  - [Parameters and Payloads](https://api.readme.dev/docs/parameters-and-payloads)
+  - [HTTP requests](https://api.readme.dev/docs/http-requests)
+  - [Server configurations](https://api.readme.dev/docs/server-configurations)
+- [How does it work?](https://api.readme.dev/docs/how-it-works)
+- [FAQ](https://api.readme.dev/docs/faq)
 
-## Installation
-```
-npm install api --save
-```
-
-## Usage
-Using `api` is as simple as supplying it an OpenAPI and using the SDK as you would any other!
-
-```js
-const sdk = require('api')('https://raw.githubusercontent.com/readmeio/oas-examples/main/3.0/json/petstore.json');
-
-sdk.listPets().then(res => {
-  console.log(`My pets name is ${res[0].name}!`);
-});
-```
-
-The OpenAPI definition is automatically downloaded, cached, and transformed into a chainable [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) Promise that you can use to make API requests.
-
-### Authentication
-`api` supports API authentication through an `.auth()` method:
-
-```js
-sdk.auth('myApiToken');
-sdk.listPets().then(...);
-```
-
-With the exception of OpenID, it supports all forms of authentication supported by the OpenAPI specification! Just give `.auth()` your credentials and it'll figure out how to use it according to the API you're using.
-
-For example:
-
-* HTTP Basic auth: `sdk.auth('username', 'password')`
-* Bearer tokens (HTTP or OAuth 2): `sdk.auth('myBearerToken')`
-* API Keys: `sdk.auth('myApiKey')`
-
-> ℹ️ Note that `sdk.auth()` is not chainable.
-
-### Parameters and Payloads
-When supplying parameters and/or request body payloads to an API request, you don't need to explicitly define what goes where since the API definition contains all that information. All you need to do is supply either one or two objects:
-
-* `body`: This will contain all data required for a request body payload for a POST, PUT, etc. request. It can either be an array or an object — whichever you need to use the API operation you're using.
-* `metadata`: This is an object where all parameters (path, query, header, cookie) go. Again, don't worry about telling the SDK that a path parameter is for the path, that's all handled for you.
-
-For example, if you wanted to make a simple GET request:
-
-```js
-sdk.showPetById({ petId: 1234 }).then(...)
-```
-
-Since `petId` matches up with the `petId` path parameter, the SDK here will issue a GET request against `/pets/1234`.
-
-What about a POST request?
-
-```js
-sdk.createPets({ name: 'Buster' }).then(...)
-```
-
-Since `name` here would correspond on `createPets` to request body payload, this will issue a POST request against `/pets` to make a new pet named "Buster".
-
-What about operations that require both? Well you can mix them too!
-
-```js
-sdk.updatePet({ name: 'Buster 2' }, { petId: 1234 }).then(...)
-```
-
-Since we've supplied two objects here, the SDK automatically knows that you're supplying both a `body` and `metadata`, and can make a PUT request against `/pets/1234` for you.
-
-What about a `multipart/form-data` request? That works too, and you don't even have to worry about the fun of multipart boundaries!
+`api` is a library that facilitates creating an SDK from an OpenAPI definition. You can use its codegen offering to create an opinionated SDK for TypeScript or JS (+ TypeScript types).
 
-```js
-sdk.uploadFile({ file: '/path/to/a/file.txt' }).then(...)
+```sh
+$ npx api install https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.json
 ```
 
-You can also give it a stream and it'll handle all of the hard work for you.
-
 ```js
-sdk.uploadFile({ file: fs.createReadStream('/path/to/a/file.txt') }).then(...)
-```
-
-### HTTP requests
-If the API you're using doesn't have any documented operation IDs, you can make requests with HTTP verbs instead:
-
-```js
-sdk.get('/pets/{petId}', { petId: 1234 }).then(...)
-```
-
-The SDK supports GET, PUT, POST, DELETE, OPTIONS, HEAD, and TRACE requests.
-
-### Server configurations
-If the API you're using offers alternate server URLs and server variables in its [`servers`](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#serverObject) definition you can supply this to the SDK with `.server()`:
+const SDK = require('@api/petstore');
 
-```js
-sdk.server('https://{region}.api.example.com/{basePath}', {
-  name: 'eu',
-  basePath: 'v14',
+const petstore = new SDK();
+petstore.listPets().then(res => {
+  console.log(`My pets name is ${res[0].name}!`);
 });
-
-sdk.get('/pets').then(...)
-```
-
-When your request is executed it will be made to `https://eu.api.example.com/v14/pets`. Alternatively if you don't want to deal with URL templates you can opt to pass the full URL in instead:
-
-```js
-sdk.server('https://eu.api.example.com/v14');
-```
-
-## How does it work?
-Behind the scenes, `api` will:
-
-1. Download the supplied OpenAPI definition, either from a publically accessible URLs or an absolute/relative path.
-2. Dereference the definition so it's easier for us to handle.
-3. Hash the definition and cache it into a directory in `node_modules/.cache/api/`.
-4. Process the definition and instantiate chainable methods for HTTP verbs and operation IDs the API contains via a JS [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy).
-
-On subsequent requests, `api` will look in its cache, and if the supplied definition exists there, it'll retrieve it from the cache instead of re-retrieving it again.
-
-## Interested in contributing?
-Welcome! Have a look at [CONTRIBUTING.md](CONTRIBUTING.md).
-
-## FAQ
-#### Does this support YAML definitions?
-Yes! YAML definitions will be automatically converted to JSON before they're cached and loaded as an SDK.
-
-#### Does this support Swagger 2.0 definitions?
-At the moment it does not. If you wish to use an API that has a Swagger 2.0 file, you'll need to first convert it to an OpenAPI 3 definition.
-
-#### Does this support traditional OAuth 2 flows of creating tokens?
-Not yet, unfortunately. For APIs that use OAuth 2, you'll need a fully-qualified token already for `api` to make requests.
-
-#### Does this support APIs that use multiple forms of authentication on a single request?
-Not yet! This is something we're thinking about how to handle, but it's difficult with the simple nature of the `.auth()` method as it currently does not require the user to inform the SDK of what kind of authentication scheme the token they're supplying it should match up against.
-
-#### Will this work in browsers?
-Not at the moment as the library requires some filesystem handling in order to manage its cache state, but it's something we're actively thinking about. If you'd like to help us out in making this compatible with browsers we'd love to help you out on a pull request.
-
-#### Will this validate my data before it reaches the API?
-Not yet! This is something we've got planned down the road.
-
-#### Does this support OpenAPI definitions that require authentication to download?
-Not yet! The URL that you give the module must be publicy accessible. If it isn't, you can download it to your computer/server and then use the absolute path to that file instead.
-
-```js
-const sdk = require('api')('/path/to/downloaded.json');
 ```
 
-#### How do I access the Response object (for status and headers)?
-By default we parse the response based on the `content-type` header for you. You can disable this by doing the following:
+Or you can use it dynamically (though you won't have fancy TypeScript types):
 
 ```js
-sdk.config({ parseResponse: false });
-```
-
-#### Where is the cache stored?
-
-By default the cache is configured with the [find-cache-dir](https://npm.im/find-cache-dir) library so the cache will be in `node_modules/.cache/api`. If placing this cache within the `node_modules/` directory is a problem for your environment (maybe you use `npm prune`) you can configure this by supplying an additional argument to the SDK instantiator:
-
-```js
-const sdk = require('api')('https://raw.githubusercontent.com/readmeio/oas-examples/main/3.0/json/petstore.json', {
-  cacheDir: './path/to/my/custom/cache/dir',
-});
+const petstore = require('api')(
+  'https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.json'
+);
 
-sdk.listPets().then(res => {
+petstore.listPets().then(res => {
   console.log(`My pets name is ${res[0].name}!`);
 });
 ```

package/bin/api

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/bin');

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var commander_1 = require("commander");
+var pkg = __importStar(require("./packageInfo"));
+var commands_1 = __importDefault(require("./cli/commands"));
+(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var program;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                program = new commander_1.Command();
+                program.name(pkg.PACKAGE_NAME);
+                program.version(pkg.PACKAGE_VERSION);
+                /**
+                 * Instead of using Commander's `executableDir` API for loading in external command files we're
+                 * programatically doing it like this because it's cleaner for us to let Commander manage option
+                 * and argument parsing within this file than having each command  manage that itself.
+                 */
+                Object.entries(commands_1["default"]).forEach(function (_a) {
+                    var cmd = _a[1];
+                    program.addCommand(cmd);
+                });
+                return [4 /*yield*/, program.parseAsync(process.argv)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); })();

package/dist/cache.d.ts

@@ -0,0 +1,30 @@
+import type { OASDocument } from 'oas/@types/rmoas.types';
+import 'isomorphic-fetch';
+import Fetcher from './fetcher';
+declare type CacheStore = Record<string, {
+    hash: string;
+    path?: string;
+    original: string | OASDocument;
+    title?: string;
+    version?: string;
+}>;
+export default class Cache {
+    static dir: string;
+    static cacheStore: string;
+    static specsCache: string;
+    uri: string | OASDocument;
+    uriHash: string;
+    cached: false | CacheStore;
+    fetcher: Fetcher;
+    constructor(uri: string | OASDocument, cacheDir?: string | false);
+    static getCacheHash(file: string | OASDocument): string;
+    static setCacheDir(dir?: string | false): void;
+    static reset(): Promise<void>;
+    static validate(json: any): Promise<import("openapi-types").OpenAPI.Document<{}>>;
+    isCached(): boolean;
+    getCache(): CacheStore;
+    get(): any;
+    load(): Promise<OASDocument>;
+    save(spec: OASDocument): OASDocument;
+}
+export {};

package/dist/cache.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+require("isomorphic-fetch");
+var openapi_parser_1 = __importDefault(require("@readme/openapi-parser"));
+var crypto_1 = __importDefault(require("crypto"));
+var find_cache_dir_1 = __importDefault(require("find-cache-dir"));
+var fs_1 = __importDefault(require("fs"));
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
+var make_dir_1 = __importDefault(require("make-dir"));
+var packageInfo_1 = require("./packageInfo");
+var fetcher_1 = __importDefault(require("./fetcher"));
+var Cache = /** @class */ (function () {
+    function Cache(uri, cacheDir) {
+        if (cacheDir === void 0) { cacheDir = false; }
+        Cache.setCacheDir(cacheDir);
+        Cache.cacheStore = path_1["default"].join(Cache.dir, 'cache.json');
+        Cache.specsCache = path_1["default"].join(Cache.dir, 'specs');
+        this.fetcher = new fetcher_1["default"](uri);
+        this.uri = this.fetcher.uri;
+        this.uriHash = Cache.getCacheHash(this.uri);
+        // This should default to false so we have awareness if we've looked at the cache yet.
+        this.cached = false;
+    }
+    Cache.getCacheHash = function (file) {
+        var data;
+        if (typeof file === 'object') {
+            // Under certain unit testing circumstances, we might be supplying the class with a raw JSON
+            // object so we'll need to convert it to a string in order to hand it off to the crypto
+            // module.
+            data = JSON.stringify(file);
+        }
+        else {
+            data = file;
+        }
+        return crypto_1["default"].createHash('md5').update(data).digest('hex');
+    };
+    Cache.setCacheDir = function (dir) {
+        if (dir) {
+            Cache.dir = dir;
+            return;
+        }
+        else if (Cache.dir) {
+            // If we already have a cache dir set and aren't explicitly it to something new then we
+            // shouldn't overwrite what we've already got.
+            return;
+        }
+        Cache.dir = (0, find_cache_dir_1["default"])({ name: packageInfo_1.PACKAGE_NAME });
+        if (typeof Cache.dir === 'undefined') {
+            // The `find-cache-dir` module returns `undefined` if the `node_modules/` directory isn't
+            // writable, or there's no `package.json` in the root-most directory. If this happens, we can
+            // instead adhoc create a cache directory in the users OS temp directory and store our data
+            // there.
+            //
+            // @link https://github.com/avajs/find-cache-dir/issues/29
+            Cache.dir = make_dir_1["default"].sync(path_1["default"].join(os_1["default"].tmpdir(), packageInfo_1.PACKAGE_NAME));
+        }
+    };
+    Cache.reset = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Cache.cacheStore) return [3 /*break*/, 2];
+                        return [4 /*yield*/, fs_1["default"].promises.rm(Cache.cacheStore)["catch"](function () {
+                                // no-op
+                            })];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!Cache.specsCache) return [3 /*break*/, 4];
+                        return [4 /*yield*/, fs_1["default"].promises.rm(Cache.specsCache, { recursive: true })["catch"](function () {
+                                // no-op
+                            })];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Cache.validate = function (json) {
+        if (json.swagger) {
+            throw new Error('Sorry, this module only supports OpenAPI definitions.');
+        }
+        // The `validate` method handles dereferencing for us.
+        return openapi_parser_1["default"].validate(json, {
+            dereference: {
+                // If circular `$refs` are ignored they'll remain in the API definition as `$ref: String`.
+                // This allows us to not only do easy circular reference detection but also stringify and
+                // save dereferenced API definitions back into the cache directory.
+                circular: 'ignore'
+            }
+        })["catch"](function (err) {
+            if (/is not a valid openapi definition/i.test(err.message)) {
+                throw new Error("Sorry, that doesn't look like a valid OpenAPI definition.");
+            }
+            throw err;
+        });
+    };
+    Cache.prototype.isCached = function () {
+        var cache = this.getCache();
+        return cache && this.uriHash in cache;
+    };
+    Cache.prototype.getCache = function () {
+        if (typeof this.cached === 'object') {
+            return this.cached;
+        }
+        this.cached = {};
+        if (fs_1["default"].existsSync(Cache.cacheStore)) {
+            this.cached = JSON.parse(fs_1["default"].readFileSync(Cache.cacheStore, 'utf8'));
+        }
+        return this.cached;
+    };
+    Cache.prototype.get = function () {
+        // If the class was supplied a raw object, just go ahead and bypass the caching system and
+        // return that.
+        if (typeof this.uri === 'object') {
+            return this.uri;
+        }
+        if (!this.isCached()) {
+            throw new Error("".concat(this.uri, " has not been cached yet and must do so before being retrieved."));
+        }
+        var cache = this.getCache();
+        // Prior to v4.5.0 we were putting a fully resolved path to the API definition in the cache
+        // store but if you had specified a custom caching directory and would generate the cache on
+        // your system, that filepath would obviously not be the same in other environments. For this
+        // reason the `path` was removed from the cache store in favor of storing the `hash` instead.
+        //
+        // If we still have `path` in the config cache for backwards compatibility we should use it.
+        if ('path' in cache[this.uriHash]) {
+            return JSON.parse(fs_1["default"].readFileSync(cache[this.uriHash].path, 'utf8'));
+        }
+        return JSON.parse(fs_1["default"].readFileSync(path_1["default"].join(Cache.specsCache, "".concat(cache[this.uriHash].hash, ".json")), 'utf8'));
+    };
+    Cache.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                // If the class was supplied a raw object, just go ahead and bypass the caching system and
+                // return that.
+                if (typeof this.uri === 'object') {
+                    return [2 /*return*/, this.uri];
+                }
+                return [2 /*return*/, this.fetcher.load().then(function (spec) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, this.save(spec)];
+                    }); }); })];
+            });
+        });
+    };
+    Cache.prototype.save = function (spec) {
+        if (!fs_1["default"].existsSync(Cache.dir)) {
+            fs_1["default"].mkdirSync(Cache.dir, { recursive: true });
+        }
+        if (!fs_1["default"].existsSync(Cache.specsCache)) {
+            fs_1["default"].mkdirSync(Cache.specsCache, { recursive: true });
+        }
+        var cache = this.getCache();
+        if (!(this.uriHash in cache)) {
+            var saved = JSON.stringify(spec, null, 2);
+            var fileHash = crypto_1["default"].createHash('md5').update(saved).digest('hex');
+            cache[this.uriHash] = {
+                hash: fileHash,
+                original: this.uri,
+                title: 'title' in spec.info ? spec.info.title : undefined,
+                version: 'version' in spec.info ? spec.info.version : undefined
+            };
+            fs_1["default"].writeFileSync(path_1["default"].join(Cache.specsCache, "".concat(fileHash, ".json")), saved);
+            fs_1["default"].writeFileSync(Cache.cacheStore, JSON.stringify(cache, null, 2));
+            this.cached = cache;
+        }
+        return spec;
+    };
+    return Cache;
+}());
+exports["default"] = Cache;

package/dist/cli/codegen/index.d.ts

@@ -0,0 +1,4 @@
+import type Oas from 'oas';
+import type CodeGeneratorLanguage from './language';
+export declare type SupportedLanguages = 'js' | 'js-cjs' | 'js-esm' | 'ts';
+export default function codegen(language: SupportedLanguages, spec: Oas, specPath: string, identifier: string): CodeGeneratorLanguage;

package/dist/cli/codegen/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var typescript_1 = __importDefault(require("./languages/typescript"));
+function codegen(language, spec, specPath, identifier) {
+    switch (language) {
+        case 'js':
+            throw new TypeError('An export format of CommonJS or ECMAScript is required for JavaScript compilation.');
+        case 'js-cjs':
+        case 'js-esm':
+        case 'ts':
+            return new typescript_1["default"](spec, specPath, identifier, {
+                outputJS: ['js-cjs', 'js-esm'].includes(language),
+                // TS will always generate with ESM-like exports.
+                compilerTarget: language === 'js-cjs' ? 'cjs' : 'esm'
+            });
+        default:
+            throw new TypeError("Unsupported language supplied: ".concat(language));
+    }
+}
+exports["default"] = codegen;

package/dist/cli/codegen/language.d.ts

@@ -0,0 +1,27 @@
+import type Oas from 'oas';
+import type Storage from '../storage';
+export interface InstallerOptions {
+    /**
+     * Will initiate a dry run install process. Used for simulating installations within a unit test.
+     */
+    dryRun?: boolean;
+    /**
+     * Used for stubbing out the logger that we use within the installation process so it can be
+     * easily introspected without having to mock out `console.*`.
+     */
+    logger?: (msg: string) => void;
+}
+export default abstract class CodeGeneratorLanguage {
+    spec: Oas;
+    specPath: string;
+    identifier: string;
+    userAgent: string;
+    requiredPackages: Record<string, {
+        reason: string;
+        url: string;
+    }>;
+    constructor(spec: Oas, specPath: string, identifier: string);
+    abstract generator(): Promise<Record<string, string>>;
+    abstract installer(storage: Storage, opts?: InstallerOptions): Promise<void>;
+    hasRequiredPackages(): boolean;
+}

package/dist/cli/codegen/language.js

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+var packageInfo_1 = require("../../packageInfo");
+var CodeGeneratorLanguage = /** @class */ (function () {
+    function CodeGeneratorLanguage(spec, specPath, identifier) {
+        this.spec = spec;
+        this.specPath = specPath;
+        // User agents should be contextual to the spec in question and the version of `api` that was
+        // used to generate the SDK. For example, this'll look like `petstore/1.0.0 (api/4.2.0)` for
+        // a `petstore` spec installed on api@4.2.0.
+        var info = spec.getDefinition().info;
+        this.userAgent = "".concat(identifier, "/").concat(info.version, " (").concat(packageInfo_1.PACKAGE_NAME, "/").concat(packageInfo_1.PACKAGE_VERSION, ")");
+    }
+    CodeGeneratorLanguage.prototype.hasRequiredPackages = function () {
+        return Boolean(Object.keys(this.requiredPackages));
+    };
+    return CodeGeneratorLanguage;
+}());
+exports["default"] = CodeGeneratorLanguage;