true-pg 0.5.0 → 0.6.0

package/lib/zod/index.js

@@ -1,28 +1,18 @@
-import { FunctionReturnTypeKind, } from "../extractor/index.js";
-import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
+import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
+import { allowed_kind_names, createGenerator } from "../types.js";
+import { Import } from "../imports.js";
 import { builtins } from "./builtins.js";
 import { to_snake_case, join, quote, quoteI } from "../util.js";
 // 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",
+    const zod = (ctx, name) => ctx.imports.add(new Import({
+        from: "zod",
+        namedImports: name ? [name] : undefined,
         typeOnly: false,
-        star: !name,
+        star: name ? undefined : "z",
     }));
-    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, 
+    const column = (ctx, 
     /** Information about the column */
     col) => {
         // don't create a property for always generated columns
@@ -30,114 +20,137 @@ export const Zod = createGenerator(opts => {
             return "";
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(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()`;
+        const nullable = col.isNullable || col.generated === "BY DEFAULT" || col.defaultValue;
+        let type = generator.formatType(ctx, col.type, { nullable });
+        if (nullable)
+            type += `.optional()`;
         out += `: ${type}`;
         return `\t${out},\n`;
     };
-    const composite_attribute = (imports, attr) => {
+    const composite_attribute = (ctx, attr) => {
         let out = quoteI(attr.name);
-        out += `: ${generator.formatType(attr.type)}`;
-        add(imports, attr.type);
-        if (attr.type.dimensions > 0)
-            out += ".array()".repeat(attr.type.dimensions);
+        out += `: ${generator.formatType(ctx, attr.type, { nullable: attr.isNullable })}`;
         if (attr.isNullable)
-            out += ".nullable().optional()";
+            out += ".optional()";
         return out;
     };
     const generator = {
-        formatSchema(name) {
+        formatSchemaName(name) {
             return to_snake_case(name) + "_validators";
         },
-        formatSchemaType(type) {
+        formatSchemaMemberName(type) {
             return to_snake_case(type.name);
         },
-        formatType(type) {
+        formatType(ctx, type, attr) {
+            let base;
             if (type.kind === FunctionReturnTypeKind.ExistingTable) {
-                return to_snake_case(type.name);
+                base = to_snake_case(type.name);
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: false,
+                }));
             }
-            else if (type.schema === "pg_catalog") {
+            else if (type.schema === "pg_catalog" ||
+                type.kind === Canonical.Kind.Base ||
+                type.kind === Canonical.Kind.Pseudo) {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
-                    return format;
-                opts?.warnings?.push(`(zod) Unknown builtin type: ${name}. Pass customBuiltinMap to map this type. Defaulting to "z.unknown()".`);
-                return "z.unknown()";
+                    base = format;
+                else {
+                    opts?.warnings?.add(`(zod) Unknown base type: ${name}. Pass 'zod.builtinMap' to map this type. Defaulting to "z.unknown()".`);
+                    base = "z.unknown()";
+                }
+                ctx.imports.add(new Import({
+                    from: "zod",
+                    namedImports: ["z"],
+                }));
             }
-            return to_snake_case(type.name);
+            else {
+                base = to_snake_case(type.name);
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: false,
+                }));
+            }
+            if ("dimensions" in type)
+                base += ".array()".repeat(type.dimensions);
+            if (attr?.nullable)
+                base += ".nullable()";
+            return base;
         },
-        table(imports, table) {
+        table(ctx, table) {
             let out = "";
             if (table.comment)
                 out += `/** ${table.comment} */\n`;
-            out += `export const ${this.formatSchemaType(table)} = z.object({\n`;
-            zod(imports, "z");
+            out += `export const ${this.formatSchemaMemberName(table)} = z.object({\n`;
+            zod(ctx, "z");
             for (const col of table.columns)
-                out += column(imports, col);
+                out += column(ctx, col);
             out += "});";
             return out;
         },
-        view(imports, view) {
+        view(ctx, view) {
             let out = "";
             if (view.comment)
                 out += `/** ${view.comment} */\n`;
-            zod(imports, "z");
-            out += `export const ${this.formatSchemaType(view)} = z.object({\n`;
+            zod(ctx, "z");
+            out += `export const ${this.formatSchemaMemberName(view)} = z.object({\n`;
             for (const col of view.columns)
-                out += column(imports, col);
+                out += column(ctx, col);
             out += "});";
             return out;
         },
-        materializedView(imports, materializedView) {
+        materializedView(ctx, materializedView) {
             let out = "";
             if (materializedView.comment)
                 out += `/** ${materializedView.comment} */\n`;
-            zod(imports, "z");
-            out += `export const ${this.formatSchemaType(materializedView)} = z.object({\n`;
+            zod(ctx, "z");
+            out += `export const ${this.formatSchemaMemberName(materializedView)} = z.object({\n`;
             for (const col of materializedView.columns)
-                out += column(imports, col);
+                out += column(ctx, col);
             out += "});";
             return out;
         },
-        enum(imports, en) {
+        enum(ctx, en) {
             let out = "";
             if (en.comment)
                 out += `/** ${en.comment} */\n`;
-            out += `export const ${this.formatSchemaType(en)} = z.union([\n`;
+            out += `export const ${this.formatSchemaMemberName(en)} = z.union([\n`;
             out += en.values.map(v => `\tz.literal("${v}")`).join(",\n");
             out += "\n]);";
-            zod(imports, "z");
+            zod(ctx, "z");
             return out;
         },
-        composite(imports, type) {
+        composite(ctx, 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 += `export const ${this.formatSchemaMemberName(type)} = z.object({\n`;
+            zod(ctx, "z");
+            const props = type.canonical.attributes.map(c => composite_attribute(ctx, c)).map(t => `\t${t},`);
             out += props.join("\n");
             out += "\n});";
             return out;
         },
-        domain(imports, type) {
+        domain(ctx, type) {
             let out = "";
-            out += `export const ${this.formatSchemaType(type)} = ${this.formatType(type.canonical.domain_base_type)};`;
-            zod(imports, "z");
+            out += `export const ${this.formatSchemaMemberName(type)} = ${this.formatType(ctx, type.canonical.domain_base_type)};`;
             return out;
         },
-        range(imports, type) {
+        range(ctx, type) {
             let out = "";
-            out += `export const ${this.formatSchemaType(type)} = z.string();`;
-            zod(imports, "z");
+            out += `export const ${this.formatSchemaMemberName(type)} = z.string();`;
+            zod(ctx, "z");
             return out;
         },
-        function(imports, type) {
+        function(ctx, type) {
             let out = "export const ";
-            out += this.formatSchemaType(type);
+            out += this.formatSchemaMemberName(type);
             out += " = {\n";
             out += `\tparameters: z.tuple([`;
             // Get the input parameters (those that appear in function signature)
@@ -149,12 +162,9 @@ export const Zod = createGenerator(opts => {
                 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);
+                    out += "\t\t" + this.formatType(ctx, param.type, { nullable: param.hasDefault });
                     if (param.hasDefault)
-                        out += ".nullable().optional()";
+                        out += ".optional()";
                     out += `, // ${param.name}\n`;
                 }
                 out += "\t])";
@@ -162,10 +172,8 @@ export const Zod = createGenerator(opts => {
             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 += this.formatType(ctx, { ...variadic.type, dimensions: variadic.type.dimensions - 1 });
                 out += ")" + ", // " + variadic.name + "\n";
             }
             else
@@ -176,60 +184,54 @@ export const Zod = createGenerator(opts => {
                     out += "z.void()/* RETURNS TABLE with no columns */";
                 else {
                     out += "z.object({\n";
+                    zod(ctx, "z");
                     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 += this.formatType(ctx, col.type); // ignore nullability of inline table columns
                         out += `,\n`;
                     }
                     out += "\t})";
                 }
             }
             else if (type.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
-                out += this.formatType(type.returnType);
-                add(imports, type.returnType);
+                out += this.formatType(ctx, type.returnType);
             }
             else {
-                out += this.formatType(type.returnType.type);
-                add(imports, type.returnType.type);
-                if (type.returnType.type.dimensions > 0)
-                    out += ".array()".repeat(type.returnType.type.dimensions);
+                out += this.formatType(ctx, type.returnType.type);
             }
             // Add additional array brackets if it returns a set
             if (type.returnType.isSet)
                 out += ".array()";
             out += ",\n};";
-            zod(imports, "z");
             return out;
         },
-        schemaKindIndex(schema, kind, main_generator) {
+        schemaKindIndex(ctx, 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);
+                const name = this.formatSchemaMemberName(each);
+                const file = generator.formatSchemaMemberName(each);
                 return `export { ${name} } from "./${file}.ts";`;
             })
                 .join("\n");
         },
-        schemaIndex(schema, main_generator) {
+        schemaIndex(ctx, schema, main_generator) {
             const actual_kinds = allowed_kind_names.filter(kind => schema[kind].length);
-            let out = actual_kinds.map(kind => `import * as zod_${kind} from "./${kind}/index.ts";`).join("\n");
+            // we could in theory use the imports from GeneratorContext here, but this works fine
+            let out = actual_kinds.map(kind => `import * as zod_${kind}s from "./${kind}s/index.ts";`).join("\n");
             out += "\n\n";
-            out += `export const ${this.formatSchema(schema.name)} = {\n`;
+            out += `export const ${this.formatSchemaName(schema.name)} = {\n`;
             for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
                     continue;
-                out += `\t${kind}: {\n`;
+                out += `\t${kind}s: {\n`;
                 const formatted = items
                     .map(each => {
-                    const formatted = this.formatSchemaType(each);
+                    const formatted = this.formatSchemaMemberName(each);
                     return { ...each, formatted };
                 })
                     .filter(x => x !== undefined);
@@ -244,11 +246,11 @@ export const Zod = createGenerator(opts => {
             out += "}";
             return out;
         },
-        fullIndex(schemas, main_generator) {
+        fullIndex(ctx, schemas, main_generator) {
             const generator = main_generator ?? this;
             const parts = [];
             parts.push(schemas
-                .map(s => `import { ${generator.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+                .map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
                 .join("\n"));
             {
                 let validator = `export const Validators = {\n`;
@@ -258,7 +260,7 @@ export const Zod = createGenerator(opts => {
                         const seen = new Set();
                         const formatted = current
                             .map(each => {
-                            const formatted = generator.formatSchemaType(each);
+                            const formatted = generator.formatSchemaMemberName(each);
                             // skip clashing names
                             if (seen.has(formatted))
                                 return;
@@ -269,7 +271,7 @@ export const Zod = createGenerator(opts => {
                         if (!formatted.length)
                             return "";
                         let out = "";
-                        out += "\t// " + kind + "\n";
+                        out += "\t// " + kind + "s\n";
                         out += join(formatted.map(t => {
                             const isDefault = defaultSchema === schema.name;
                             let qualified = "";
@@ -278,7 +280,7 @@ export const Zod = createGenerator(opts => {
                             else
                                 qualified = t.name;
                             qualified = quoteI(qualified);
-                            return `\t${qualified}: ${this.formatSchema(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}],`;
+                            return `\t${qualified}: ${this.formatSchemaName(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}],`;
                         }), "\n");
                         return out;
                     }));
@@ -287,7 +289,7 @@ export const Zod = createGenerator(opts => {
                 validator += "\n};";
                 parts.push(validator);
             }
-            parts.push(schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n"));
+            parts.push(schemas.map(s => `export type { ${this.formatSchemaName(s.name)} };`).join("\n"));
             return join(parts);
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "true-pg",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",
@@ -22,7 +22,8 @@
 	},
 	"devDependencies": {
 		"@types/bun": "latest",
-		"@types/pg": "^8.11.13"
+		"@types/pg": "^8.11.13",
+		"kysely-pglite": "^0.6.1"
 	},
 	"peerDependencies": {
 		"kysely": "^0.27",