true-pg 0.2.2 → 0.3.0

package/lib/zod/builtins.js

@@ -4,12 +4,11 @@ export const builtins = {
     "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()",
+    // result in potential data loss.
+    "pg_catalog.int8": "z.bigint()",
+    "pg_catalog.numeric": "z.bigint()",
     "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()",
@@ -19,11 +18,11 @@ export const builtins = {
     "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.date": "z.coerce.date()",
+    "pg_catalog.time": "z.coerce.date()",
+    "pg_catalog.timetz": "z.coerce.date()",
+    "pg_catalog.timestamp": "z.coerce.date()",
+    "pg_catalog.timestamptz": "z.coerce.date()",
     "pg_catalog.int4range": "z.string()",
     "pg_catalog.int8range": "z.string()",
     "pg_catalog.numrange": "z.string()",
@@ -32,4 +31,7 @@ export const builtins = {
     "pg_catalog.daterange": "z.string()",
     "pg_catalog.record": "z.record(z.string(), z.unknown())",
     "pg_catalog.void": "z.void()",
+    "pg_catalog.bytea": "z.string()",
+    "pg_catalog.vector": "z.number().array()",
+    "pg_catalog.tsvector": "z.string().array()",
 };

package/lib/zod/index.js

@@ -1,10 +1,7 @@
+import { FunctionReturnTypeKind, } from "../extractor/index.js";
 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;
-};
+import { join, quote, quoteI } from "../util.js";
 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
@@ -37,7 +34,7 @@ export const Zod = createGenerator(opts => {
         if (col.generated === "ALWAYS")
             return "";
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
-        out += col.name;
+        out += quoteI(col.name);
         let type = generator.formatType(col.type);
         add(imports, col.type);
         if (col.type.dimensions > 0)
@@ -48,7 +45,7 @@ export const Zod = createGenerator(opts => {
         return `\t${out},\n`;
     };
     const composite_attribute = (imports, attr) => {
-        let out = attr.name;
+        let out = quoteI(attr.name);
         out += `: ${generator.formatType(attr.type)}`;
         add(imports, attr.type);
         if (attr.type.dimensions > 0)
@@ -65,12 +62,15 @@ export const Zod = createGenerator(opts => {
             return to_snake_case(type.name);
         },
         formatType(type) {
-            if (type.schema === "pg_catalog") {
+            if (type.kind === FunctionReturnTypeKind.ExistingTable) {
+                return to_snake_case(type.name);
+            }
+            else 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()".`);
+                opts?.warnings?.push(`(zod) Unknown builtin type: ${name}. Pass customBuiltinMap to map this type. Defaulting to "z.unknown()".`);
                 return "z.unknown()";
             }
             return to_snake_case(type.name);
@@ -86,6 +86,28 @@ export const Zod = createGenerator(opts => {
             out += "});";
             return out;
         },
+        view(imports, view) {
+            let out = "";
+            if (view.comment)
+                out += `/** ${view.comment} */\n`;
+            zod(imports, "z");
+            out += `export const ${this.formatSchemaType(view)} = z.object({\n`;
+            for (const col of view.columns)
+                out += column(imports, col);
+            out += "});";
+            return out;
+        },
+        materializedView(imports, materializedView) {
+            let out = "";
+            if (materializedView.comment)
+                out += `/** ${materializedView.comment} */\n`;
+            zod(imports, "z");
+            out += `export const ${this.formatSchemaType(materializedView)} = z.object({\n`;
+            for (const col of materializedView.columns)
+                out += column(imports, col);
+            out += "});";
+            return out;
+        },
         enum(imports, en) {
             let out = "";
             if (en.comment)
@@ -106,6 +128,18 @@ export const Zod = createGenerator(opts => {
             out += "\n});";
             return out;
         },
+        domain(imports, type) {
+            let out = "";
+            out += `export const ${this.formatSchemaType(type)} = ${this.formatType(type.canonical.domain_base_type)};`;
+            zod(imports, "z");
+            return out;
+        },
+        range(imports, type) {
+            let out = "";
+            out += `export const ${this.formatSchemaType(type)} = z.string();`;
+            zod(imports, "z");
+            return out;
+        },
         function(imports, type) {
             let out = "export const ";
             out += this.formatSchemaType(type);
@@ -142,17 +176,25 @@ export const Zod = createGenerator(opts => {
             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`;
+            if (type.returnType.kind === FunctionReturnTypeKind.InlineTable) {
+                if (type.returnType.columns.length === 0)
+                    out += "z.void()/* RETURNS TABLE with no columns */";
+                else {
+                    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})";
                 }
-                out += "\t})";
+            }
+            else if (type.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
+                out += this.formatType(type.returnType);
+                add(imports, type.returnType);
             }
             else {
                 out += this.formatType(type.returnType.type);
@@ -164,6 +206,7 @@ export const Zod = createGenerator(opts => {
             if (type.returnType.isSet)
                 out += ".array()";
             out += ",\n};";
+            zod(imports, "z");
             return out;
         },
         schemaKindIndex(schema, kind, main_generator) {
@@ -180,10 +223,11 @@ export const Zod = createGenerator(opts => {
                 .join("\n");
         },
         schemaIndex(schema, main_generator) {
-            let out = allowed_kind_names.map(kind => `import * as zod_${kind} from "./${kind}/index.ts";`).join("\n");
+            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");
             out += "\n\n";
             out += `export const ${this.formatSchema(schema.name)} = {\n`;
-            for (const kind of allowed_kind_names) {
+            for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
                     continue;
@@ -196,9 +240,7 @@ export const Zod = createGenerator(opts => {
                     .filter(x => x !== undefined);
                 out += formatted
                     .map(t => {
-                    let name = t.name;
-                    if (isIdentifierInvalid(name))
-                        name = `"${name}"`;
+                    let name = quoteI(t.name);
                     return `\t\t${name}: zod_${t.kind}s.${t.formatted},`;
                 })
                     .join("\n");
@@ -209,44 +251,49 @@ export const Zod = createGenerator(opts => {
         },
         fullIndex(schemas, main_generator) {
             const generator = main_generator ?? this;
-            let out = "";
-            out += schemas
+            const parts = [];
+            parts.push(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;
+                .join("\n"));
+            {
+                let validator = `export const Validators = {\n`;
+                validator += 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 isDefault = defaultSchema === schema.name;
+                            let qualified = "";
+                            if (!isDefault)
+                                qualified = schema.name + "." + t.name;
+                            else
+                                qualified = t.name;
+                            qualified = quoteI(qualified);
+                            return `\t${qualified}: ${this.formatSchema(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}],`;
+                        }), "\n");
+                        return out;
+                    }));
+                    return `\t/* -- ${schema.name} --*/\n\n` + schema_validators || "\t-- no validators\n\n";
                 }));
-                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;
+                validator += "\n};";
+                parts.push(validator);
+            }
+            parts.push(schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n"));
+            return join(parts);
         },
     };
     return generator;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "true-pg",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",
@@ -17,7 +17,7 @@
 	},
 	"scripts": {
 		"check": "tsc --noEmit",
-		"build": "tsc",
+		"build": "rm -rf lib && tsc",
 		"prepare": "bun run build"
 	},
 	"devDependencies": {
@@ -30,7 +30,6 @@
 	},
 	"dependencies": {
 		"cosmiconfig": "^9.0.0",
-		"mri": "^1.2.0",
-		"pg-extract": "^0.0.3"
+		"mri": "^1.2.0"
 	}
 }