api 7.0.0-alpha.2 → 7.0.0-alpha.5

package/src/commands/index.ts

@@ -1,4 +1,4 @@
-import installCommand from './install';
+import installCommand from './install.js';
 
 export default {
   install: installCommand,

package/src/commands/install.ts

@@ -1,15 +1,13 @@
-import type { SupportedLanguages } from '../codegen';
-
 import { Command, Option } from 'commander';
 import figures from 'figures';
 import Oas from 'oas';
 import ora from 'ora';
 
-import codegen from '../codegen';
-import Fetcher from '../fetcher';
-import promptTerminal from '../lib/prompt';
-import logger from '../logger';
-import Storage from '../storage';
+import codegenFactory, { SupportedLanguages } from '../codegen/factory.js';
+import Fetcher from '../fetcher.js';
+import promptTerminal from '../lib/prompt.js';
+import logger from '../logger.js';
+import Storage from '../storage.js';
 
 // @todo log logs to `.api/.logs` and have `.logs` ignored
 const cmd = new Command();
@@ -19,12 +17,7 @@ cmd
   .argument('<uri>', 'an API to install')
   .option('-i, --identifier <identifier>', 'API identifier (eg. `@api/petstore`)')
   .addOption(
-    new Option('-l, --lang <language>', 'SDK language').choices([
-      'js', // User generally wants JS, we'll prompt if they want CJS or ESM files.
-      'js-cjs',
-      'js-esm',
-      'ts',
-    ]),
+    new Option('-l, --lang <language>', 'SDK language').default(SupportedLanguages.JS).choices([SupportedLanguages.JS]),
   )
   .addOption(new Option('-y, --yes', 'Automatically answer "yes" to any prompts printed'))
   .action(async (uri: string, options: { identifier?: string; lang: string; yes?: boolean }) => {
@@ -36,29 +29,11 @@ cmd
         type: 'select',
         name: 'value',
         message: 'What language would you like to generate an SDK for?',
-        choices: [
-          { title: 'TypeScript', value: 'ts' },
-          { title: 'JavaScript', value: 'js' },
-        ],
+        choices: [{ title: 'JavaScript', value: SupportedLanguages.JS }],
         initial: 1,
       }));
     }
 
-    // Because our TS generation outputs raw TS source files we don't need to worry about CJS/ESM.
-    if (language === 'js') {
-      ({ value: language } = await promptTerminal({
-        type: 'select',
-        name: 'value',
-        message: 'How are your project imports and exports structured?',
-        choices: [
-          { title: 'CommonJS', description: 'require/exports', value: 'cjs' },
-          { title: 'ECMAScript Modules', description: 'import/export', value: 'esm' },
-        ],
-        initial: 0,
-        format: sel => (sel === 'cjs' ? 'js-cjs' : 'js-esm'),
-      }));
-    }
-
     // @todo let them know that we're going to be creating a `.api/ directory
     // @todo detect if they have a gitigore and .npmignore and if .api woudl be ignored by that
     // @todo don't support swagger files without upconverting them
@@ -120,9 +95,9 @@ cmd
 
     // @todo look for a prettier config and if we find one ask them if we should use it
     spinner = ora('Generating your SDK').start();
-    const generator = codegen(language, oas, './openapi.json', identifier);
+    const generator = codegenFactory(language, oas, '../openapi.json', identifier);
     const sdkSource = await generator
-      .generator()
+      .generate()
       .then(res => {
         spinner.succeed(spinner.text);
         return res;
@@ -170,7 +145,7 @@ cmd
 
       spinner = ora('Installing required packages').start();
       try {
-        await generator.installer(storage);
+        await generator.install(storage);
         spinner.succeed(spinner.text);
       } catch (err) {
         // @todo cleanup installed files
@@ -180,6 +155,17 @@ cmd
       }
     }
 
+    spinner = ora('Compiling your SDK').start();
+    try {
+      await generator.compile(storage);
+      spinner.succeed(spinner.text);
+    } catch (err) {
+      // @todo cleanup installed files
+      spinner.fail(spinner.text);
+      logger(err.message, true);
+      process.exit(1);
+    }
+
     logger('🚀 All done!');
   })
   .addHelpText(

package/src/packageInfo.ts

@@ -1,3 +1,3 @@
 // This file is automatically updated by the build script.
 export const PACKAGE_NAME = 'api';
-export const PACKAGE_VERSION = '7.0.0-alpha.2';
+export const PACKAGE_VERSION = '7.0.0-alpha.5';

package/src/storage.ts

@@ -3,12 +3,11 @@ import type { OASDocument } from 'oas/rmoas.types';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import makeDir from 'make-dir';
 import ssri from 'ssri';
 import validateNPMPackageName from 'validate-npm-package-name';
 
-import Fetcher from './fetcher';
-import { PACKAGE_VERSION } from './packageInfo';
+import Fetcher from './fetcher.js';
+import { PACKAGE_VERSION } from './packageInfo.js';
 
 export default class Storage {
   static dir: string;
@@ -57,9 +56,10 @@ export default class Storage {
       return;
     }
 
-    Storage.dir = makeDir.sync(path.join(process.cwd(), '.api'));
+    Storage.dir = path.join(process.cwd(), '.api');
 
-    makeDir.sync(Storage.getAPIsDir());
+    fs.mkdirSync(Storage.dir, { recursive: true });
+    fs.mkdirSync(Storage.getAPIsDir(), { recursive: true });
   }
 
   /**
@@ -194,6 +194,15 @@ export default class Storage {
       Object.entries(files).forEach(([fileName, contents]) => {
         const sourceFilePath = path.join(this.getIdentifierStorageDir(), fileName);
 
+        // If this file is stored in a subdirectory then we need to create it.
+        if (path.dirname(fileName) !== '.') {
+          const dir = path.dirname(fileName);
+          const dirPath = path.join(this.getIdentifierStorageDir(), dir);
+          if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath);
+          }
+        }
+
         fs.writeFileSync(sourceFilePath, contents);
 
         savedSource.push(sourceFilePath);

package/tsconfig.json

@@ -1,16 +1,9 @@
 {
+  "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "allowJs": true,
-    "baseUrl": "./src",
-    "declaration": true,
     "esModuleInterop": true,
-    "lib": ["DOM", "DOM.Iterable", "ES2020"],
-    "module": "NodeNext",
-    "noImplicitAny": true,
-    "outDir": "dist/",
-    "skipLibCheck": true,
-    "strict": true,
-    "useUnknownInCatchVariables": false
+    "lib": ["DOM", "DOM.Iterable", "ES2023"],
+    "outDir": "dist/"
   },
   "include": ["./src/**/*"]
 }

package/bin/api

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

package/dist/codegen/index.d.ts

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

package/dist/codegen/index.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const 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: ${language}`);
-    }
-}
-exports.default = codegen;

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

@@ -1,111 +0,0 @@
-import type Storage from '../../storage';
-import type { InstallerOptions } from '../language';
-import type Oas from 'oas';
-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';
-export interface TSGeneratorOptions {
-    compilerTarget?: 'cjs' | 'esm';
-    outputJS?: boolean;
-}
-interface OperationTypeHousing {
-    operation: Operation;
-    types: {
-        params?: false | Record<'body' | 'formData' | 'metadata', string>;
-        responses?: Record<string | number, {
-            description?: string;
-            type: string;
-        }>;
-    };
-}
-export default class TSGenerator extends CodeGeneratorLanguage {
-    project: Project;
-    outputJS: boolean;
-    compilerTarget: 'cjs' | 'esm';
-    types: Map<string, string>;
-    sdk: ClassDeclaration;
-    schemas: Record<string, {
-        body?: unknown;
-        metadata?: unknown;
-        response?: Record<string, unknown>;
-    } | Record<string, unknown>>;
-    usesHTTPMethodRangeInterface: boolean;
-    constructor(spec: Oas, specPath: string, identifier: string, opts?: TSGeneratorOptions);
-    installer(storage: Storage, opts?: InstallerOptions): Promise<void>;
-    /**
-     * Compile the current OpenAPI definition into a TypeScript library.
-     *
-     */
-    generator(): Promise<{
-        [x: string]: string;
-    }>;
-    /**
-     * Create our main SDK source file.
-     *
-     */
-    createSourceFile(): import("ts-morph").SourceFile;
-    /**
-     * Create our main schemas file. This is where all of the JSON Schema that our TypeScript typing
-     * infrastructure sources its data from. Without this there are no types.
-     *
-     */
-    createSchemasFile(): import("ts-morph").SourceFile;
-    /**
-     * Create our main types file. This sources its data from the JSON Schema `schemas.ts` file and
-     * will re-export types to be used in TypeScript implementations and IDE intellisense. This
-     * typing work is functional with the `json-schema-to-ts` library.
-     *
-     * @see {@link https://npm.im/json-schema-to-ts}
-     */
-    createTypesFile(): import("ts-morph").SourceFile;
-    /**
-     * Add a new JSDoc `@tag` to an existing docblock.
-     *
-     */
-    static addTagToDocblock(docblock: OptionalKind<JSDocStructure>, tag: OptionalKind<JSDocTagStructure>): {
-        tags: OptionalKind<JSDocTagStructure>[];
-        description?: string | import("ts-morph").WriterFunction | undefined;
-        leadingTrivia?: string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[] | undefined;
-        trailingTrivia?: string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[] | undefined;
-        kind?: import("ts-morph").StructureKind.JSDoc | undefined;
-    };
-    /**
-     * Create operation accessors on the SDK.
-     *
-     */
-    createOperationAccessor(operation: Operation, operationId: string, paramTypes?: OperationTypeHousing['types']['params'], responseTypes?: OperationTypeHousing['types']['responses']): void;
-    /**
-     * Scour through the current OpenAPI definition and compile a store of every operation, along
-     * with every HTTP method that's in use, and their available TypeScript types that we can use,
-     * along with every HTTP method that's in use.
-     *
-     */
-    loadOperationsAndMethods(): {
-        operations: Record<string, OperationTypeHousing>;
-        methods: Set<HttpMethods>;
-    };
-    /**
-     * Compile the parameter (path, query, cookie, and header) schemas for an API operation into
-     * usable TypeScript types.
-     *
-     */
-    prepareParameterTypesForOperation(operation: Operation, operationId: string): false | Record<"body" | "formData" | "metadata", string>;
-    /**
-     * Compile the response schemas for an API operation into usable TypeScript types.
-     *
-     */
-    prepareResponseTypesForOperation(operation: Operation, operationId: string): {
-        [x: string]: {
-            type: string;
-            description: any;
-        };
-    } | undefined;
-    /**
-     * Add a given schema into our schema dataset that we'll be be exporting as types.
-     *
-     */
-    addSchemaToExport(schema: SchemaObject, typeName: string, pointer: string): void;
-}
-export {};

package/src/codegen/index.ts

@@ -1,31 +0,0 @@
-import type CodeGeneratorLanguage from './language';
-import type Oas from 'oas';
-
-import TSGenerator from './languages/typescript';
-
-export type SupportedLanguages = 'js' | 'js-cjs' | 'js-esm' | 'ts';
-
-export default function codegen(
-  language: SupportedLanguages,
-  spec: Oas,
-  specPath: string,
-  identifier: string,
-): CodeGeneratorLanguage {
-  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 TSGenerator(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: ${language}`);
-  }
-}