true-pg 0.5.0 → 0.6.0

package/lib/index.js

@@ -1,14 +1,30 @@
 import { Extractor, FunctionReturnTypeKind } from "./extractor/index.js";
 import { rm, mkdir, writeFile } from "node:fs/promises";
-import { Nodes, allowed_kind_names } from "./types.js";
+import { allowed_kind_names } from "./types.js";
+import { ImportList } from "./imports.js";
 import { existsSync } from "node:fs";
-import { join } from "./util.js";
+import { join, parens } from "./util.js";
 import { join as joinpath } from "node:path";
-import { config, adapters } from "./config.js";
+import { config, generators as builtin_generators } from "./config.js";
 export { config };
-const time = (start) => {
-    const end = performance.now();
-    return (end - start).toFixed(2);
+const NO_COLOR = Boolean(process.env.NO_COLOR || process.env.CI);
+const red = (str) => (NO_COLOR ? str : `\x1b[31m${str}\x1b[0m`);
+const green = (str) => (NO_COLOR ? str : `\x1b[32m${str}\x1b[0m`);
+const yellow = (str) => (NO_COLOR ? str : `\x1b[33m${str}\x1b[0m`);
+const blue = (str) => (NO_COLOR ? str : `\x1b[34m${str}\x1b[0m`);
+const bold = (str) => (NO_COLOR ? str : `\x1b[1m${str}\x1b[0m`);
+const underline = (str) => (NO_COLOR ? str : `\x1b[4m${str}\x1b[0m`);
+const THRESHOLD1 = 800;
+const THRESHOLD2 = 1500;
+const time = (start, addParens = true) => {
+    const diff = performance.now() - start;
+    const diffstr = diff.toFixed(2) + "ms";
+    const str = addParens ? parens(diffstr) : diffstr;
+    if (diff < THRESHOLD1)
+        return green(str);
+    if (diff < THRESHOLD2)
+        return yellow(str);
+    return red(str);
 };
 const filter_overloaded_functions = (functions) => {
     const counts = functions.reduce((acc, func) => {
@@ -61,11 +77,15 @@ const filter_unsupported_functions = (functions) => {
     const unsupported = filtered.filter(func => !filtered.includes(func));
     return [filtered, unsupported];
 };
-const write = (filename, file) => writeFile(filename, file + "\n");
 const multifile = async (generators, schemas, opts) => {
-    const { out } = opts;
-    const warnings = [];
-    const gens = generators.map(g => g({ ...opts, warnings }));
+    const { out, defaultSchema } = opts;
+    let count = 0;
+    const write = async (filename, file) => {
+        await writeFile(filename, file + "\n");
+        count++;
+    };
+    const warnings = new Set();
+    const gens = generators.map(g => g({ defaultSchema, warnings }));
     const def_gen = gens[0];
     const files = {
         name: out,
@@ -83,7 +103,7 @@ const multifile = async (generators, schemas, opts) => {
                         children: Object.fromEntries(schema[kind].map(item => [
                             item.name,
                             {
-                                name: def_gen.formatSchemaType(item),
+                                name: def_gen.formatSchemaMemberName(item),
                                 type: "type",
                             },
                         ])),
@@ -95,20 +115,20 @@ const multifile = async (generators, schemas, opts) => {
     for (const schema of Object.values(schemas)) {
         console.log("Selected schema '%s':\n", schema.name);
         const schemaDir = joinpath(out, schema.name);
-        const [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.functions);
+        const [unique_functions, overloaded_functions] = filter_overloaded_functions(schema.function);
         const [supported_functions, unsupported_functions] = filter_unsupported_functions(unique_functions);
-        schema.functions = supported_functions;
+        schema.function = supported_functions;
         {
             const skipped = unsupported_functions.map(f => `  - ${f.name}`);
             if (skipped.length) {
-                warnings.push(`Skipping ${skipped.length} functions not representable in JavaScript (safe to ignore):\n` +
+                warnings.add(`Skipping ${skipped.length} functions not representable in JavaScript (safe to ignore):\n` +
                     skipped.join("\n"));
             }
         }
         {
             const skipped = overloaded_functions.map(f => `  - ${f}`);
             if (skipped.length) {
-                warnings.push(`Skipping ${skipped.length} overloaded functions (not supported):\n` + skipped.join("\n"));
+                warnings.add(`Skipping ${skipped.length} overloaded functions (not supported):\n` + skipped.join("\n"));
             }
         }
         let createIndex = false;
@@ -116,73 +136,65 @@ const multifile = async (generators, schemas, opts) => {
             if (schema[kind].length < 1)
                 continue;
             createIndex = true;
-            await mkdir(joinpath(schemaDir, kind), { recursive: true });
-            console.log(" Creating %s:\n", kind);
+            const kindDir = joinpath(schemaDir, kind + "s");
+            await mkdir(kindDir, { recursive: true });
+            console.log(" Creating %s:\n", kind + "s");
             for (const [i, item] of schema[kind].entries()) {
                 const index = "[" + (i + 1 + "]").padEnd(3, " ");
-                const filename = joinpath(schemaDir, kind, def_gen.formatSchemaType(item) + ".ts");
+                const filename = joinpath(kindDir, def_gen.formatSchemaMemberName(item) + ".ts");
                 const exists = await existsSync(filename);
                 if (exists) {
-                    warnings.push(`Skipping ${item.kind} "${item.name}": formatted name clashes. Wanted to create ${filename}`);
+                    warnings.add(`Skipping ${item.kind} "${item.name}": formatted name clashes. Wanted to create ${filename}`);
                     continue;
                 }
                 const start = performance.now();
                 let file = "";
-                const imports = new Nodes.ImportList([]);
-                if (item.kind === "table")
-                    file += join(gens.map(gen => gen.table(imports, item)));
-                if (item.kind === "view")
-                    file += join(gens.map(gen => gen.view(imports, item)));
-                // prettier-ignore
-                if (item.kind === "materializedView")
-                    file += join(gens.map(gen => gen.materializedView(imports, item)));
-                if (item.kind === "enum")
-                    file += join(gens.map(gen => gen.enum(imports, item)));
-                if (item.kind === "composite")
-                    file += join(gens.map(gen => gen.composite(imports, item)));
-                if (item.kind === "domain")
-                    file += join(gens.map(gen => gen.domain(imports, item)));
-                if (item.kind === "range")
-                    file += join(gens.map(gen => gen.range(imports, item)));
-                if (item.kind === "function")
-                    file += join(gens.map(gen => gen.function(imports, item)));
-                const parts = [];
-                parts.push(imports.stringify(filename, files));
-                parts.push(file);
-                file = join(parts);
+                const imports = new ImportList();
+                file += join(gens.map(gen => gen[item.kind]({ source: filename, imports }, 
+                // @ts-expect-error TypeScript cannot fathom the fact that item is related to item.kind
+                item)));
+                file = join([imports.stringify(files), file]);
                 await write(filename, file);
-                console.log("  %s %s \x1b[32m(%sms)\x1B[0m", index, filename, time(start));
+                console.log("  %s %s %s", index, filename, time(start));
             }
             {
                 const start = performance.now();
-                const kindIndex = join(gens.map(gen => gen.schemaKindIndex(schema, kind, def_gen)));
-                const kindIndexFilename = joinpath(schemaDir, kind, "index.ts");
-                await write(kindIndexFilename, kindIndex);
-                const end = performance.now();
-                console.log("  ✅   Created %s index: %s \x1b[32m(%sms)\x1B[0m\n", kind, kindIndexFilename, (end - start).toFixed(2));
+                const imports = new ImportList();
+                const fileName = joinpath(kindDir, "index.ts");
+                const kindIndex = join(gens.map(gen => gen.schemaKindIndex({ source: fileName, imports }, schema, kind, def_gen)));
+                const file = join([imports.stringify(files), kindIndex]);
+                await write(fileName, file);
+                console.log("  ✅   Created %s index: %s %s\n", kind, fileName, time(start));
             }
         }
         if (!createIndex)
             continue;
         {
             const start = performance.now();
-            const index = join(gens.map(gen => gen.schemaIndex(schema, def_gen)));
-            const indexFilename = joinpath(schemaDir, "index.ts");
-            await write(indexFilename, index);
-            console.log(" Created schema index: %s \x1b[32m(%sms)\x1B[0m\n", indexFilename, time(start));
+            const imports = new ImportList();
+            const fileName = joinpath(schemaDir, "index.ts");
+            const index = join(gens.map(gen => gen.schemaIndex({ source: fileName, imports }, schema, def_gen)));
+            const file = join([imports.stringify(files), index]);
+            await write(fileName, file);
+            console.log(" Created schema index: %s %s\n", fileName, time(start));
         }
     }
     {
         const start = performance.now();
-        const fullIndex = join(gens.map(gen => gen.fullIndex(Object.values(schemas))));
-        const fullIndexFilename = joinpath(out, "index.ts");
-        await write(fullIndexFilename, fullIndex);
-        console.log("Created full index: %s \x1b[32m(%sms)\x1B[0m", fullIndexFilename, time(start));
+        const imports = new ImportList();
+        const fileName = joinpath(out, "index.ts");
+        const fullIndex = join(gens.map(gen => gen.fullIndex({ source: fileName, imports }, Object.values(schemas))));
+        const file = join([imports.stringify(files), fullIndex]);
+        await write(fileName, file);
+        console.log("Created full index: %s %s", fileName, time(start));
     }
-    if (warnings.length > 0) {
+    if (warnings.size > 0) {
         console.log("\nWarnings generated:");
-        console.log(warnings.map(warning => "* " + warning).join("\n"));
+        for (const warning of warnings) {
+            console.log("* " + warning);
+        }
     }
+    return count;
 };
 export async function generate(opts, generators) {
     const validated = config(opts);
@@ -190,13 +202,13 @@ export async function generate(opts, generators) {
     const extractor = new Extractor(opts);
     const start = performance.now();
     const schemas = await extractor.extractSchemas();
-    const end = performance.now();
-    console.log("Extracted schemas \x1b[32m(%sms)\x1b[0m\n", (end - start).toFixed(2));
-    console.info("Adapters enabled: %s\n", validated.adapters.join(", "));
-    generators = validated.adapters.map(adapter => adapters[adapter]).concat(generators ?? []);
+    console.log("Extracted schemas %s\n", time(start));
+    console.info("Generators enabled: %s\n", validated.generators.join(", "));
+    generators = validated.generators.map(generator => builtin_generators[generator]).concat(generators ?? []);
     console.log("Clearing directory and generating schemas at '%s'\n", out);
     await rm(out, { recursive: true, force: true });
     await mkdir(out, { recursive: true });
-    await multifile(generators, schemas, validated);
-    console.log("Completed in \x1b[32m%sms\x1b[0m", time(start));
+    const count = await multifile(generators, schemas, validated);
+    console.log("Completed in %s, %s generated.", time(start, false), bold(underline(blue(count + " files"))));
+    console.log();
 }

package/lib/kysely/index.js

@@ -1,149 +1,153 @@
 import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
-import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
+import { allowed_kind_names, createGenerator } from "../types.js";
+import { Import } from "../imports.js";
 import { builtins } from "./builtins.js";
 import { toPascalCase, join, quote, quoteI } from "../util.js";
 export const Kysely = createGenerator(opts => {
     const defaultSchema = opts?.defaultSchema ?? "public";
-    const ky = (imports, name) => imports.add(new Nodes.ExternalImport({
-        name,
-        module: "kysely",
-        typeOnly: true,
-        star: false,
-    }));
-    const add = (imports, type) => {
-        if (type.schema === "pg_catalog")
-            return;
-        imports.add(new Nodes.InternalImport({
-            name: generator.formatType(type),
-            canonical_type: type,
+    const ky = (ctx, name) => {
+        ctx.imports.add(new Import({
+            from: "kysely",
+            namedImports: [name],
             typeOnly: true,
-            star: false,
         }));
     };
     const column = (
     /** "this" */
-    generator, 
-    /** @out Append used types to this array */
-    imports, 
+    generator, ctx, 
     /** Information about the column */
     col) => {
-        let base = generator.formatType(col.type);
-        if (col.type.dimensions > 0)
-            base += "[]".repeat(col.type.dimensions);
-        if (col.isNullable)
-            base += " | null";
+        let base = generator.formatType(ctx, col.type, { nullable: col.isNullable });
         let qualified = base;
         if (col.generated === "ALWAYS") {
             qualified = `GeneratedAlways<${qualified}>`;
-            ky(imports, "GeneratedAlways");
+            ky(ctx, "GeneratedAlways");
         }
         else if (col.generated === "BY DEFAULT") {
             qualified = `Generated<${qualified}>`;
-            ky(imports, "Generated");
+            ky(ctx, "Generated");
         }
         else if (col.defaultValue) {
             qualified = `Generated<${qualified}>`;
-            ky(imports, "Generated");
+            ky(ctx, "Generated");
         }
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(col.name);
-        // TODO: update imports for non-primitive types
         out += `: ${qualified}`;
-        add(imports, col.type);
         return `\t${out};\n`;
     };
-    const composite_attribute = (generator, imports, attr) => {
+    const composite_attribute = (ctx, generator, attr) => {
         let out = quoteI(attr.name);
         if (attr.isNullable)
             out += "?";
-        out += `: ${generator.formatType(attr.type)}`;
-        add(imports, attr.type);
-        if (attr.type.dimensions > 0)
-            out += "[]".repeat(attr.type.dimensions);
-        if (attr.isNullable)
-            out += " | null";
+        out += ": ";
+        out += generator.formatType(ctx, attr.type, { nullable: attr.isNullable });
         return out;
     };
     const generator = {
-        formatSchema(name) {
+        formatSchemaName(name) {
             return toPascalCase(name) + "Schema";
         },
-        formatSchemaType(type) {
+        formatSchemaMemberName(type) {
             return toPascalCase(type.name);
         },
-        formatType(type) {
+        formatType(ctx, type, attr) {
+            let base;
             if (type.kind === FunctionReturnTypeKind.ExistingTable) {
-                return toPascalCase(type.name);
+                base = toPascalCase(type.name);
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: true,
+                }));
             }
-            else if (type.schema === "pg_catalog") {
+            else if (type.schema === "pg_catalog" ||
+                type.kind === Canonical.Kind.Base ||
+                type.kind === Canonical.Kind.Pseudo) {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
-                    return format;
-                opts?.warnings?.push(`(kysely) Unknown builtin type: ${name}. Pass customBuiltinMap to map this type. Defaulting to "unknown".`);
-                return "unknown";
+                    base = format;
+                else {
+                    opts?.warnings?.add(`(kysely) Unknown base type: ${name}. Pass 'kysely.builtinMap' to map this type. Defaulting to "unknown".`);
+                    base = "unknown";
+                }
             }
-            return toPascalCase(type.name);
+            else {
+                base = toPascalCase(type.name);
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: true,
+                }));
+            }
+            if ("dimensions" in type)
+                base += "[]".repeat(type.dimensions);
+            if (attr?.nullable)
+                base += " | null";
+            return base;
         },
-        table(imports, table) {
+        table(ctx, table) {
             let out = "";
             if (table.comment)
                 out += `/** ${table.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(table)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(table)} {\n`;
             for (const col of table.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        view(imports, view) {
+        view(ctx, view) {
             let out = "";
             if (view.comment)
                 out += `/** ${view.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(view)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(view)} {\n`;
             for (const col of view.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        materializedView(imports, materializedView) {
+        materializedView(ctx, materializedView) {
             let out = "";
             if (materializedView.comment)
                 out += `/** ${materializedView.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(materializedView)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(materializedView)} {\n`;
             for (const col of materializedView.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        enum(imports, en) {
+        enum(ctx, en) {
             let out = "";
             if (en.comment)
                 out += `/** ${en.comment} */\n`;
-            out += `export type ${this.formatSchemaType(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
+            out += `export type ${this.formatSchemaMemberName(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
             return out;
         },
-        composite(imports, type) {
+        composite(ctx, type) {
             let out = "";
             if (type.comment)
                 out += `/** ${type.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(type)} {\n`;
-            const props = type.canonical.attributes.map(c => composite_attribute(this, imports, c)).map(t => `\t${t};`);
+            out += `export interface ${this.formatSchemaMemberName(type)} {\n`;
+            const props = type.canonical.attributes.map(c => composite_attribute(ctx, this, c)).map(t => `\t${t};`);
             out += props.join("\n");
             out += "\n}";
             return out;
         },
-        domain(imports, type) {
+        domain(ctx, type) {
             let out = "";
-            out += `export type ${this.formatSchemaType(type)} = ${this.formatType(type.canonical.domain_base_type)};`;
+            out += `export type ${this.formatSchemaMemberName(type)} = ${this.formatType(ctx, type.canonical.domain_base_type)};`;
             return out;
         },
-        range(imports, type) {
+        range(ctx, type) {
             let out = "";
             // force this to be string because range has to be passed as a string to Kysely
-            out += `export type ${this.formatSchemaType(type)} = string;`;
+            out += `export type ${this.formatSchemaMemberName(type)} = string;`;
             return out;
         },
-        function(imports, type) {
+        function(ctx, type) {
             let out = "";
             out += "/**\n";
             if (type.comment)
@@ -152,7 +156,7 @@ export const Kysely = createGenerator(opts => {
             out += ` * @parallelSafety ${type.parallelSafety}\n`;
             out += ` * @isStrict ${type.isStrict}\n`;
             out += " */\n";
-            out += `export interface ${this.formatSchemaType(type)} {\n\t`;
+            out += `export interface ${this.formatSchemaMemberName(type)} {\n\t`;
             // Get the input parameters (those that appear in function signature)
             const inputParams = type.parameters.filter(p => p.mode === "IN" || p.mode === "INOUT" || p.mode === "VARIADIC");
             if (inputParams.length === 0) {
@@ -162,10 +166,7 @@ export const Kysely = createGenerator(opts => {
                 out += "(";
                 out += inputParams[0].name;
                 out += ": ";
-                out += this.formatType(inputParams[0].type);
-                add(imports, inputParams[0].type);
-                if (inputParams[0].type.dimensions > 0)
-                    out += "[]".repeat(inputParams[0].type.dimensions);
+                out += this.formatType(ctx, inputParams[0].type);
                 out += "): ";
             }
             else if (inputParams.length > 0) {
@@ -177,10 +178,7 @@ export const Kysely = createGenerator(opts => {
                     out += `\t\t${paramName}`;
                     if (param.hasDefault && !isVariadic)
                         out += "?";
-                    out += `: ${this.formatType(param.type)}`;
-                    add(imports, param.type);
-                    if (param.type.dimensions > 0)
-                        out += "[]".repeat(param.type.dimensions);
+                    out += `: ${this.formatType(ctx, param.type)}`;
                     if (!isVariadic)
                         out += ",";
                     out += "\n";
@@ -194,24 +192,17 @@ export const Kysely = createGenerator(opts => {
                     out += "{\n";
                     for (const col of type.returnType.columns) {
                         out += `\t\t"${col.name}": `;
-                        out += this.formatType(col.type);
-                        add(imports, col.type);
-                        if (col.type.dimensions > 0)
-                            out += "[]".repeat(col.type.dimensions);
+                        out += this.formatType(ctx, col.type);
                         out += `;\n`;
                     }
                     out += "\t}";
                 }
             }
             else if (type.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
-                out += this.formatType(type.returnType);
-                add(imports, type.returnType);
+                out += this.formatType(ctx, type.returnType);
             }
             else {
-                out += this.formatType(type.returnType.type);
-                add(imports, type.returnType.type);
-                if (type.returnType.type.dimensions > 0)
-                    out += "[]".repeat(type.returnType.type.dimensions);
+                out += this.formatType(ctx, type.returnType.type);
             }
             // Add additional array brackets if it returns a set
             if (type.returnType.isSet) {
@@ -220,32 +211,33 @@ export const Kysely = createGenerator(opts => {
             out += ";\n}";
             return out;
         },
-        schemaKindIndex(schema, kind, main_generator) {
+        schemaKindIndex(ctx, schema, kind, main_generator) {
             const generator = main_generator ?? this;
             const imports = schema[kind];
             if (imports.length === 0)
                 return "";
             return imports
                 .map(each => {
-                const name = this.formatSchemaType(each);
-                const file = generator.formatSchemaType(each);
+                const name = generator.formatSchemaMemberName(each);
+                const file = generator.formatSchemaMemberName(each);
                 return `export type { ${name} } from "./${file}.ts";`;
             })
                 .join("\n");
         },
-        schemaIndex(schema) {
+        schemaIndex(ctx, schema) {
             const actual_kinds = allowed_kind_names.filter(kind => schema[kind].length);
-            let out = actual_kinds.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
+            // we could in theory use the imports from GeneratorContext here, but this works fine
+            let out = actual_kinds.map(kind => `import type * as ${kind}s from "./${kind}s/index.ts";`).join("\n");
             out += "\n\n";
-            out += `export interface ${this.formatSchema(schema.name)} {\n`;
+            out += `export interface ${this.formatSchemaName(schema.name)} {\n`;
             for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
                     continue;
-                out += `\t${kind}: {\n`;
+                out += `\t${kind}s: {\n`;
                 const formatted = items
                     .map(each => {
-                    const formatted = this.formatSchemaType(each);
+                    const formatted = generator.formatSchemaMemberName(each);
                     return { ...each, formatted };
                 })
                     .filter(x => x !== undefined);
@@ -260,22 +252,22 @@ export const Kysely = createGenerator(opts => {
             out += "}";
             return out;
         },
-        fullIndex(schemas) {
+        fullIndex(ctx, schemas) {
             const parts = [];
             parts.push(schemas
-                .map(s => `import type { ${this.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+                .map(s => `import type { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
                 .join("\n"));
             {
                 let iface = `export interface Database {\n`;
                 iface += schemas
                     .map(schema => {
                     // only tables, views, and materialized views are queryable
-                    const tables = [...schema.tables, ...schema.views, ...schema.materializedViews];
+                    const tables = [...schema.table, ...schema.view, ...schema.materializedView];
                     let out = "";
                     const seen = new Set();
                     const formatted = tables
                         .map(each => {
-                        const formatted = this.formatSchemaType(each);
+                        const formatted = generator.formatSchemaMemberName(each);
                         // skip clashing names
                         if (seen.has(formatted))
                             return;
@@ -294,7 +286,7 @@ export const Kysely = createGenerator(opts => {
                         else
                             qualified = t.name;
                         qualified = quoteI(qualified);
-                        return `\t${qualified}: ${this.formatSchema(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
+                        return `\t${qualified}: ${generator.formatSchemaName(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
                     })
                         .join("\n");
                     return out;
@@ -303,7 +295,7 @@ export const Kysely = createGenerator(opts => {
                 iface += "\n}";
                 parts.push(iface);
             }
-            parts.push(schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n"));
+            parts.push(schemas.map(s => `export type { ${generator.formatSchemaName(s.name)} };`).join("\n"));
             return join(parts);
         },
     };