true-pg 0.4.5 → 0.5.1

package/README.md

@@ -15,7 +15,7 @@ bun add true-pg
 ## Quickstart
 
 ```bash
-npx true-pg --all-adapters --uri postgres://user:password@localhost:5432/database --out ./models
+npx true-pg --all-generators --uri postgres://user:password@localhost:5432/database --out ./models
 ```
 
 This will generate a `models` directory with the following structure:
@@ -68,8 +68,8 @@ Options:
 -   `-c, --config [path]` - Path to config file (JSON)
 -   `-u, --uri [uri]` - Database URI (Postgres only!)
 -   `-o, --out [path]` - Path to output directory (defaults to "models")
--   `-a, --adapter [adapter]` - Adapter to use (e.g. `kysely`, `zod`). Can be specified multiple times.
--   `-A, --all-adapters` - Enable all built-in adapters
+-   `-g, --generator [generator]` - Generator to use (e.g. `kysely`, `zod`). Can be specified multiple times.
+-   `-A, --all-generators` - Enable all built-in generators
 
 You can configure true-pg either through command-line arguments or a config file.
 
@@ -89,7 +89,7 @@ import { config } from "true-pg";
 export default config({
 	uri: "postgres://user:password@localhost:5432/database",
 	out: "src/models",
-	adapters: ["kysely", "zod"],
+	generators: ["kysely", "zod"],
 	defaultSchema: "public",
 });
 ```
@@ -101,7 +101,7 @@ export default config({
 | `uri`           | PostgreSQL connection URI                                | Required, or config |
 | `config`        | Knex connection config object                            | Required, or uri    |
 | `out`           | Output directory for generated files                     | `"models"`          |
-| `adapters`      | Adapters to use (e.g. `kysely`, `zod`)                   | `"kysely"`          |
+| `generators`    | Generators to use (e.g. `kysely`, `zod`)                 | `"kysely"`          |
 | `defaultSchema` | Default schema to use (Kysely schema will be unprefixed) | `"public"`          |
 
 ## Customising Code Generation
@@ -118,28 +118,28 @@ You can create a custom generator to control how code is generated:
 import { createGenerator, generate } from "true-pg";
 
 const generator = createGenerator(opts => ({
-	formatSchema: name => `${name}Schema`,
-	formatSchemaType: type => `${type}Type`,
-	formatType: type => `${type}Interface`,
-	table: (imports, table) => {
+	formatSchemaName: name => `${name}Schema`,
+	formatSchemaMemberName: type => `${type.name}Type`,
+	formatType: (ctx, type) => `${type}Interface`,
+	table: (ctx, table) => {
 		// Custom table type generation
 	},
-	enum: (imports, en) => {
+	enum: (ctx, en) => {
 		// Custom enum type generation
 	},
-	composite: (imports, composite) => {
+	composite: (ctx, composite) => {
 		// Custom composite type generation
 	},
-	function: (imports, func) => {
+	function: (ctx, func) => {
 		// Custom function type generation
 	},
-	schemaKindIndex: (schema, kind) => {
+	schemaKindIndex: (ctx, schema, kind) => {
 		// Custom schema kind index generation
 	},
-	schemaIndex: schema => {
+	schemaIndex: (ctx, schema) => {
 		// Custom schema index generation
 	},
-	fullIndex: schemas => {
+	fullIndex: (ctx, schemas) => {
 		// Custom full index generation
 	},
 }));
@@ -147,14 +147,14 @@ const generator = createGenerator(opts => ({
 await generate(
 	{
 		uri: "postgres://user:password@localhost:5432/database",
-		adapters: [], // empty array to disable adapters
+		generators: [], // empty array to disable generators
 		out: "src/models",
 	},
 	[generator],
 );
 ```
 
-Filenames will be created using the `format*` methods of the FIRST generator passed to `generate` or via the `--adapter` CLI option.
+Filenames will be created using the `format*` methods of the FIRST generator passed to `generate` or via the `--generator` CLI option.
 
 ## Schema Generator Interface
 

package/lib/bin.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import mri from "mri";
 import { generate } from "./index.js";
-import { adapters } from "./config.js";
+import { generators } from "./config.js";
 const args = process.argv.slice(2);
 const opts = mri(args, {
-    boolean: ["help", "all-adapters"],
-    string: ["config", "uri", "out", "adapter"],
+    boolean: ["help", "all-generators"],
+    string: ["config", "uri", "out", "generator"],
     alias: {
         h: "help",
         c: "config",
         u: "uri",
         o: "out",
-        a: "adapter",
-        A: "all-adapters",
+        a: "generator",
+        A: "all-generators",
     },
 });
 import { cosmiconfig } from "cosmiconfig";
@@ -31,27 +31,27 @@ if (help) {
     log("  -h, --help                  Show help");
     log("  -u, --uri      [uri]        Database URI (Postgres only!)");
     log("  -o, --out      [path]       Path to output directory");
-    log("  -a, --adapter  [adapter]    Output adapter to use (default: 'kysely')");
-    log("  -A, --all-adapters          Output all adapters");
+    log("  -g, --generator  [generator]    Output generator to use (default: 'kysely')");
+    log("  -A, --all-generators          Output all generators");
     log("  -c, --config   [path]       Path to config file");
     log("                              Defaults to '.truepgrc.json' or '.config/.truepgrc.json'");
     log("Example:");
-    log("  true-pg -u postgres://user:pass@localhost:5432/my-database -o models -a kysely -a zod");
+    log("  true-pg -u postgres://user:pass@localhost:5432/my-database -o models -g kysely -g zod");
     log();
     if (opts.help)
         process.exit(0);
     else
         process.exit(1);
 }
-if (opts["all-adapters"])
-    opts.adapter = Object.keys(adapters);
-if (!(opts.adapter || config.adapters))
-    console.warn('No adapters specified, using default: ["kysely"]');
-// allow single adapter or comma-separated list of adapters
-if (typeof opts.adapter === "string")
-    opts.adapter = opts.adapter.split(",");
+if (opts["all-generators"])
+    opts.generator = Object.keys(generators);
+if (!(opts.generator || config.generators))
+    console.warn('No generators specified, using default: ["kysely"]');
+// allow single generator or comma-separated list of generators
+if (typeof opts.generator === "string")
+    opts.generator = opts.generator.split(",");
 // CLI args take precedence over config file
 config.uri = opts.uri ?? config.uri;
 config.out = opts.out ?? config.out;
-config.adapters = opts.adapter ?? config.adapters ?? ["kysely"];
+config.generators = opts.generator ?? config.generators ?? ["kysely"];
 await generate(config);

package/lib/config.d.ts

@@ -4,8 +4,8 @@ export type ExtractorConfig = Exclude<ConstructorParameters<typeof Extractor>[0]
 export interface BaseConfig {
     /** The output directory for the generated models. Default: "models" */
     out?: string;
-    /** Adapters to enable. Currently supported adapters are "kysely" and "zod". Default: ["kysely"] */
-    adapters?: ("kysely" | "zod")[];
+    /** Generators to enable. Currently supported generators are "kysely" and "zod". Default: ["kysely"] */
+    generators?: ("kysely" | "zod")[];
     /** The default schema to use for the generated models. These will be unprefixed in the final `Database` interface. Default: "public" */
     defaultSchema?: string;
 }
@@ -22,27 +22,27 @@ export interface ConfigConfig extends BaseConfig {
     config: ExtractorConfig["config"];
 }
 export type TruePGConfig = Deunionise<PgConfig | UriConfig | ConfigConfig>;
-export declare const adapters: {
+export declare const generators: {
     kysely: import("./types.ts").createGenerator;
     zod: import("./types.ts").createGenerator;
 };
 export declare function config(opts: TruePGConfig): {
     out: string;
-    adapters: ("kysely" | "zod")[];
+    generators: ("kysely" | "zod")[];
     defaultSchema: string;
     pg: ExtractorConfig["pg"];
     uri?: undefined;
     config?: undefined;
 } | {
     out: string;
-    adapters: ("kysely" | "zod")[];
+    generators: ("kysely" | "zod")[];
     defaultSchema: string;
     uri: ExtractorConfig["uri"];
     pg?: undefined;
     config?: undefined;
 } | {
     out: string;
-    adapters: ("kysely" | "zod")[];
+    generators: ("kysely" | "zod")[];
     defaultSchema: string;
     config: ExtractorConfig["config"];
     pg?: undefined;

package/lib/config.js

@@ -2,19 +2,19 @@ import { normalize as normalise } from "node:path";
 import {} from "./util.js";
 import { Kysely } from "./kysely/index.js";
 import { Zod } from "./zod/index.js";
-export const adapters = {
+export const generators = {
     kysely: Kysely,
     zod: Zod,
 };
-const availableAdapters = Object.keys(adapters);
+const availableGenerators = Object.keys(generators);
 export function config(opts) {
     const out = normalise(opts.out || "./models");
-    const adapters = opts.adapters || ["kysely"];
+    const generators = opts.generators || ["kysely"];
     const defaultSchema = opts.defaultSchema || "public";
-    for (const adapter of opts.adapters ?? []) {
-        if (!availableAdapters.includes(adapter)) {
-            console.error('Requested adapter "%s" not found.', adapter);
-            console.error("Available adapters: %s", availableAdapters.join(", "));
+    for (const generator of opts.generators ?? []) {
+        if (!availableGenerators.includes(generator)) {
+            console.error('Requested generator "%s" not found.', generator);
+            console.error("Available generators: %s", availableGenerators.join(", "));
             console.error("See documentation for more information.");
             process.exit(1);
         }
@@ -26,7 +26,7 @@ export function config(opts) {
     return {
         ...opts,
         out,
-        adapters,
+        generators,
         defaultSchema,
     };
 }

package/lib/imports.d.ts

@@ -0,0 +1,35 @@
+import type { Canonical } from "./extractor/index.ts";
+import type { FunctionReturnType } from "./extractor/index.ts";
+import type { FolderStructure } from "./types.ts";
+export interface ImportIdentifier {
+    name: string;
+    alias?: string;
+    typeOnly?: boolean;
+}
+export declare class Import {
+    from: string | ((files: FolderStructure) => string);
+    namedImports?: (string | ImportIdentifier)[];
+    star?: string;
+    default?: string;
+    typeOnly?: boolean;
+    constructor(args: {
+        from: string | ((files: FolderStructure) => string);
+        namedImports?: (string | ImportIdentifier)[];
+        star?: string;
+        default?: string;
+        typeOnly?: boolean;
+    });
+    static fromInternal(opts: {
+        source: string;
+        type: Canonical | FunctionReturnType.ExistingTable;
+        withName?: string;
+        typeOnly?: boolean;
+    }): Import;
+}
+export declare class ImportList {
+    imports: Import[];
+    constructor(imports?: Import[]);
+    static merge(lists: ImportList[]): ImportList;
+    add(item: Import): void;
+    stringify(files: FolderStructure): string;
+}

package/lib/imports.js

@@ -0,0 +1,102 @@
+import { dirname, relative } from "node:path";
+import { eq } from "./util.js";
+export class Import {
+    from;
+    namedImports;
+    star;
+    default;
+    typeOnly;
+    constructor(args) {
+        this.from = args.from;
+        this.namedImports = args.namedImports;
+        this.star = args.star;
+        this.default = args.default;
+        this.typeOnly = args.typeOnly ?? false;
+    }
+    static fromInternal(opts) {
+        const t = opts.type;
+        return new Import({
+            from: files => {
+                const schema = files.children[t.schema];
+                const kind = schema.children[`${t.kind}s`];
+                const type = kind.children[t.name];
+                const path = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
+                return relative(dirname(opts.source), path);
+            },
+            namedImports: [opts.withName ?? t.name],
+            typeOnly: opts.typeOnly,
+        });
+    }
+}
+export class ImportList {
+    imports;
+    constructor(imports = []) {
+        this.imports = imports;
+    }
+    static merge(lists) {
+        return new ImportList(lists.flatMap(l => l.imports));
+    }
+    add(item) {
+        this.imports.push(item);
+    }
+    stringify(files) {
+        const modulegroups = {};
+        for (const item of this.imports) {
+            const from = typeof item.from === "function" ? item.from(files) : item.from;
+            const group = modulegroups[from];
+            if (group)
+                group.push(item);
+            else
+                modulegroups[from] = [item];
+        }
+        const imports = [];
+        const modules = Object.keys(modulegroups).sort((a, b) => {
+            const dotA = a.startsWith(".");
+            const dotB = b.startsWith(".");
+            // we could do localeCompare instead of 0, but 0 maintains order of fields for imports
+            return dotA === dotB ? 0 : dotA ? 1 : -1;
+        });
+        let broke = false;
+        for (const from of modules) {
+            if (!broke && from.startsWith(".")) {
+                imports.push("");
+                broke = true;
+            }
+            const items = modulegroups[from];
+            // unique named imports from this module
+            const namedImports = items
+                .flatMap(s => s.namedImports?.map(i => (typeof i === "string" ? { name: i, typeOnly: s.typeOnly } : i)) ?? [])
+                .filter((imp, index, arr) => {
+                if (arr.findIndex(i => eq(i, imp)) !== index)
+                    return false;
+                return true;
+            });
+            const allTypeOnly = namedImports.every(i => i.typeOnly);
+            const namedImportPart = namedImports
+                .map(i => (!allTypeOnly && i.typeOnly ? "type " : "") + i.name)
+                .join(", ");
+            const namedImportLine = namedImportPart
+                ? `import ${allTypeOnly ? "type " : ""}{ ${namedImportPart} } from "${from}";`
+                : undefined;
+            // all star imports from this module
+            const stars = items.filter(i => i.star).filter((i, index, arr) => arr.findIndex(j => eq(j, i)) === index);
+            const starImportLines = stars.map(i => `import ${i.typeOnly ? "type " : ""}* as ${i.star} from "${from}";`);
+            // all default imports from this module
+            const defaults = items
+                .filter(i => i.default)
+                .filter((i, index, arr) => arr.findIndex(j => eq(j, i)) === index);
+            const defaultImportLines = defaults.map(i => `import ${i.typeOnly ? "type " : ""}${i.default} from "${from}";`);
+            const sideEffectImports = items.find(i => !i.default && !i.star && !i.namedImports?.length);
+            const sideEffectImportLine = sideEffectImports ? `import "${sideEffectImports.from}";` : undefined;
+            if (sideEffectImportLine)
+                imports.push(sideEffectImportLine);
+            if (namedImportLine)
+                imports.push(namedImportLine);
+            if (starImportLines.length)
+                imports.push(...starImportLines);
+            if (defaultImportLines.length)
+                imports.push(...defaultImportLines);
+        }
+        return imports.join("\n");
+    }
+}

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",
                             },
                         ])),
@@ -101,14 +121,14 @@ const multifile = async (generators, schemas, opts) => {
         {
             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;
@@ -120,69 +140,60 @@ const multifile = async (generators, schemas, opts) => {
             console.log(" Creating %s:\n", kind);
             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(schemaDir, kind, 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(schemaDir, kind, "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 +201,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();
 }