api 7.0.0-alpha.3 → 7.0.0-alpha.6

package/dist/codegen/languages/{typescript.js → typescript/index.js}

@@ -1,151 +1,147 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const execa_1 = __importDefault(require("execa"));
-const lodash_setwith_1 = __importDefault(require("lodash.setwith"));
-const semver_1 = __importDefault(require("semver"));
-const ts_morph_1 = require("ts-morph");
-const logger_1 = __importDefault(require("../../logger"));
-const language_1 = __importDefault(require("../language"));
-const util_1 = require("./typescript/util");
-class TSGenerator extends language_1.default {
+import path from 'node:path';
+import corePkg from '@readme/api-core/package.json' assert { type: 'json' };
+import execa from 'execa';
+import setWith from 'lodash.setwith';
+import semver from 'semver';
+import { IndentationText, Project, QuoteKind, ScriptTarget, VariableDeclarationKind } from 'ts-morph';
+import logger from '../../../logger.js';
+import CodeGenerator from '../../codegenerator.js';
+import { docblockEscape, generateTypeName, wordWrap } from './util.js';
+/**
+ * This is the conversion prefix that we add to all `$ref` pointers we find in generated JSON
+ * Schema.
+ *
+ * Because the pointer name is a string we want to have it reference the schema constant we're
+ * adding into the codegen'd schema file. As there's no way, not even using `eval()` in this case,
+ * to convert a string to a constant we're prefixing them with this so we can later remove it and
+ * rewrite the value to a literal. eg. `'Pet'` becomes `Pet`.
+ *
+ * And because our TypeScript type name generator properly ignores `:`, this is safe to prepend to
+ * all generated type names.
+ */
+const REF_PLACEHOLDER = '::convert::';
+const REF_PLACEHOLDER_REGEX = /"::convert::([a-zA-Z_$\\d]*)"/g;
+export default class TSGenerator extends CodeGenerator {
     project;
-    outputJS;
-    compilerTarget;
     types;
     sdk;
     schemas;
     usesHTTPMethodRangeInterface = false;
-    constructor(spec, specPath, identifier, opts = {}) {
-        const options = {
-            outputJS: false,
-            compilerTarget: 'cjs',
-            ...opts,
-        };
-        if (!options.outputJS) {
-            // TypeScript compilation will always target towards ESM-like imports and exports.
-            options.compilerTarget = 'esm';
-        }
+    constructor(spec, specPath, identifier) {
         super(spec, specPath, identifier);
         this.requiredPackages = {
-            api: {
-                reason: "Required for the `@readme/api-core` library that the codegen'd SDK uses for making requests.",
+            '@readme/api-core': {
+                dependencyType: 'production',
+                reason: "The core magic of your codegen'd SDK and is what is used for making requests.",
                 url: 'https://npm.im/api',
+                version: 
+                // When running unit tests we're installing `@readme/api-core` but because that package
+                // source lives in this repository NPM will throw a gnarly "Cannot set properties of null
+                // (setting 'dev')" workspace error message because we're creating a funky circular
+                // dependency.
+                process.env.NODE_ENV === 'test'
+                    ? `file:${path.relative(__dirname, path.dirname(require.resolve('@readme/api-core/package.json')))}`
+                    : corePkg.version,
             },
             'json-schema-to-ts': {
+                dependencyType: 'production',
                 reason: 'Required for TypeScript type handling.',
                 url: 'https://npm.im/json-schema-to-ts',
+                version: '^2.9.2',
             },
-            oas: {
-                reason: 'Used within `@readme/api-core` and is also loaded for TypeScript types.',
-                url: 'https://npm.im/oas',
+            tsup: {
+                dependencyType: 'development',
+                reason: "Used for compiling your codegen'd SDK into code that can be used in JS environments.",
+                url: 'https://tsup.egoist.dev/',
+                version: '^7.2.0',
             },
-        };
-        this.project = new ts_morph_1.Project({
-            manipulationSettings: {
-                indentationText: ts_morph_1.IndentationText.TwoSpaces,
-                quoteKind: ts_morph_1.QuoteKind.Single,
+            typescript: {
+                dependencyType: 'development',
+                reason: 'Required for `tsup`.',
+                version: '^5.2.2',
             },
+        };
+        this.project = new Project({
             compilerOptions: {
-                // If we're exporting a TypeScript SDK then we don't need to pollute the codegen directory
-                // with unnecessary declaration `.d.ts` files.
-                declaration: options.outputJS,
                 outDir: 'dist',
                 resolveJsonModule: true,
-                target: options.compilerTarget === 'cjs' ? ts_morph_1.ScriptTarget.ES5 : ts_morph_1.ScriptTarget.ES2020,
-                // If we're compiling to a CJS target then we need to include this compiler option
-                // otherwise TS will attempt to load our `openapi.json` import with a `.default` property
-                // which doesn't exist. `esModuleInterop` wraps imports in a small `__importDefault`
-                // function that does some determination to see if the module has a default export or not.
-                //
-                // Basically without this option CJS code will fail.
-                ...(options.compilerTarget === 'cjs' ? { esModuleInterop: true } : {}),
+                target: ScriptTarget.ES2022,
+            },
+            manipulationSettings: {
+                indentationText: IndentationText.TwoSpaces,
+                quoteKind: QuoteKind.Single,
             },
+            useInMemoryFileSystem: true,
         });
-        this.compilerTarget = options.compilerTarget;
-        this.outputJS = options.outputJS;
         this.types = new Map();
         this.schemas = {};
     }
-    async installer(storage, opts = {}) {
+    // eslint-disable-next-line class-methods-use-this
+    async install(storage, opts = {}) {
         const installDir = storage.getIdentifierStorageDir();
-        const info = this.spec.getDefinition().info;
-        let pkgVersion = semver_1.default.coerce(info.version);
-        if (!pkgVersion) {
-            // If the version that's in `info.version` isn't compatible with semver NPM won't be able to
-            // handle it properly so we need to fallback to something it can.
-            pkgVersion = semver_1.default.coerce('0.0.0');
-        }
-        const pkg = {
-            name: `@api/${storage.identifier}`,
-            version: pkgVersion.version,
-            main: `./index.${this.outputJS ? 'js' : 'ts'}`,
-            types: './index.d.ts', // Types are always present regardless if you're getting compiled JS.
-        };
-        node_fs_1.default.writeFileSync(node_path_1.default.join(installDir, 'package.json'), JSON.stringify(pkg, null, 2));
         const npmInstall = ['install', '--save', opts.dryRun ? '--dry-run' : ''].filter(Boolean);
-        // This will install packages required for the SDK within its installed directory in `.apis/`.
-        await (0, execa_1.default)('npm', [...npmInstall, ...Object.keys(this.requiredPackages)].filter(Boolean), {
-            cwd: installDir,
-        }).then(res => {
-            if (opts.dryRun) {
-                (opts.logger ? opts.logger : logger_1.default)(res.command);
-                (opts.logger ? opts.logger : logger_1.default)(res.stdout);
-            }
-        });
         // This will install the installed SDK as a dependency within the current working directory,
         // adding `@api/<sdk identifier>` as a dependency there so you can load it with
         // `require('@api/<sdk identifier>)`.
-        return (0, execa_1.default)('npm', [...npmInstall, installDir].filter(Boolean))
+        await execa('npm', [...npmInstall, installDir].filter(Boolean))
             .then(res => {
             if (opts.dryRun) {
-                (opts.logger ? opts.logger : logger_1.default)(res.command);
-                (opts.logger ? opts.logger : logger_1.default)(res.stdout);
+                (opts.logger ? opts.logger : logger)(res.command);
+                (opts.logger ? opts.logger : logger)(res.stdout);
             }
         })
             .catch(err => {
+            // If `npm install` throws this error it always happens **after** our dependencies have been
+            // installed and is an annoying quirk that sometimes occurs when installing a package within
+            // our workspace as we're creating a circular dependency on `@readme/api-core`.
+            if (process.env.NODE_ENV === 'test' &&
+                err.message.includes("npm ERR! Cannot set properties of null (setting 'dev')")) {
+                (opts.logger ? opts.logger : logger)("npm threw an error but we're ignoring it");
+                return;
+            }
             if (opts.dryRun) {
-                (opts.logger ? opts.logger : logger_1.default)(err.message);
+                (opts.logger ? opts.logger : logger)(err.message);
                 return;
             }
             throw err;
         });
     }
     /**
-     * Compile the current OpenAPI definition into a TypeScript library.
+     * Compile the TS code we generated into JS for use in CJS and ESM environments.
      *
      */
-    async generator() {
-        const sdkSource = this.createSourceFile();
-        if (Object.keys(this.schemas).length) {
-            this.createSchemasFile();
-            this.createTypesFile();
-            /**
-             * Export all of our available types so they can be used in SDK implementations. Types are
-             * exported individually because TS has no way right now of allowing us to do
-             * `export type * from './types'` on a non-named entry.
-             *
-             * Types in the main entry point are only being exported for TS outputs as JS users won't be
-             * able to use them and it clashes with the default SDK export present.
-             *
-             * @see {@link https://github.com/microsoft/TypeScript/issues/37238}
-             * @see {@link https://github.com/readmeio/api/issues/588}
-             */
-            if (!this.outputJS) {
-                const types = Array.from(this.types.keys());
-                types.sort();
-                sdkSource.addExportDeclarations([
-                    {
-                        isTypeOnly: true,
-                        namedExports: types,
-                        moduleSpecifier: './types',
-                    },
-                ]);
+    // eslint-disable-next-line class-methods-use-this
+    async compile(storage, opts = {}) {
+        const installDir = storage.getIdentifierStorageDir();
+        await execa('npx', ['tsup'], {
+            cwd: installDir,
+        })
+            .then(res => {
+            if (opts.dryRun) {
+                (opts.logger ? opts.logger : logger)(res.command);
+                (opts.logger ? opts.logger : logger)(res.stdout);
+            }
+        })
+            .catch(err => {
+            if (opts.dryRun) {
+                (opts.logger ? opts.logger : logger)(err.message);
+                return;
             }
+            throw err;
+        });
+    }
+    /**
+     * Generate the current OpenAPI definition into a TypeScript library.
+     *
+     */
+    async generate() {
+        const srcDirectory = this.project.createDirectory('src');
+        const sdkSource = this.createSDKSource(srcDirectory);
+        this.createPackageJSON();
+        this.createTSConfig();
+        if (Object.keys(this.schemas).length) {
+            this.createSchemasFile(srcDirectory);
+            this.createTypesFile(srcDirectory);
         }
         else {
             // If we don't have any schemas then we shouldn't import a `types` file that doesn't exist.
@@ -162,43 +158,18 @@ class TSGenerator extends language_1.default {
                 .find(id => id.getText().includes('HTTPMethodRange'))
                 ?.replaceWithText("import type { ConfigOptions, FetchResponse } from '@readme/api-core';");
         }
-        if (this.outputJS) {
-            return this.project
-                .emitToMemory()
-                .getFiles()
-                .map(sourceFile => {
-                const file = node_path_1.default.basename(sourceFile.filePath);
-                if (file === 'schemas.js' || file === 'types.js') {
-                    // If we're generating a JS SDK then we don't need to generate these two files as the
-                    // user will have `.d.ts` files for them instead.
-                    return {};
-                }
-                let code = sourceFile.text;
-                if (file === 'index.js' && this.compilerTarget === 'cjs') {
-                    /**
-                     * There's an annoying quirk with `ts-morph` where if we're exporting a default export
-                     * to a CJS environment, it'll export it as `exports.default`. Because we don't want
-                     * folks in these environments to have to load their SDKs with
-                     * `require('@api/sdk').default` we're overriding that here to change it to being the
-                     * module exports.
-                     *
-                     * `ts-morph` unfortunately doesn't give us any options for programatically doing this
-                     * so we need to resort to modifying the emitted JS code.
-                     */
-                    code = code
-                        .replace(/Object\.defineProperty\(exports, '__esModule', { value: true }\);\n/, '')
-                        .replace('exports.default = createSDK;', 'module.exports = createSDK;');
-                }
+        return [
+            ...this.project.getSourceFiles().map(sourceFile => {
+                // `getFilePath` will always return a string that contains a preceeding directory separator
+                // however when we're creating these codegen'd files that may cause us to create that file
+                // in the root directory (because it's preceeded by a `/`). We don't want that to happen so
+                // we're slicing off that first character.
+                let filePath = sourceFile.getFilePath().toString();
+                filePath = filePath.substring(1);
                 return {
-                    [file]: code,
+                    [filePath]: sourceFile.getFullText(),
                 };
-            })
-                .reduce((prev, next) => Object.assign(prev, next));
-        }
-        return [
-            ...this.project.getSourceFiles().map(sourceFile => ({
-                [sourceFile.getBaseName()]: sourceFile.getFullText(),
-            })),
+            }),
             // Because we're returning the raw source files for TS generation we also need to separately
             // emit out our declaration files so we can put those into a separate file in the installed
             // SDK directory.
@@ -206,7 +177,7 @@ class TSGenerator extends language_1.default {
                 .emitToMemory({ emitOnlyDtsFiles: true })
                 .getFiles()
                 .map(sourceFile => ({
-                [node_path_1.default.basename(sourceFile.filePath)]: sourceFile.text,
+                [path.basename(sourceFile.filePath)]: sourceFile.text,
             })),
         ].reduce((prev, next) => Object.assign(prev, next));
     }
@@ -214,9 +185,9 @@ class TSGenerator extends language_1.default {
      * Create our main SDK source file.
      *
      */
-    createSourceFile() {
+    createSDKSource(sourceDirectory) {
         const { operations } = this.loadOperationsAndMethods();
-        const sourceFile = this.project.createSourceFile('index.ts', '');
+        const sourceFile = sourceDirectory.createSourceFile('index.ts', '');
         sourceFile.addImportDeclarations([
             // This import will be automatically removed later if the SDK ends up not having any types.
             { defaultImport: 'type * as types', moduleSpecifier: './types' },
@@ -225,22 +196,17 @@ class TSGenerator extends language_1.default {
                 defaultImport: 'type { ConfigOptions, FetchResponse, HTTPMethodRange }',
                 moduleSpecifier: '@readme/api-core',
             },
-            { defaultImport: 'Oas', moduleSpecifier: 'oas' },
             { defaultImport: 'APICore', moduleSpecifier: '@readme/api-core' },
             { defaultImport: 'definition', moduleSpecifier: this.specPath },
         ]);
         // @todo add TOS, License, info.* to a docblock at the top of the SDK.
         this.sdk = sourceFile.addClass({
             name: 'SDK',
-            properties: [
-                { name: 'spec', type: 'Oas' },
-                { name: 'core', type: 'APICore' },
-            ],
+            properties: [{ name: 'core', type: 'APICore' }],
         });
         this.sdk.addConstructor({
             statements: writer => {
-                writer.writeLine('this.spec = Oas.init(definition);');
-                writer.write('this.core = new APICore(this.spec, ').quote(this.userAgent).write(');');
+                writer.write('this.core = new APICore(definition, ').quote(this.userAgent).write(');');
                 return writer;
             },
         });
@@ -252,12 +218,12 @@ class TSGenerator extends language_1.default {
                 statements: writer => writer.writeLine('this.core.setConfig(config);'),
                 docs: [
                     {
-                        description: writer => writer.writeLine((0, util_1.wordWrap)('Optionally configure various options that the SDK allows.')),
+                        description: writer => writer.writeLine(wordWrap('Optionally configure various options that the SDK allows.')),
                         tags: [
                             { tagName: 'param', text: 'config Object of supported SDK options and toggles.' },
                             {
                                 tagName: 'param',
-                                text: (0, util_1.wordWrap)('config.timeout Override the default `fetch` request timeout of 30 seconds. This number should be represented in milliseconds.'),
+                                text: wordWrap('config.timeout Override the default `fetch` request timeout of 30 seconds. This number should be represented in milliseconds.'),
                             },
                         ],
                     },
@@ -273,7 +239,7 @@ class TSGenerator extends language_1.default {
                 },
                 docs: [
                     {
-                        description: writer => writer.writeLine((0, util_1.wordWrap)(`If the API you're using requires authentication you can supply the required credentials through this method and the library will magically determine how they should be used within your API request.
+                        description: writer => writer.writeLine(wordWrap(`If the API you're using requires authentication you can supply the required credentials through this method and the library will magically determine how they should be used within your API request.
 
 With the exception of OpenID and MutualTLS, it supports all forms of authentication supported by the OpenAPI specification.
 
@@ -305,7 +271,7 @@ sdk.auth('myApiKey');`)),
                 statements: writer => writer.writeLine('this.core.setServer(url, variables);'),
                 docs: [
                     {
-                        description: writer => writer.writeLine((0, util_1.wordWrap)(`If the API you're using offers alternate server URLs, and server variables, you can tell the SDK which one to use with this method. To use it you can supply either one of the server URLs that are contained within the OpenAPI definition (along with any server variables), or you can pass it a fully qualified URL to use (that may or may not exist within the OpenAPI definition).
+                        description: writer => writer.writeLine(wordWrap(`If the API you're using offers alternate server URLs, and server variables, you can tell the SDK which one to use with this method. To use it you can supply either one of the server URLs that are contained within the OpenAPI definition (along with any server variables), or you can pass it a fully qualified URL to use (that may or may not exist within the OpenAPI definition).
 
 @example <caption>Server URL with server variables</caption>
 sdk.server('https://{region}.api.example.com/{basePath}', {
@@ -329,12 +295,12 @@ sdk.server('https://eu.api.example.com/v14');`)),
         });
         // Export our SDK into the source file.
         sourceFile.addVariableStatement({
-            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarationKind: VariableDeclarationKind.Const,
             declarations: [
                 {
                     name: 'createSDK',
                     initializer: writer => {
-                        // `ts-morph` doesn't have any way to cleanly create an IFEE.
+                        // `ts-morph` doesn't have any way to cleanly create an IIFE.
                         writer.writeLine('(() => { return new SDK(); })()');
                         return writer;
                     },
@@ -342,52 +308,147 @@ sdk.server('https://eu.api.example.com/v14');`)),
             ],
         });
         sourceFile.addExportAssignment({
-            // Because CJS targets have `createSDK` exported with `module.exports`, but the TS type side
-            // of things to work right we need to set this as `export =`. Thankfully `ts-morph` will
-            // handle this accordingly and still create our JS file with `module.exports` and not
-            // `export =` -- only TS types will have this export style.
-            isExportEquals: this.compilerTarget === 'cjs' && this.outputJS,
+            // Because we're exporting `createSDK` as an IIFE constant we need to have it exported as
+            // `export default createSDK`. `addExportAssignment` by default wants it exported as
+            // `export = createSDK`, which will throw TS errors because we may also be exporting types in
+            // the `./types.ts` file.
+            isExportEquals: false,
             expression: 'createSDK',
         });
         return sourceFile;
     }
+    /**
+     * Create the `tsconfig.json` file that will allow this SDK to be compiled for use.
+     *
+     */
+    createTSConfig() {
+        const sourceFile = this.project.createSourceFile('tsconfig.json', '');
+        const config = {
+            compilerOptions: {
+                module: 'NodeNext',
+                resolveJsonModule: true,
+            },
+            include: ['./src/**/*'],
+        };
+        sourceFile.addStatements(JSON.stringify(config, null, 2));
+        return sourceFile;
+    }
+    /**
+     * Create the `package.json` file that will ultimately make this SDK available to use.
+     *
+     */
+    createPackageJSON() {
+        const sourceFile = this.project.createSourceFile('package.json', '');
+        const hasTypes = !!Object.keys(this.schemas).length;
+        const info = this.spec.getDefinition().info;
+        let pkgVersion = semver.coerce(info.version);
+        if (!pkgVersion) {
+            // If the version that's in `info.version` isn't compatible with semver NPM won't be able to
+            // handle it properly so we need to fallback to something it can.
+            pkgVersion = semver.coerce('0.0.0');
+        }
+        const tsupOptions = {
+            cjsInterop: true,
+            clean: true,
+            dts: true,
+            entry: [
+                './src/index.ts',
+                // If this SDK has schemas and generated types then we should also export those too so
+                // they're available to use.
+                hasTypes ? './src/types.ts' : '',
+            ].filter(Boolean),
+            format: ['esm', 'cjs'],
+            minify: false,
+            shims: true,
+            sourcemap: true,
+            splitting: true,
+        };
+        const dependencies = Object.entries(this.requiredPackages)
+            .map(([dep, { dependencyType, version }]) => (dependencyType === 'production' ? { [dep]: version } : {}))
+            .reduce((prev, next) => Object.assign(prev, next));
+        const devDependencies = Object.entries(this.requiredPackages)
+            .map(([dep, { dependencyType, version }]) => (dependencyType === 'development' ? { [dep]: version } : {}))
+            .reduce((prev, next) => Object.assign(prev, next));
+        const pkg = {
+            name: `@api/${this.identifier}`,
+            version: pkgVersion.version,
+            main: './dist/index.js',
+            types: './dist/index.d.ts',
+            module: './dist/index.mts',
+            exports: {
+                '.': {
+                    import: './dist/index.mjs',
+                    require: './dist/index.js',
+                },
+                ...(hasTypes
+                    ? {
+                        './types': {
+                            import: './dist/types.d.mts',
+                            require: './dist/types.d.ts',
+                        },
+                    }
+                    : {}),
+            },
+            files: ['dist'],
+            scripts: {
+                prepare: 'tsup',
+            },
+            dependencies,
+            devDependencies,
+            tsup: tsupOptions,
+        };
+        sourceFile.addStatements(JSON.stringify(pkg, null, 2));
+        return 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() {
-        const sourceFile = this.project.createSourceFile('schemas.ts', '');
+    createSchemasFile(sourceDirectory) {
+        const sourceFile = sourceDirectory.createSourceFile('schemas.ts', '');
+        const schemasDir = sourceDirectory.createDirectory('schemas');
         const sortedSchemas = new Map(Array.from(Object.entries(this.schemas)).sort());
         Array.from(sortedSchemas).forEach(([schemaName, schema]) => {
-            sourceFile.addVariableStatement({
-                declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            const schemaFile = schemasDir.createSourceFile(`${schemaName}.ts`);
+            // Because we're chunking our schemas into a `schemas/` directory we need to add imports
+            // for these schemas into our main `schemas.ts` file.`
+            sourceFile.addImportDeclaration({
+                defaultImport: schemaName,
+                moduleSpecifier: `./schemas/${schemaName}`,
+            });
+            let str = JSON.stringify(schema);
+            const referencedSchemas = str.match(REF_PLACEHOLDER_REGEX)?.map(s => s.replace(REF_PLACEHOLDER_REGEX, '$1'));
+            if (referencedSchemas) {
+                referencedSchemas.sort();
+                referencedSchemas.forEach(ref => {
+                    // Because this schema is referenced from another file we need to create an `import`
+                    // declaration for it.
+                    schemaFile.addImportDeclaration({
+                        defaultImport: ref,
+                        moduleSpecifier: `./${ref}`,
+                    });
+                });
+            }
+            // Load the schema into the schema file within the `schemas/` directory.
+            schemaFile.addVariableStatement({
+                declarationKind: VariableDeclarationKind.Const,
                 declarations: [
                     {
                         name: schemaName,
                         initializer: writer => {
-                            /**
-                             * This is the conversion prefix that we add to all `$ref` pointers we find in
-                             * generated JSON Schema.
-                             *
-                             * Because the pointer name is a string we want to have it reference the schema
-                             * constant we're adding into the codegen'd schema file. As there's no way, not even
-                             * using `eval()` in this case, to convert a string to a constant we're prefixing
-                             * them with this so we can later remove it and rewrite the value to a literal.
-                             * eg. `'Pet'` becomes `Pet`.
-                             *
-                             * And because our TypeScript type name generator properly ignores `:`, this is safe
-                             * to prepend to all generated type names.
-                             */
-                            let str = JSON.stringify(schema);
-                            str = str.replace(/"::convert::([a-zA-Z_$\\d]*)"/g, '$1');
+                            // We can't have `::convert::<schemaName>` variables within these schema files so we
+                            // need to clean them up.
+                            str = str.replace(REF_PLACEHOLDER_REGEX, '$1');
                             writer.writeLine(`${str} as const`);
                             return writer;
                         },
                     },
                 ],
             });
+            schemaFile.addStatements(`export default ${schemaName}`);
         });
+        // Export all of our schemas from inside the main `schemas.ts` file.
         sourceFile.addStatements(`export { ${Array.from(sortedSchemas.keys()).join(', ')} }`);
         return sourceFile;
     }
@@ -398,8 +459,8 @@ sdk.server('https://eu.api.example.com/v14');`)),
      *
      * @see {@link https://npm.im/json-schema-to-ts}
      */
-    createTypesFile() {
-        const sourceFile = this.project.createSourceFile('types.ts', '');
+    createTypesFile(sourceDirectory) {
+        const sourceFile = sourceDirectory.createSourceFile('types.ts', '');
         sourceFile.addImportDeclarations([
             { defaultImport: 'type { FromSchema }', moduleSpecifier: 'json-schema-to-ts' },
             { defaultImport: '* as schemas', moduleSpecifier: './schemas' },
@@ -409,18 +470,6 @@ sdk.server('https://eu.api.example.com/v14');`)),
         });
         return sourceFile;
     }
-    /**
-     * Add a new JSDoc `@tag` to an existing docblock.
-     *
-     */
-    static addTagToDocblock(docblock, tag) {
-        const tags = docblock.tags ?? [];
-        tags.push(tag);
-        return {
-            ...docblock,
-            tags,
-        };
-    }
     /**
      * Create operation accessors on the SDK.
      *
@@ -435,18 +484,18 @@ sdk.server('https://eu.api.example.com/v14');`)),
             // what we surface the main docblock description.
             docblock.description = writer => {
                 if (description) {
-                    writer.writeLine((0, util_1.docblockEscape)((0, util_1.wordWrap)(description)));
+                    writer.writeLine(docblockEscape(wordWrap(description)));
                 }
                 else if (summary) {
-                    writer.writeLine((0, util_1.docblockEscape)((0, util_1.wordWrap)(summary)));
+                    writer.writeLine(docblockEscape(wordWrap(summary)));
                 }
                 writer.newLineIfLastNot();
                 return writer;
             };
             if (summary && description) {
-                docblock = TSGenerator.addTagToDocblock(docblock, {
+                docblock = TSGenerator.#addTagToDocblock(docblock, {
                     tagName: 'summary',
-                    text: (0, util_1.docblockEscape)((0, util_1.wordWrap)(summary)),
+                    text: docblockEscape(wordWrap(summary)),
                 });
             }
         }
@@ -488,9 +537,9 @@ sdk.server('https://eu.api.example.com/v14');`)),
                         return `FetchResponse<number, ${responseType}>`;
                     }
                     if (Number(statusPrefix) >= 4) {
-                        docblock = TSGenerator.addTagToDocblock(docblock, {
+                        docblock = TSGenerator.#addTagToDocblock(docblock, {
                             tagName: 'throws',
-                            text: `FetchError<${status}, ${responseType}>${responseDescription ? (0, util_1.docblockEscape)((0, util_1.wordWrap)(` ${responseDescription}`)) : ''}`,
+                            text: `FetchError<${status}, ${responseType}>${responseDescription ? docblockEscape(wordWrap(` ${responseDescription}`)) : ''}`,
                         });
                         return false;
                     }
@@ -500,9 +549,9 @@ sdk.server('https://eu.api.example.com/v14');`)),
                 // 400 and 500 status code families are thrown as exceptions so adding them as a possible
                 // return type isn't valid.
                 if (Number(status) >= 400) {
-                    docblock = TSGenerator.addTagToDocblock(docblock, {
+                    docblock = TSGenerator.#addTagToDocblock(docblock, {
                         tagName: 'throws',
-                        text: `FetchError<${status}, ${responseType}>${responseDescription ? (0, util_1.docblockEscape)((0, util_1.wordWrap)(` ${responseDescription}`)) : ''}`,
+                        text: `FetchError<${status}, ${responseType}>${responseDescription ? docblockEscape(wordWrap(` ${responseDescription}`)) : ''}`,
                     });
                     return false;
                 }
@@ -641,9 +690,9 @@ sdk.server('https://eu.api.example.com/v14');`)),
                 // As our schemas are dereferenced in the `oas` library we don't want to pollute our
                 // codegen'd schemas file with duplicate schemas.
                 if ('x-readme-ref-name' in s && typeof s['x-readme-ref-name'] !== 'undefined') {
-                    const typeName = (0, util_1.generateTypeName)(s['x-readme-ref-name']);
+                    const typeName = generateTypeName(s['x-readme-ref-name']);
                     this.addSchemaToExport(s, typeName, typeName);
-                    return `::convert::${typeName}`;
+                    return `${REF_PLACEHOLDER}${typeName}`;
                 }
                 return s;
             },
@@ -657,14 +706,14 @@ sdk.server('https://eu.api.example.com/v14');`)),
         return Object.entries(res)
             .map(([paramType, schema]) => {
             let typeName;
-            if (typeof schema === 'string' && schema.startsWith('::convert::')) {
+            if (typeof schema === 'string' && schema.startsWith(REF_PLACEHOLDER)) {
                 // If this schema is a string and has our conversion prefix then we've already created
                 // a type for it.
-                typeName = schema.replace('::convert::', '');
+                typeName = schema.replace(REF_PLACEHOLDER, '');
             }
             else {
-                typeName = (0, util_1.generateTypeName)(operationId, paramType, 'param');
-                this.addSchemaToExport(schema, typeName, `${(0, util_1.generateTypeName)(operationId)}.${paramType}`);
+                typeName = generateTypeName(operationId, paramType, 'param');
+                this.addSchemaToExport(schema, typeName, `${generateTypeName(operationId)}.${paramType}`);
             }
             return {
                 // Types are prefixed with `types.` because that's how we're importing them from
@@ -691,9 +740,9 @@ sdk.server('https://eu.api.example.com/v14');`)),
                     // As our schemas are dereferenced in the `oas` library we don't want to pollute our
                     // codegen'd schemas file with duplicate schemas.
                     if ('x-readme-ref-name' in s && typeof s['x-readme-ref-name'] !== 'undefined') {
-                        const typeName = (0, util_1.generateTypeName)(s['x-readme-ref-name']);
+                        const typeName = generateTypeName(s['x-readme-ref-name']);
                         this.addSchemaToExport(s, typeName, `${typeName}`);
-                        return `::convert::${typeName}`;
+                        return `${REF_PLACEHOLDER}${typeName}`;
                     }
                     return s;
                 },
@@ -709,17 +758,17 @@ sdk.server('https://eu.api.example.com/v14');`)),
         const res = Object.entries(schemas)
             .map(([status, { description, schema }]) => {
             let typeName;
-            if (typeof schema === 'string' && schema.startsWith('::convert::')) {
+            if (typeof schema === 'string' && schema.startsWith(REF_PLACEHOLDER)) {
                 // If this schema is a string and has our conversion prefix then we've already created
                 // a type for it.
-                typeName = schema.replace('::convert::', '');
+                typeName = schema.replace(REF_PLACEHOLDER, '');
             }
             else {
-                typeName = (0, util_1.generateTypeName)(operationId, 'response', status);
+                typeName = generateTypeName(operationId, 'response', status);
                 // Because `status` will usually be a number here we need to set the pointer for it
                 // within  an `[]` as if we do `FromSchema<typeof schemas.operation.response.200>`,
                 // TypeScript will throw a compilation error.
-                this.addSchemaToExport(schema, typeName, `${(0, util_1.generateTypeName)(operationId)}.response['${status}']`);
+                this.addSchemaToExport(schema, typeName, `${generateTypeName(operationId)}.response['${status}']`);
             }
             return {
                 // Types are prefixed with `types.` because that's how we're importing them from
@@ -741,8 +790,20 @@ sdk.server('https://eu.api.example.com/v14');`)),
         if (this.types.has(typeName)) {
             return;
         }
-        (0, lodash_setwith_1.default)(this.schemas, pointer, schema, Object);
+        setWith(this.schemas, pointer, schema, Object);
         this.types.set(typeName, `FromSchema<typeof schemas.${pointer}>`);
     }
+    /**
+     * Add a new JSDoc `@tag` to an existing docblock.
+     *
+     */
+    static #addTagToDocblock(docblock, tag) {
+        const tags = docblock.tags ?? [];
+        tags.push(tag);
+        return {
+            ...docblock,
+            tags,
+        };
+    }
 }
-exports.default = TSGenerator;
+//# sourceMappingURL=index.js.map