true-pg 0.0.2 → 0.1.0

package/lib/types.d.ts

@@ -0,0 +1,126 @@
+import type { CanonicalType, CompositeTypeDetails, EnumDetails, FunctionDetails, TableDetails, SchemaType, Schema } from "pg-extract";
+export declare const allowed_kind_names: readonly ["tables", "enums", "composites", "functions"];
+export type allowed_kind_names = (typeof allowed_kind_names)[number];
+export interface FolderStructure {
+    name: string;
+    type: "root";
+    children: {
+        [realname: string]: {
+            name: string;
+            type: "schema";
+            children: {
+                [kind: string]: {
+                    kind: allowed_kind_names;
+                    type: "kind";
+                    children: {
+                        [realname: string]: {
+                            name: string;
+                            type: "type";
+                        };
+                    };
+                };
+            };
+        };
+    };
+}
+export declare namespace Nodes {
+    class ExternalImport {
+        name: string;
+        typeOnly: boolean;
+        star: boolean;
+        external: true;
+        module: string;
+        constructor(args: {
+            name: string;
+            module: string;
+            typeOnly: boolean;
+            star: boolean;
+        });
+    }
+    class InternalImport {
+        name: string;
+        canonical_type: CanonicalType;
+        typeOnly: boolean;
+        star: boolean;
+        external: false;
+        constructor(args: {
+            name: string;
+            canonical_type: CanonicalType;
+            typeOnly: boolean;
+            star: boolean;
+        });
+    }
+    class ImportList {
+        imports: (ExternalImport | InternalImport)[];
+        constructor(imports: (ExternalImport | InternalImport)[]);
+        static merge(lists: ImportList[]): ImportList;
+        add(item: ExternalImport | InternalImport): void;
+        stringify(context_file: string, files: FolderStructure): string;
+    }
+    interface Export {
+        name: string;
+        kind: SchemaType["kind"];
+        schema: string;
+        star: boolean;
+    }
+}
+export interface TruePGOpts {
+    uri: string;
+    out: string;
+    adapters: string[];
+    defaultSchema?: string;
+}
+export interface CreateGeneratorOpts {
+    defaultSchema?: string;
+    warnings: string[];
+}
+export interface createGenerator {
+    (opts?: CreateGeneratorOpts): SchemaGenerator;
+}
+export declare const createGenerator: (generatorCreator: createGenerator) => createGenerator;
+export interface SchemaGenerator {
+    /**
+     * Use this function to define a name mapping for schema names.
+     * This is useful if you want to use a different name for a schema in the generated code.
+     * Example: "public" -> "PublicSchema"
+     */
+    formatSchema(name: string): string;
+    /**
+     * Use this function to define a name mapping for schema types.
+     * This is useful if you want to use a different name for a type in the generated code.
+     * Example: "users" -> "UsersTable"
+     */
+    formatSchemaType(type: SchemaType): string;
+    /**
+     * Use this function to define a name mapping for type names.
+     * This is useful if you want to use a different name for a type in the generated code.
+     * Example: "users" -> "UsersTable"
+     */
+    formatType(type: CanonicalType): string;
+    table(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the table */
+    table: TableDetails): string;
+    enum(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the enum */
+    en: EnumDetails): string;
+    composite(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the composite type */
+    type: CompositeTypeDetails): string;
+    function(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the function */
+    type: FunctionDetails): string;
+    /** create the file `$out/$schema.name/$kind/index.ts` */
+    schemaKindIndex(schema: Schema, kind: Exclude<keyof Schema, "name">, main_generator?: SchemaGenerator): string;
+    /** create the file `$out/$schema.name/index.ts` */
+    schemaIndex(schema: Schema, main_generator?: SchemaGenerator): string;
+    /** create the file `$out/index.ts` */
+    fullIndex(schemas: Schema[], main_generator?: SchemaGenerator): string;
+}

package/lib/types.js

@@ -0,0 +1,167 @@
+import { dirname, relative } from "node:path";
+import { join } from "./util.js";
+// To be updated when we add support for other kinds
+export const allowed_kind_names = ["tables", "enums", "composites", "functions"];
+export var Nodes;
+(function (Nodes) {
+    class ExternalImport {
+        // what to import
+        name;
+        // use `type` syntax?
+        typeOnly;
+        // use `* as` syntax?
+        star;
+        // this is an external import
+        external;
+        // what module to import from
+        module;
+        constructor(args) {
+            this.name = args.name;
+            this.typeOnly = args.typeOnly;
+            this.star = args.star;
+            this.external = true;
+            this.module = args.module;
+        }
+    }
+    Nodes.ExternalImport = ExternalImport;
+    class InternalImport {
+        // what to import
+        name;
+        // underlying type that is being imported
+        canonical_type;
+        // use `type` syntax?
+        typeOnly;
+        // use `* as` syntax?
+        star;
+        // this is an internal import
+        external;
+        constructor(args) {
+            this.name = args.name;
+            this.canonical_type = args.canonical_type;
+            this.star = args.star;
+            this.typeOnly = args.typeOnly;
+            this.external = false;
+        }
+    }
+    Nodes.InternalImport = InternalImport;
+    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(context_file, files) {
+            const externals = this.imports.filter(i => i.external);
+            const internals = this.imports.filter(i => !i.external);
+            const modulegroups = {};
+            for (const item of externals) {
+                const group = modulegroups[item.module];
+                if (group)
+                    group.push(item);
+                else
+                    modulegroups[item.module] = [item];
+            }
+            const out = [];
+            // TODO: normalise external and internal imports and handle the stringification of the imports in a single place
+            {
+                // EXTERNAL IMPORTS
+                const imports = [];
+                for (const module in modulegroups) {
+                    const items = modulegroups[module];
+                    const star = items.find(i => i.star);
+                    const unique = items.filter((i, index, arr) => {
+                        if (i.star)
+                            return false;
+                        if (arr.findIndex(i2 => i2.name === i.name) !== index)
+                            return false;
+                        return true;
+                    });
+                    const bits = [];
+                    const typeOnlys = unique.filter(i => i.typeOnly);
+                    const values = unique.filter(i => !i.typeOnly);
+                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
+                    const typeInline = values.length !== 0;
+                    let import_line = `import `;
+                    for (const type of typeOnlys)
+                        bits.push(typeInline ? "type " : "" + type.name);
+                    for (const type of values)
+                        bits.push(type.name);
+                    if (bits.length)
+                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
+                    if (bits.length && star)
+                        import_line += `, `;
+                    if (star)
+                        import_line += `* as ${star.name}`;
+                    if (bits.length || star)
+                        import_line += ` from`;
+                    import_line += `"${module}";`;
+                    imports.push(import_line);
+                }
+                out.push(join(imports, "\n"));
+            }
+            {
+                // INTERNAL IMPORTS
+                const imports = [];
+                const unique_types = internals
+                    .filter(({ name: name1, canonical_type: int }, index, arr) => {
+                    return (arr.findIndex(({ name: name2, canonical_type: int2 }) => {
+                        return (
+                        // adapter-assigned name
+                        name2 === name1 &&
+                            // canonical type details
+                            int2.name === int.name &&
+                            int2.schema === int.schema &&
+                            int2.kind === int.kind);
+                    }) === index);
+                })
+                    .map(imp => {
+                    const t = imp.canonical_type;
+                    const schema = files.children[t.schema];
+                    const kind = schema.children[`${t.kind}s`];
+                    const type = kind.children[t.name];
+                    const located_file = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
+                    return { ...imp, located_file };
+                });
+                const group_by_file = {};
+                for (const type of unique_types) {
+                    const file = group_by_file[type.located_file] || [];
+                    file.push(type);
+                    group_by_file[type.located_file] = file;
+                }
+                for (const group in group_by_file) {
+                    let relative_path = relative(dirname(context_file), group);
+                    if (/^[^\.+\/]/.test(relative_path))
+                        relative_path = "./" + relative_path;
+                    const items = group_by_file[group];
+                    const typeOnlys = items.filter(i => i.typeOnly);
+                    const values = items.filter(i => !i.typeOnly);
+                    const star = values.find(i => i.star);
+                    let import_line = "import ";
+                    const bits = [];
+                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
+                    const typeInline = values.length !== 0;
+                    for (const type of typeOnlys)
+                        bits.push((typeInline ? "type " : "") + type.name);
+                    for (const type of values)
+                        bits.push(type.name);
+                    if (bits.length)
+                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
+                    if (star)
+                        import_line += `* as ${star.name}`;
+                    import_line += ` from "${relative_path}";`;
+                    imports.push(import_line);
+                }
+                out.push(join(imports, "\n"));
+            }
+            return join(out);
+        }
+    }
+    Nodes.ImportList = ImportList;
+})(Nodes || (Nodes = {}));
+/* convenience function to create a generator with type inference */
+export const createGenerator = (generatorCreator) => generatorCreator;

package/lib/util.d.ts

@@ -0,0 +1 @@
+export declare const join: (parts: Iterable<string>, joiner?: string) => string;

package/lib/util.js

@@ -0,0 +1 @@
+export const join = (parts, joiner = "\n\n") => Array.from(parts).filter(Boolean).join(joiner);

package/lib/zod/builtins.d.ts

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

package/lib/zod/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": "z.number()",
+    "pg_catalog.int4": "z.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": "z.string()",
+    "pg_catalog.float4": "z.number()",
+    "pg_catalog.float8": "z.number()",
+    "pg_catalog.numeric": "z.string()",
+    "pg_catalog.bool": "z.boolean()",
+    "pg_catalog.json": "z.unknown()",
+    "pg_catalog.jsonb": "z.unknown()",
+    "pg_catalog.char": "z.string()",
+    "pg_catalog.bpchar": "z.string()",
+    "pg_catalog.varchar": "z.string()",
+    "pg_catalog.text": "z.string()",
+    "pg_catalog.uuid": "z.string()",
+    "pg_catalog.inet": "z.string()",
+    "pg_catalog.date": "z.date()",
+    "pg_catalog.time": "z.date()",
+    "pg_catalog.timetz": "z.date()",
+    "pg_catalog.timestamp": "z.date()",
+    "pg_catalog.timestamptz": "z.date()",
+    "pg_catalog.int4range": "z.string()",
+    "pg_catalog.int8range": "z.string()",
+    "pg_catalog.numrange": "z.string()",
+    "pg_catalog.tsrange": "z.string()",
+    "pg_catalog.tstzrange": "z.string()",
+    "pg_catalog.daterange": "z.string()",
+    "pg_catalog.record": "z.record(z.string(), z.unknown())",
+    "pg_catalog.void": "z.void()",
+};

package/lib/zod/index.d.ts

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

package/lib/zod/index.js

@@ -0,0 +1,253 @@
+import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
+import { builtins } from "./builtins.js";
+import { join } from "../util.js";
+const isIdentifierInvalid = (str) => {
+    const invalid = str.match(/[^a-zA-Z0-9_]/);
+    return invalid !== null;
+};
+const to_snake_case = (str) => str
+    .replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
+    .replace(/[^a-zA-Z0-9]+/g, "_") // replace non-alphanumeric characters with underscores
+    .replace(/([A-Z])/g, "_$1") // insert underscores before uppercase letters
+    .toLowerCase();
+// TODO: create an insert and update zod interface for each type
+export const Zod = createGenerator(opts => {
+    const defaultSchema = opts?.defaultSchema ?? "public";
+    const zod = (imports, name) => imports.add(new Nodes.ExternalImport({
+        name: name ?? "z",
+        module: "zod",
+        typeOnly: false,
+        star: !name,
+    }));
+    const add = (imports, type) => {
+        if (type.schema === "pg_catalog")
+            zod(imports, "z");
+        else
+            imports.add(new Nodes.InternalImport({
+                name: generator.formatType(type),
+                canonical_type: type,
+                typeOnly: false,
+                star: false,
+            }));
+    };
+    const column = (imports, 
+    /** Information about the column */
+    col) => {
+        // don't create a property for always generated columns
+        if (col.generated === "ALWAYS")
+            return "";
+        let out = col.comment ? `/** ${col.comment} */\n\t` : "";
+        out += col.name;
+        let type = generator.formatType(col.type);
+        add(imports, col.type);
+        if (col.type.dimensions > 0)
+            type += ".array()".repeat(col.type.dimensions);
+        if (col.isNullable || col.generated === "BY DEFAULT" || col.defaultValue)
+            type += `.nullable().optional()`;
+        out += `: ${type}`;
+        return `\t${out},\n`;
+    };
+    const composite_attribute = (imports, attr) => {
+        let out = attr.name;
+        out += `: ${generator.formatType(attr.type)}`;
+        add(imports, attr.type);
+        if (attr.type.dimensions > 0)
+            out += ".array()".repeat(attr.type.dimensions);
+        if (attr.isNullable)
+            out += ".nullable().optional()";
+        return out;
+    };
+    const generator = {
+        formatSchema(name) {
+            return to_snake_case(name) + "_validators";
+        },
+        formatSchemaType(type) {
+            return to_snake_case(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 "z.unknown()".`);
+                return "z.unknown()";
+            }
+            return to_snake_case(type.name);
+        },
+        table(imports, table) {
+            let out = "";
+            if (table.comment)
+                out += `/** ${table.comment} */\n`;
+            out += `export const ${this.formatSchemaType(table)} = z.object({\n`;
+            zod(imports, "z");
+            for (const col of table.columns)
+                out += column(imports, col);
+            out += "});";
+            return out;
+        },
+        enum(imports, en) {
+            let out = "";
+            if (en.comment)
+                out += `/** ${en.comment} */\n`;
+            out += `export const ${this.formatSchemaType(en)} = z.union([\n`;
+            out += en.values.map(v => `\tz.literal("${v}")`).join(",\n");
+            out += "\n]);";
+            zod(imports, "z");
+            return out;
+        },
+        composite(imports, type) {
+            let out = "";
+            if (type.comment)
+                out += `/** ${type.comment} */\n`;
+            out += `export const ${this.formatSchemaType(type)} = z.object({\n`;
+            const props = type.canonical.attributes.map(c => composite_attribute(imports, c)).map(t => `\t${t},`);
+            out += props.join("\n");
+            out += "\n});";
+            return out;
+        },
+        function(imports, type) {
+            let out = "export const ";
+            out += this.formatSchemaType(type);
+            out += " = {\n";
+            out += `\tparameters: z.tuple([`;
+            // Get the input parameters (those that appear in function signature)
+            const inputParams = type.parameters.filter(p => p.mode === "IN" || p.mode === "INOUT");
+            if (inputParams.length === 0) {
+                out += "])";
+            }
+            else {
+                out += "\n";
+                for (const param of inputParams) {
+                    // TODO: update imports for non-primitive types based on typeInfo.kind
+                    out += "\t\t" + this.formatType(param.type);
+                    add(imports, param.type);
+                    if (param.type.dimensions > 0)
+                        out += ".array()".repeat(param.type.dimensions);
+                    if (param.hasDefault)
+                        out += ".nullable().optional()";
+                    out += `, // ${param.name}\n`;
+                }
+                out += "\t])";
+            }
+            const variadic = type.parameters.find(p => p.mode === "VARIADIC");
+            if (variadic) {
+                out += ".rest(";
+                out += this.formatType(variadic.type);
+                // reduce by 1 because it's already a rest parameter
+                if (variadic.type.dimensions > 1)
+                    out += ".array()".repeat(variadic.type.dimensions - 1);
+                out += ")" + ", // " + variadic.name + "\n";
+            }
+            else
+                out += ",\n";
+            out += "\treturnType: ";
+            if (type.returnType.kind === "table") {
+                out += "z.object({\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 += ".array()".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 += ".array()".repeat(type.returnType.type.dimensions);
+            }
+            // Add additional array brackets if it returns a set
+            if (type.returnType.isSet)
+                out += ".array()";
+            out += ",\n};";
+            return out;
+        },
+        schemaKindIndex(schema, kind, main_generator) {
+            const imports = schema[kind];
+            if (imports.length === 0)
+                return "";
+            const generator = main_generator ?? this;
+            return imports
+                .map(each => {
+                const name = this.formatSchemaType(each);
+                const file = generator.formatSchemaType(each);
+                return `export { ${name} } from "./${file}.ts";`;
+            })
+                .join("\n");
+        },
+        schemaIndex(schema, main_generator) {
+            let out = allowed_kind_names.map(kind => `import * as zod_${kind} from "./${kind}/index.ts";`).join("\n");
+            out += "\n\n";
+            out += `export const ${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}: zod_${t.kind}s.${t.formatted},`;
+                })
+                    .join("\n");
+                out += "\n\t},\n";
+            }
+            out += "}";
+            return out;
+        },
+        fullIndex(schemas, main_generator) {
+            const generator = main_generator ?? this;
+            let out = "";
+            out += schemas
+                .map(s => `import { ${generator.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+                .join("\n");
+            out += "\n\n";
+            out += `export const Validators = {\n`;
+            out += join(schemas.map(schema => {
+                const schema_validators = join(allowed_kind_names.map(kind => {
+                    const current = schema[kind];
+                    const seen = new Set();
+                    const formatted = current
+                        .map(each => {
+                        const formatted = generator.formatSchemaType(each);
+                        // skip clashing names
+                        if (seen.has(formatted))
+                            return;
+                        seen.add(formatted);
+                        return { ...each, formatted };
+                    })
+                        .filter(x => x !== undefined);
+                    if (!formatted.length)
+                        return "";
+                    let out = "";
+                    out += "\t// " + kind + "\n";
+                    out += join(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}"],`;
+                    }), "\n");
+                    return out;
+                }));
+                return `\t/* -- ${schema.name} --*/\n\n` + schema_validators || "\t-- no validators\n\n";
+            }));
+            out += "\n}\n\n";
+            out += schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n");
+            return out;
+        },
+    };
+    return generator;
+});

package/package.json

@@ -1,12 +1,15 @@
 {
 	"name": "true-pg",
-	"version": "0.0.2",
+	"version": "0.1.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",
 	"bin": {
 		"true-pg": "lib/bin.js"
 	},
+	"files": [
+		"lib"
+	],
 	"scripts": {
 		"check": "tsc --noEmit",
 		"build": "tsc"

package/.github/workflows/releases.yml

@@ -1,29 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - v*
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      id-token: write
-
-    steps:
-    - uses: actions/checkout@v4
-    - uses: oven-sh/setup-bun@v2
-    - run : bun install
-    - run : bun run prepare
-    - name: Publish to npm
-      run : |
-        bun run version.ts
-        bun publish --ignore-scripts --access=public
-      env :
-        NPM_CONFIG_TOKEN: ${{ secrets.NPM_CONFIG_TOKEN }}
-        NPM_CONFIG_PROVENANCE: true
-    - name: Publish to JSR
-      run: bunx jsr publish --allow-dirty