api 7.0.0-alpha.1 → 7.0.0-alpha.3

package/dist/bin.js

@@ -22,70 +22,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var commander_1 = require("commander");
-var commands_1 = __importDefault(require("./commands"));
-var pkg = __importStar(require("./packageInfo"));
-(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*/];
-        }
+const commander_1 = require("commander");
+const commands_1 = __importDefault(require("./commands"));
+const pkg = __importStar(require("./packageInfo"));
+(async () => {
+    const 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(([, cmd]) => {
+        program.addCommand(cmd);
     });
-}); })();
+    await program.parseAsync(process.argv);
+})();

package/dist/codegen/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var typescript_1 = __importDefault(require("./languages/typescript"));
+const typescript_1 = __importDefault(require("./languages/typescript"));
 function codegen(language, spec, specPath, identifier) {
     switch (language) {
         case 'js':
@@ -17,7 +17,7 @@ function codegen(language, spec, specPath, identifier) {
                 compilerTarget: language === 'js-cjs' ? 'cjs' : 'esm',
             });
         default:
-            throw new TypeError("Unsupported language supplied: ".concat(language));
+            throw new TypeError(`Unsupported language supplied: ${language}`);
     }
 }
 exports.default = codegen;

package/dist/codegen/language.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var packageInfo_1 = require("../packageInfo");
-var CodeGeneratorLanguage = /** @class */ (function () {
-    function CodeGeneratorLanguage(spec, specPath, identifier) {
+const packageInfo_1 = require("../packageInfo");
+class CodeGeneratorLanguage {
+    spec;
+    specPath;
+    identifier;
+    userAgent;
+    requiredPackages;
+    constructor(spec, specPath, identifier) {
         this.spec = spec;
         this.specPath = specPath;
         this.identifier = identifier;
         // 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, ")");
+        const info = spec.getDefinition().info;
+        this.userAgent = `${identifier}/${info.version} (${packageInfo_1.PACKAGE_NAME}/${packageInfo_1.PACKAGE_VERSION})`;
         /**
          * This check is barbaric but there are a number of issues with how the `transformer` work we
          * have in `oas` and in `.getParametersAsJSONSchema()` and `.getResponseAsJSONSchema()` that
@@ -25,9 +30,8 @@ var CodeGeneratorLanguage = /** @class */ (function () {
             throw new Error('Sorry, this library does not yet support generating an SDK for an OpenAPI definition that contains circular references.');
         }
     }
-    CodeGeneratorLanguage.prototype.hasRequiredPackages = function () {
+    hasRequiredPackages() {
         return Boolean(Object.keys(this.requiredPackages));
-    };
-    return CodeGeneratorLanguage;
-}());
+    }
+}
 exports.default = CodeGeneratorLanguage;

package/dist/codegen/languages/typescript/util.js

@@ -4,16 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTypeName = exports.docblockEscape = exports.wordWrap = void 0;
-var lodash_camelcase_1 = __importDefault(require("lodash.camelcase"));
-var lodash_deburr_1 = __importDefault(require("lodash.deburr"));
-var lodash_startcase_1 = __importDefault(require("lodash.startcase"));
+const lodash_camelcase_1 = __importDefault(require("lodash.camelcase"));
+const lodash_deburr_1 = __importDefault(require("lodash.deburr"));
+const lodash_startcase_1 = __importDefault(require("lodash.startcase"));
 /**
  * This is a mix of reserved JS words and keywords in TypeScript that might be reserved or
  * allowable but functionally confusing (like `let any = 'buster';`)
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar}
  */
-var RESERVED_WORDS = [
+const RESERVED_WORDS = [
     'abstract',
     'any',
     'arguments',
@@ -105,9 +105,8 @@ var RESERVED_WORDS = [
 /**
  * @see {@link https://www.30secondsofcode.org/js/s/word-wrap}
  */
-function wordWrap(str, max) {
-    if (max === void 0) { max = 88; }
-    return str.replace(new RegExp("(?![^\\n]{1,".concat(max, "}$)([^\\n]{1,").concat(max, "})\\s"), 'g'), '$1\n');
+function wordWrap(str, max = 88) {
+    return str.replace(new RegExp(`(?![^\\n]{1,${max}}$)([^\\n]{1,${max}})\\s`, 'g'), '$1\n');
 }
 exports.wordWrap = wordWrap;
 /**
@@ -139,36 +138,32 @@ function toSafeString(str) {
         // replace chars which are not valid for typescript identifiers with whitespace
         .replace(/(^\s*[^a-zA-Z_$])|([^a-zA-Z_$\d])/g, ' ')
         // uppercase leading underscores followed by lowercase
-        .replace(/^_[a-z]/g, function (match) { return match.toUpperCase(); })
+        .replace(/^_[a-z]/g, (match) => match.toUpperCase())
         // remove non-leading underscores followed by lowercase (convert snake_case)
-        .replace(/_[a-z]/g, function (match) { return match.substr(1, match.length).toUpperCase(); })
+        .replace(/_[a-z]/g, (match) => match.substr(1, match.length).toUpperCase())
         // uppercase letters after digits, dollars
-        .replace(/([\d$]+[a-zA-Z])/g, function (match) { return match.toUpperCase(); })
+        .replace(/([\d$]+[a-zA-Z])/g, (match) => match.toUpperCase())
         // uppercase first letter after whitespace
-        .replace(/\s+([a-zA-Z])/g, function (match) { return match.toUpperCase().trim(); })
+        .replace(/\s+([a-zA-Z])/g, (match) => match.toUpperCase().trim())
         // remove remaining whitespace
         .replace(/\s/g, ''));
 }
-function generateTypeName() {
-    var parts = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        parts[_i] = arguments[_i];
-    }
-    var str;
+function generateTypeName(...parts) {
+    let str;
     // If the end of our string ends with something like `2XX`, the combination of `startCase` and
     // `camelCase` will transform it into `2Xx`.
     if (parts.length > 1) {
-        var last = parts[parts.length - 1];
+        const last = parts[parts.length - 1];
         if (last.match(/^(\d)XX$/)) {
             str = (0, lodash_startcase_1.default)((0, lodash_camelcase_1.default)(parts.slice(0, -1).join(' ')));
-            str += " ".concat(last);
+            str += ` ${last}`;
         }
     }
     if (!str) {
         str = (0, lodash_startcase_1.default)((0, lodash_camelcase_1.default)(parts.join(' ')));
     }
     if (RESERVED_WORDS.includes(str.toLowerCase())) {
-        str = "$".concat(str);
+        str = `$${str}`;
     }
     return toSafeString(str);
 }

package/dist/codegen/languages/typescript.d.ts

@@ -1,8 +1,8 @@
 import type Storage from '../../storage';
 import type { InstallerOptions } from '../language';
 import type Oas from 'oas';
-import type { Operation } from 'oas';
-import type { HttpMethods, SchemaObject } from 'oas/dist/rmoas.types';
+import type Operation from 'oas/operation';
+import type { HttpMethods, SchemaObject } from 'oas/rmoas.types';
 import type { ClassDeclaration, JSDocStructure, JSDocTagStructure, OptionalKind } from 'ts-morph';
 import { Project } from 'ts-morph';
 import CodeGeneratorLanguage from '../language';
@@ -91,7 +91,7 @@ export default class TSGenerator extends CodeGeneratorLanguage {
      * usable TypeScript types.
      *
      */
-    prepareParameterTypesForOperation(operation: Operation, operationId: string): false | Record<"formData" | "body" | "metadata", string>;
+    prepareParameterTypesForOperation(operation: Operation, operationId: string): false | Record<"body" | "formData" | "metadata", string>;
     /**
      * Compile the response schemas for an API operation into usable TypeScript types.
      *