true-pg 0.0.2 → 0.1.0

package/lib/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/bin.js

@@ -0,0 +1,67 @@
+import mri from "mri";
+import { existsSync } from "fs";
+import { generate, adapters } from "./index.js";
+const args = process.argv.slice(2);
+const opts = mri(args, {
+    boolean: ["help", "all-adapters"],
+    string: ["config", "uri", "out", "adapter"],
+    alias: {
+        h: "help",
+        c: "config",
+        u: "uri",
+        o: "out",
+        a: "adapter",
+        A: "all-adapters",
+    },
+});
+const help = opts.help || (!opts.config && !opts.uri);
+if (help) {
+    // if help is triggered unintentionally, it's a user error
+    const type = opts.help ? "log" : "error";
+    const log = console[type];
+    log();
+    log("Usage: true-pg [options]");
+    log();
+    log("Options:");
+    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("  -c, --config   [path]       Path to config file (JSON)");
+    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();
+    if (opts.help)
+        process.exit(0);
+    else
+        process.exit(1);
+}
+let configfile = opts.config;
+if (!configfile) {
+    const candidates = [".truepgrc.json", ".config/.truepgrc.json"];
+    for (const candidate of candidates) {
+        if (await existsSync(candidate)) {
+            configfile = candidate;
+            break;
+        }
+    }
+}
+const config = configfile ? await Bun.file(configfile).json() : {};
+if (opts["all-adapters"]) {
+    opts.adapter = Object.keys(adapters);
+    console.log("Enabling all built-in adapters:", opts.adapter);
+}
+if (!(opts.adapter || config.adapters))
+    console.warn('No adapters specified, using default: ["kysely"]');
+opts.out ??= "models";
+// allow single adapter or comma-separated list of adapters
+if (typeof opts.adapter === "string")
+    opts.adapter = opts.adapter.split(",");
+opts.adapter ??= ["kysely"];
+// 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;
+await generate(config);

package/lib/consumer.d.ts

@@ -0,0 +1,23 @@
+export declare namespace True {
+    type Column<Selectable, Insertable = Selectable, Updateable = Selectable> = {
+        "@true-pg/insert": Insertable;
+        "@true-pg/update": Updateable;
+        "@true-pg/select": Selectable;
+    };
+    type Generated<T> = Column<T, T | undefined, T | undefined>;
+    type HasDefault<T> = Column<T, T | undefined, T | undefined>;
+    type AlwaysGenerated<T> = Column<T, never, never>;
+    type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+    type Simplify<T> = DrainOuterGeneric<{
+        [K in keyof T]: T[K];
+    } & {}>;
+    type Selectable<T extends Record<string, any>> = Simplify<{
+        [K in keyof T]: T[K] extends Record<string, any> ? Selectable<T[K]> : T[K] extends Column<infer S, infer I, infer U> ? S : T[K];
+    }>;
+    type Insertable<T extends Record<string, any>> = Simplify<{
+        [K in keyof T]: T[K] extends Record<string, any> ? Insertable<T[K]> : T[K] extends Column<infer S, infer I, infer U> ? I : T[K];
+    }>;
+    type Updateable<T extends Record<string, any>> = Simplify<{
+        [K in keyof T]?: T[K] extends Record<string, any> ? Updateable<T[K]> : T[K] extends Column<infer S, infer I, infer U> ? U : T[K];
+    }>;
+}

package/lib/consumer.js

@@ -0,0 +1 @@
+export {};

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import { type TruePGOpts, type createGenerator } from "./types.ts";
+export declare const adapters: Record<string, createGenerator>;
+export * from "./consumer.ts";
+export declare function generate(opts: TruePGOpts, generators?: createGenerator[]): Promise<void>;

package/lib/index.js

@@ -0,0 +1,150 @@
+import { Extractor } from "pg-extract";
+import { rm, mkdir, writeFile } from "fs/promises";
+import { Nodes, allowed_kind_names } from "./types.js";
+import { existsSync } from "fs";
+import { join } from "./util.js";
+import { Kysely } from "./kysely/index.js";
+import { Zod } from "./zod/index.js";
+export const adapters = {
+    kysely: Kysely,
+    zod: Zod,
+};
+export * from "./consumer.js";
+const filter_function = (func, warnings) => {
+    const typesToFilter = [
+        "pg_catalog.trigger",
+        "pg_catalog.event_trigger",
+        "pg_catalog.internal",
+        "pg_catalog.language_handler",
+        "pg_catalog.fdw_handler",
+        "pg_catalog.index_am_handler",
+        "pg_catalog.tsm_handler",
+    ];
+    const warn = (type) => warnings.push(`Skipping function ${func.name}: cannot represent ${type} (safe to ignore)`);
+    if (func.returnType.kind === "table") {
+        for (const col of func.returnType.columns) {
+            if (typesToFilter.includes(col.type.canonical_name)) {
+                warn(col.type.canonical_name);
+                return false;
+            }
+        }
+    }
+    else {
+        if (typesToFilter.includes(func.returnType.type.canonical_name)) {
+            warn(func.returnType.type.canonical_name);
+            return false;
+        }
+    }
+    for (const param of func.parameters) {
+        if (typesToFilter.includes(param.type.canonical_name)) {
+            warn(param.type.canonical_name);
+            return false;
+        }
+    }
+    return func;
+};
+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 def_gen = gens[0];
+    const files = {
+        name: out,
+        type: "root",
+        children: Object.fromEntries(Object.values(schemas).map(schema => [
+            schema.name,
+            {
+                name: schema.name,
+                type: "schema",
+                children: Object.fromEntries(allowed_kind_names.map(kind => [
+                    kind,
+                    {
+                        kind: kind,
+                        type: "kind",
+                        children: Object.fromEntries(schema[kind].map(item => [
+                            item.name,
+                            {
+                                name: def_gen.formatSchemaType(item),
+                                type: "type",
+                            },
+                        ])),
+                    },
+                ])),
+            },
+        ])),
+    };
+    const start = performance.now();
+    for (const schema of Object.values(schemas)) {
+        console.log("Selected schema '%s':\n", schema.name);
+        const schemaDir = `${out}/${schema.name}`;
+        // skip functions that cannot be represented in JavaScript
+        schema.functions = schema.functions.filter(f => filter_function(f, warnings));
+        for (const kind of allowed_kind_names) {
+            if (schema[kind].length < 1)
+                continue;
+            await mkdir(`${schemaDir}/${kind}`, { recursive: true });
+            console.log(" Creating %s:\n", kind);
+            for (const [i, item] of schema[kind].entries()) {
+                const index = "[" + (i + 1 + "]").padEnd(3, " ");
+                const filename = `${schemaDir}/${kind}/${def_gen.formatSchemaType(item)}.ts`;
+                const exists = await existsSync(filename);
+                if (exists) {
+                    warnings.push(`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 === "composite")
+                    file += join(gens.map(gen => gen.composite(imports, item)));
+                if (item.kind === "enum")
+                    file += join(gens.map(gen => gen.enum(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);
+                await write(filename, file);
+                const end = performance.now();
+                console.log("  %s %s \x1b[32m(%sms)\x1B[0m", index, filename, (end - start).toFixed(2));
+            }
+            const kindIndex = join(gens.map(gen => gen.schemaKindIndex(schema, kind, def_gen)));
+            const kindIndexFilename = `${schemaDir}/${kind}/index.ts`;
+            await write(kindIndexFilename, kindIndex);
+            console.log('  ✅   Created "%s" %s index: %s\n', schema.name, kind, kindIndexFilename);
+        }
+        const index = join(gens.map(gen => gen.schemaIndex(schema, def_gen)));
+        const indexFilename = `${out}/${schema.name}/index.ts`;
+        await write(indexFilename, index);
+        console.log(" Created schema index: %s\n", indexFilename);
+    }
+    const fullIndex = join(gens.map(gen => gen.fullIndex(Object.values(schemas))));
+    const fullIndexFilename = `${out}/index.ts`;
+    await write(fullIndexFilename, fullIndex);
+    console.log("Created full index: %s", fullIndexFilename);
+    const end = performance.now();
+    console.log("Completed in \x1b[32m%sms\x1b[0m", (end - start).toFixed(2));
+    if (warnings.length > 0) {
+        console.log("\nWarnings generated:");
+        console.log(warnings.map(warning => "* " + warning).join("\n"));
+    }
+};
+export async function generate(opts, generators) {
+    const out = opts.out || "./models";
+    const extractor = new Extractor(opts.uri);
+    const schemas = await extractor.extractSchemas();
+    generators ??= opts.adapters.map(adapter => {
+        const selected = adapters[adapter];
+        if (!selected)
+            throw new Error(`Requested adapter ${adapter} not found`);
+        return selected;
+    });
+    console.log("Clearing directory and generating schemas at '%s'", out);
+    await rm(out, { recursive: true, force: true });
+    await mkdir(out, { recursive: true });
+    await multifile(generators, schemas, { ...opts, out });
+}

package/lib/kysely/builtins.d.ts

@@ -0,0 +1 @@
+export declare const builtins: Record<string, string>;

package/lib/kysely/builtins.js

@@ -0,0 +1,35 @@
+// extended from https://github.com/kristiandupont/kanel/blob/e9332f03ff5e38f5b844dd7a4563580c0d9d1444/packages/kanel/src/defaultTypeMap.ts
+export const builtins = {
+    "pg_catalog.int2": "number",
+    "pg_catalog.int4": "number",
+    // JS numbers are always floating point, so there is only 53 bits of precision
+    // for the integer part. Thus, storing a 64-bit integer in a JS number will
+    // result in potential data loss. We therefore use strings for 64-bit integers
+    // the same way that the pg driver does.
+    "pg_catalog.int8": "string",
+    "pg_catalog.float4": "number",
+    "pg_catalog.float8": "number",
+    "pg_catalog.numeric": "string",
+    "pg_catalog.bool": "boolean",
+    "pg_catalog.json": "unknown",
+    "pg_catalog.jsonb": "unknown",
+    "pg_catalog.char": "string",
+    "pg_catalog.bpchar": "string",
+    "pg_catalog.varchar": "string",
+    "pg_catalog.text": "string",
+    "pg_catalog.uuid": "string",
+    "pg_catalog.inet": "string",
+    "pg_catalog.date": "Date",
+    "pg_catalog.time": "Date",
+    "pg_catalog.timetz": "Date",
+    "pg_catalog.timestamp": "Date",
+    "pg_catalog.timestamptz": "Date",
+    "pg_catalog.int4range": "string",
+    "pg_catalog.int8range": "string",
+    "pg_catalog.numrange": "string",
+    "pg_catalog.tsrange": "string",
+    "pg_catalog.tstzrange": "string",
+    "pg_catalog.daterange": "string",
+    "pg_catalog.record": "Record<string, unknown>",
+    "pg_catalog.void": "void",
+};

package/lib/kysely/index.d.ts

@@ -0,0 +1,2 @@
+import { createGenerator } from "../types.ts";
+export declare const Kysely: createGenerator;

package/lib/kysely/index.js

@@ -0,0 +1,273 @@
+import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
+import { builtins } from "./builtins.js";
+const isIdentifierInvalid = (str) => {
+    const invalid = str.match(/[^a-zA-Z0-9_]/);
+    return invalid !== null;
+};
+const toPascalCase = (str) => str
+    .replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
+    .replace(/[^a-zA-Z0-9_]+/g, "") // remove non-alphanumeric/underscore characters
+    .replace(" ", "_") // replace spaces with underscores
+    .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()) // capitalize letters after underscores
+    .replace(/^([a-z])/, (_, letter) => letter.toUpperCase()); // capitalize first letter
+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,
+            typeOnly: true,
+            star: false,
+        }));
+    };
+    const column = (
+    /** "this" */
+    generator, 
+    /** @out Append used types to this array */
+    imports, 
+    /** 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 qualified = base;
+        if (col.generated === "ALWAYS") {
+            qualified = `GeneratedAlways<${qualified}>`;
+            ky(imports, "GeneratedAlways");
+        }
+        else if (col.generated === "BY DEFAULT") {
+            qualified = `Generated<${qualified}>`;
+            ky(imports, "Generated");
+        }
+        else if (col.defaultValue) {
+            qualified = `Generated<${qualified}>`;
+            ky(imports, "Generated");
+        }
+        let out = col.comment ? `/** ${col.comment} */\n\t` : "";
+        out += 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) => {
+        let out = 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";
+        return out;
+    };
+    const generator = {
+        formatSchema(name) {
+            return toPascalCase(name) + "Schema";
+        },
+        formatSchemaType(type) {
+            return toPascalCase(type.name);
+        },
+        formatType(type) {
+            if (type.schema === "pg_catalog") {
+                const name = type.canonical_name;
+                const format = builtins[name];
+                if (format)
+                    return format;
+                opts?.warnings?.push(`Unknown builtin type: ${name}! Pass customBuiltinMap to map this type. Defaulting to "unknown".`);
+                return "unknown";
+            }
+            return toPascalCase(type.name);
+        },
+        table(imports, table) {
+            let out = "";
+            if (table.comment)
+                out += `/** ${table.comment} */\n`;
+            out += `export interface ${this.formatSchemaType(table)} {\n`;
+            for (const col of table.columns)
+                out += column(this, imports, col);
+            out += "}";
+            return out;
+        },
+        enum(imports, en) {
+            let out = "";
+            if (en.comment)
+                out += `/** ${en.comment} */\n`;
+            out += `export type ${this.formatSchemaType(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
+            return out;
+        },
+        composite(imports, 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 += props.join("\n");
+            out += "\n}";
+            return out;
+        },
+        function(imports, type) {
+            let out = "";
+            out += "/**\n";
+            if (type.comment)
+                out += ` * ${type.comment}\n`;
+            out += ` * @volatility ${type.volatility}\n`;
+            out += ` * @parallelSafety ${type.parallelSafety}\n`;
+            out += ` * @isStrict ${type.isStrict}\n`;
+            out += " */\n";
+            out += `export interface ${this.formatSchemaType(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) {
+                out += "(): ";
+            }
+            else if (inputParams.length === 1) {
+                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 += "): ";
+            }
+            else if (inputParams.length > 0) {
+                out += "(\n";
+                for (const param of inputParams) {
+                    // Handle variadic parameters differently if needed
+                    const isVariadic = param.mode === "VARIADIC";
+                    const paramName = isVariadic ? `...${param.name}` : param.name;
+                    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);
+                    if (!isVariadic)
+                        out += ",";
+                    out += "\n";
+                }
+                out += "\t): ";
+            }
+            if (type.returnType.kind === "table") {
+                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 += `;\n`;
+                }
+                out += "\t}";
+            }
+            else {
+                out += this.formatType(type.returnType.type);
+                add(imports, type.returnType.type);
+                if (type.returnType.type.dimensions > 0)
+                    out += "[]".repeat(type.returnType.type.dimensions);
+            }
+            // Add additional array brackets if it returns a set
+            if (type.returnType.isSet) {
+                out += "[]";
+            }
+            out += ";\n}";
+            return out;
+        },
+        schemaKindIndex(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);
+                return `export type { ${name} } from "./${file}.ts";`;
+            })
+                .join("\n");
+        },
+        schemaIndex(schema) {
+            let out = allowed_kind_names.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
+            out += "\n\n";
+            out += `export interface ${this.formatSchema(schema.name)} {\n`;
+            for (const kind of allowed_kind_names) {
+                const items = schema[kind];
+                if (items.length === 0)
+                    continue;
+                out += `\t${kind}: {\n`;
+                const formatted = items
+                    .map(each => {
+                    const formatted = this.formatSchemaType(each);
+                    return { ...each, formatted };
+                })
+                    .filter(x => x !== undefined);
+                out += formatted
+                    .map(t => {
+                    let name = t.name;
+                    if (isIdentifierInvalid(name))
+                        name = `"${name}"`;
+                    return `\t\t${name}: ${t.kind}s.${t.formatted};`;
+                })
+                    .join("\n");
+                out += "\n\t};\n";
+            }
+            out += "}";
+            return out;
+        },
+        fullIndex(schemas) {
+            let out = "";
+            out += schemas
+                .map(s => `import type { ${this.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+                .join("\n");
+            out += "\n\n";
+            out += `export interface Database {\n`;
+            out += schemas
+                .map(schema => {
+                // Kysely only wants tables
+                const tables = schema.tables;
+                let out = "";
+                const seen = new Set();
+                const formatted = tables
+                    .map(each => {
+                    const formatted = this.formatSchemaType(each);
+                    // skip clashing names
+                    if (seen.has(formatted))
+                        return;
+                    seen.add(formatted);
+                    return { ...each, formatted };
+                })
+                    .filter(x => x !== undefined);
+                if (out.length)
+                    out += "\n\n";
+                out += formatted
+                    .map(t => {
+                    const prefix = defaultSchema === schema.name ? "" : schema.name + ".";
+                    let qualified = prefix + t.name;
+                    if (isIdentifierInvalid(qualified))
+                        qualified = `"${qualified}"`;
+                    return `\t${qualified}: ${this.formatSchema(schema.name)}["${t.kind}s"]["${t.name}"];`;
+                })
+                    .join("\n");
+                return out;
+            })
+                .join("");
+            out += "\n}\n\n";
+            out += schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n");
+            return out;
+        },
+    };
+    return generator;
+});