true-pg 0.5.0 → 0.6.0

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/extractor/index.d.ts

@@ -9,6 +9,7 @@ import { type FunctionDetails } from "./kinds/function.ts";
 import { type DomainDetails } from "./kinds/domain.ts";
 import { type RangeDetails } from "./kinds/range.ts";
 import type { PgType } from "./pgtype.ts";
+export { pgTypeKinds, type PgType, type Kind } from "./pgtype.ts";
 import { Canonical } from "./canonicalise.ts";
 export { Canonical };
 export type { TableDetails, ViewDetails, MaterializedViewDetails, EnumDetails, CompositeTypeDetails, FunctionDetails, DomainDetails, RangeDetails, };
@@ -23,14 +24,14 @@ export { FunctionReturnTypeKind } from "./kinds/function.ts";
  */
 export type Schema = {
     name: string;
-    tables: TableDetails[];
-    views: ViewDetails[];
-    materializedViews: MaterializedViewDetails[];
-    enums: EnumDetails[];
-    composites: CompositeTypeDetails[];
-    functions: FunctionDetails[];
-    domains: DomainDetails[];
-    ranges: RangeDetails[];
+    table: TableDetails[];
+    view: ViewDetails[];
+    materializedView: MaterializedViewDetails[];
+    enum: EnumDetails[];
+    composite: CompositeTypeDetails[];
+    function: FunctionDetails[];
+    domain: DomainDetails[];
+    range: RangeDetails[];
 };
 export type SchemaType = TableDetails | ViewDetails | MaterializedViewDetails | EnumDetails | CompositeTypeDetails | FunctionDetails | DomainDetails | RangeDetails;
 /**

package/lib/extractor/index.js

@@ -10,18 +10,19 @@ import extractFunction, {} from "./kinds/function.js";
 import extractDomain, {} from "./kinds/domain.js";
 import extractRange, {} from "./kinds/range.js";
 import fetchTypes from "./fetchTypes.js";
+export { pgTypeKinds } from "./pgtype.js";
 import { canonicalise, Canonical } from "./canonicalise.js";
 export { Canonical };
 export { FunctionReturnTypeKind } from "./kinds/function.js";
 const emptySchema = {
-    tables: [],
-    views: [],
-    materializedViews: [],
-    enums: [],
-    composites: [],
-    functions: [],
-    domains: [],
-    ranges: [],
+    table: [],
+    view: [],
+    materializedView: [],
+    enum: [],
+    composite: [],
+    function: [],
+    domain: [],
+    range: [],
 };
 const populatorMap = {
     table: extractTable,
@@ -133,10 +134,7 @@ export class Extractor {
                     ...emptySchema,
                 };
             }
-            schemas[p.schemaName][`${p.kind}s`] = [
-                ...schemas[p.schemaName][`${p.kind}s`],
-                p,
-            ];
+            schemas[p.schemaName][p.kind] = [...schemas[p.schemaName][p.kind], p];
         }
         const result = 
         //  options?.resolveViews

package/lib/extractor/pgtype.d.ts

@@ -1,9 +1,9 @@
 export declare const typeKindMap: {
-    readonly d: "domain";
     readonly e: "enum";
+    readonly d: "domain";
     readonly r: "range";
 };
-type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
+export type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
 export declare const classKindMap: {
     readonly r: "table";
     readonly p: "table";
@@ -11,12 +11,13 @@ export declare const classKindMap: {
     readonly m: "materializedView";
     readonly c: "composite";
 };
-type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
+export type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
 export declare const routineKindMap: {
     readonly f: "function";
 };
-type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
-export type Kind = TypeKind | ClassKind | RoutineKind;
+export type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
+export declare const pgTypeKinds: ("function" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
+export type Kind = (typeof pgTypeKinds)[number];
 /**
  * Base type for Postgres objects.
  */
@@ -38,4 +39,3 @@ export type PgType<K extends Kind = Kind> = {
      */
     comment: string | null;
 };
-export {};

package/lib/extractor/pgtype.js

@@ -1,6 +1,6 @@
 export const typeKindMap = {
-    d: "domain",
     e: "enum",
+    d: "domain",
     r: "range",
     // Not supported (yet):
     // m: 'multiRange',
@@ -28,3 +28,9 @@ export const routineKindMap = {
     // a: 'aggregate',
     // w: 'windowFunction',
 };
+const unique = (arr) => [...new Set(arr)];
+export const pgTypeKinds = unique([
+    ...Object.values(classKindMap),
+    ...Object.values(typeKindMap),
+    ...Object.values(routineKindMap),
+]);

package/lib/imports.d.ts

@@ -0,0 +1,41 @@
+import type { Canonical } from "./extractor/index.ts";
+import type { FunctionReturnType } from "./extractor/index.ts";
+import type { allowed_kind_names, FolderStructure } from "./types.ts";
+export interface ImportIdentifier {
+    name: string;
+    alias?: string;
+    typeOnly?: boolean;
+}
+type Supported<T> = {
+    [key in allowed_kind_names]: T extends {
+        kind: key;
+    } ? T : never;
+}[allowed_kind_names];
+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: Supported<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;
+}
+export {};

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];
+                const type = kind.children[t.name];
+                const path = `${files.name}/${schema.name}/${kind.kind}s/${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");
+    }
+}