true-pg 0.6.0 → 0.8.0

package/lib/kysely/index.js

@@ -31,6 +31,8 @@ export const Kysely = createGenerator(opts => {
             qualified = `Generated<${qualified}>`;
             ky(ctx, "Generated");
         }
+        // TODO: Use ColumnType for appropriate cases:
+        // composite, jsonb, json, date types, etc
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(col.name);
         out += `: ${qualified}`;

package/lib/types.d.ts

@@ -1,6 +1,6 @@
 import { Canonical, type TableDetails, type ViewDetails, type MaterializedViewDetails, type EnumDetails, type CompositeTypeDetails, type DomainDetails, type RangeDetails, type FunctionDetails, type SchemaType, type Schema, type FunctionReturnType } from "./extractor/index.ts";
 import type { ImportList } from "./imports.ts";
-export declare const allowed_kind_names: ("function" | "enum" | "domain" | "range" | "table" | "view" | "materializedView" | "composite")[];
+export declare const allowed_kind_names: ("function" | "composite" | "domain" | "enum" | "range" | "table" | "view" | "materializedView")[];
 export type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
     name: string;

package/lib/util.d.ts

@@ -1,3 +1,4 @@
+export declare const unreachable: (value: never) => never;
 export declare const eq: <T>(a: T, b: T) => boolean;
 export declare const toPascalCase: (str: string) => string;
 export declare const to_snake_case: (str: string) => string;
@@ -13,4 +14,7 @@ export type Simplify<T> = {
 export declare const parens: (str: string, type?: string) => string;
 export declare const quote: (str: string, using?: string) => string;
 export declare const quoteI: (str: string, using?: string) => string;
+export declare const removeNulls: <T>(o: T) => T;
+export declare const pos: (num: number) => number | undefined;
+export declare const minifyQuery: (query: string) => string;
 export {};

package/lib/util.js

@@ -1,3 +1,6 @@
+export const unreachable = (value) => {
+    throw new Error(`Fatal: Reached unreachable code: ${value}`);
+};
 export const eq = (a, b) => {
     if (a === b)
         return true;
@@ -128,3 +131,18 @@ const isIdentifierInvalid = (str) => {
 export const parens = (str, type = "()") => `${type[0]}${str}${type[1]}`;
 export const quote = (str, using = '"') => `${using}${str.replaceAll(using, "\\" + using)}${using}`;
 export const quoteI = (str, using = '"') => (isIdentifierInvalid(str) ? quote(str, using) : str);
+export const removeNulls = (o) => {
+    for (const key in o)
+        if (o[key] == null)
+            delete o[key];
+    return o;
+};
+export const pos = (num) => (num < 0 ? undefined : num);
+export const minifyQuery = (query) => {
+    return query
+        .split("\n")
+        .map(line => line.slice(0, pos(line.indexOf("--"))))
+        .join("\n")
+        .replaceAll(/\s+/g, " ")
+        .trim();
+};

package/lib/zod/index.js

@@ -22,16 +22,12 @@ export const Zod = createGenerator(opts => {
         out += quoteI(col.name);
         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 = (ctx, attr) => {
         let out = quoteI(attr.name);
         out += `: ${generator.formatType(ctx, attr.type, { nullable: attr.isNullable })}`;
-        if (attr.isNullable)
-            out += ".optional()";
         return out;
     };
     const generator = {
@@ -80,7 +76,7 @@ export const Zod = createGenerator(opts => {
             if ("dimensions" in type)
                 base += ".array()".repeat(type.dimensions);
             if (attr?.nullable)
-                base += ".nullable()";
+                base += ".optional()";
             return base;
         },
         table(ctx, table) {
@@ -163,8 +159,6 @@ export const Zod = createGenerator(opts => {
                 for (const param of inputParams) {
                     // TODO: update imports for non-primitive types based on typeInfo.kind
                     out += "\t\t" + this.formatType(ctx, param.type, { nullable: param.hasDefault });
-                    if (param.hasDefault)
-                        out += ".optional()";
                     out += `, // ${param.name}\n`;
                 }
                 out += "\t])";
@@ -249,9 +243,7 @@ export const Zod = createGenerator(opts => {
         fullIndex(ctx, schemas, main_generator) {
             const generator = main_generator ?? this;
             const parts = [];
-            parts.push(schemas
-                .map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
-                .join("\n"));
+            parts.push(schemas.map(s => `import { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`).join("\n"));
             {
                 let validator = `export const Validators = {\n`;
                 validator += join(schemas.map(schema => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "true-pg",
-	"version": "0.6.0",
+	"version": "0.8.0",
 	"type": "module",
 	"module": "lib/index.js",
 	"main": "lib/index.js",

package/lib/extractor/canonicalise.js

@@ -1,245 +0,0 @@
-import { DbAdapter } from "./adapter.js";
-const removeNulls = (o) => {
-    for (const key in o)
-        if (o[key] == null)
-            delete o[key];
-    return o;
-};
-export var Canonical;
-(function (Canonical) {
-    let Kind;
-    (function (Kind) {
-        Kind["Base"] = "base";
-        Kind["Composite"] = "composite";
-        Kind["Domain"] = "domain";
-        Kind["Enum"] = "enum";
-        Kind["Range"] = "range";
-        Kind["Pseudo"] = "pseudo";
-        Kind["Unknown"] = "unknown";
-    })(Kind = Canonical.Kind || (Canonical.Kind = {}));
-})(Canonical || (Canonical = {}));
-export const canonicalise = async (db, types) => {
-    if (types.length === 0)
-        return [];
-    const placeholders = types.map((_, i) => `($${i * 2 + 1}, $${i * 2 + 2})`).join(", ");
-    const query = `
-	WITH RECURSIVE 
-	-- Parameters with sequence numbers to preserve order
-	input(type_name, seq) AS (
-		VALUES ${placeholders}
-	),
-	-- Parse array dimensions and base type
-	type_parts AS (
-		SELECT
-			type_name,
-			seq,
-			CASE 
-				WHEN type_name ~ '\\(.*\\)' THEN regexp_replace(type_name, '\\(.*\\)', '')
-				ELSE type_name
-			END AS clean_type,
-			CASE 
-				WHEN type_name ~ '\\(.*\\)' THEN substring(type_name from '\\((.*\\?)\\)')
-				ELSE NULL
-			END AS modifiers
-		FROM input
-	),
-	array_dimensions AS (
-		SELECT
-			type_name,
-			seq,
-			modifiers,
-			CASE 
-				WHEN clean_type ~ '.*\\[\\].*' THEN 
-					(length(clean_type) - length(regexp_replace(clean_type, '\\[\\]', '', 'g'))) / 2
-				ELSE 0
-			END AS dimensions,
-			regexp_replace(clean_type, '\\[\\]', '', 'g') AS base_type_name
-		FROM type_parts
-	),
-	-- Get base type information
-	base_type_info AS (
-		SELECT
-			a.type_name,
-			a.seq,
-			a.modifiers,
-			a.dimensions,
-			t.oid AS type_oid,
-			t.typname AS internal_name,
-			n.nspname AS schema_name,
-			t.typtype AS type_kind_code,
-			t.typbasetype,
-			CASE t.typtype
-				WHEN 'b' THEN 'base'
-				WHEN 'c' THEN 'composite'
-				WHEN 'd' THEN 'domain'
-				WHEN 'e' THEN 'enum'
-				WHEN 'p' THEN 'pseudo'
-				WHEN 'r' THEN 'range'
-				ELSE 'unknown'
-			END AS type_kind
-		FROM array_dimensions a
-		JOIN pg_type t ON t.oid = a.base_type_name::regtype
-		JOIN pg_namespace n ON t.typnamespace = n.oid
-	),
-	-- Handle enum values for enum types
-	enum_values AS (
-		SELECT
-			b.type_name,
-			jsonb_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
-		FROM base_type_info b
-		JOIN pg_enum e ON b.type_oid = e.enumtypid
-		WHERE b.type_kind_code = 'e'
-		GROUP BY b.type_name
-	),
-	-- Enhanced composite attributes with additional metadata
-	composite_attributes AS (
-		SELECT
-			b.type_name,
-			jsonb_agg(
-				jsonb_build_object(
-					'name', a.attname,
-					'index', a.attnum,
-					'type_oid', a.atttypid,
-					'type_name', format_type(a.atttypid, null),
-					'comment', col_description(c.oid, a.attnum::int),
-					'defaultValue', pg_get_expr(d.adbin, d.adrelid),
-					'isNullable', NOT a.attnotnull,
-					'isIdentity', a.attidentity IS NOT NULL AND a.attidentity != '',
-					'generated', CASE 
-						WHEN a.attidentity = 'a' THEN 'ALWAYS'
-						WHEN a.attidentity = 'd' THEN 'BY DEFAULT'
-						WHEN a.attgenerated = 's' THEN 'ALWAYS'
-						ELSE 'NEVER'
-					END
-				)
-				ORDER BY a.attnum
-			) AS attributes
-		FROM base_type_info b
-		JOIN pg_type t ON t.oid = b.type_oid
-		JOIN pg_class c ON c.oid = t.typrelid
-		JOIN pg_attribute a ON a.attrelid = c.oid
-		LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum
-		WHERE b.type_kind_code = 'c' AND a.attnum > 0 AND NOT a.attisdropped
-		GROUP BY b.type_name
-	),
-	-- Recursive CTE to resolve domain base types
-	domain_types AS (
-		-- Base case: start with initial domain type
-		SELECT
-			b.type_name AS original_type,
-			b.type_oid AS domain_oid,
-			b.typbasetype AS base_type_oid,
-			1 AS level
-		FROM base_type_info b
-		WHERE b.type_kind_code = 'd'
-		
-		UNION ALL
-		
-		-- Recursive case: follow chain of domains
-		SELECT
-			d.original_type,
-			t.oid AS domain_oid,
-			t.typbasetype AS base_type_oid,
-			d.level + 1 AS level
-		FROM domain_types d
-		JOIN pg_type t ON d.base_type_oid = t.oid
-		WHERE t.typtype = 'd'-- Only continue if the base is also a domain
-	),
-	-- Get ultimate base type for domains
-	domain_base_types AS (
-		SELECT DISTINCT ON (original_type)
-			d.original_type,
-			format('%s.%s', n.nspname, t.typname) AS base_canonical_name
-		FROM (
-			-- Get the max level for each original type
-			SELECT original_type, MAX(level) AS max_level
-			FROM domain_types
-			GROUP BY original_type
-		) m
-		JOIN domain_types d ON d.original_type = m.original_type AND d.level = m.max_level
-		JOIN pg_type t ON d.base_type_oid = t.oid
-		JOIN pg_namespace n ON t.typnamespace = n.oid
-	),
-	-- Range type subtype information
-	range_subtypes AS (
-		SELECT
-			b.type_name,
-			format('%s.%s', n.nspname, t.typname) AS subtype_canonical_name
-		FROM base_type_info b
-		JOIN pg_range r ON b.type_oid = r.rngtypid
-		JOIN pg_type t ON t.oid = r.rngsubtype  -- Join to get subtype details
-		JOIN pg_namespace n ON n.oid = t.typnamespace -- Join to get subtype schema
-		WHERE b.type_kind_code = 'r'
-	)
-	-- Final result as JSON
-	SELECT jsonb_build_object(
-		'canonical_name', b.schema_name || '.' || b.internal_name,
-		'schema', b.schema_name,
-		'name', b.internal_name,
-		'kind', b.type_kind,
-		'dimensions', b.dimensions,
-		'original_type', b.type_name,
-		'modifiers', b.modifiers,
-		'enum_values', e.values,
-		'attributes', c.attributes,
-		'domain_base_type', CASE
-			WHEN b.type_kind_code = 'd' THEN d.base_canonical_name
-			ELSE NULL
-		END,
-		'range_subtype', CASE
-			WHEN b.type_kind_code = 'r' THEN r.subtype_canonical_name
-			ELSE NULL
-		END
-	) AS type_info,
-	b.seq
-	FROM base_type_info b
-	LEFT JOIN enum_values e ON b.type_name = e.type_name
-	LEFT JOIN composite_attributes c ON b.type_name = c.type_name
-	LEFT JOIN domain_base_types d ON b.type_name = d.original_type
-	LEFT JOIN range_subtypes r ON b.type_name = r.type_name
-	ORDER BY b.seq::integer;
-	`;
-    const resolved = await db.query(query, types.flatMap((type, index) => [type, index]));
-    return Promise.all(resolved
-        .map(each => each.type_info)
-        .map(async (each) => {
-        if (each.kind === Canonical.Kind.Composite) {
-            const types = each.attributes.map(each => each.type_name);
-            const canonical = await canonicalise(db, types);
-            const attributes = await Promise.all(each.attributes.map(async (each, index) => {
-                return {
-                    name: each.name,
-                    index: each.index,
-                    type: canonical[index],
-                    comment: each.comment,
-                    defaultValue: each.defaultValue,
-                    isNullable: each.isNullable,
-                    isIdentity: each.isIdentity,
-                    generated: each.generated,
-                };
-            }));
-            return removeNulls({
-                ...each,
-                kind: Canonical.Kind.Composite,
-                attributes,
-            });
-        }
-        if (each.kind === Canonical.Kind.Domain) {
-            const canonical = await canonicalise(db, [each.domain_base_type]);
-            return removeNulls({
-                ...each,
-                kind: Canonical.Kind.Domain,
-                domain_base_type: canonical[0],
-            });
-        }
-        if (each.kind === Canonical.Kind.Range) {
-            const canonical = await canonicalise(db, [each.range_subtype]);
-            return removeNulls({
-                ...each,
-                kind: Canonical.Kind.Range,
-                range_subtype: canonical[0],
-            });
-        }
-        return removeNulls(each);
-    }));
-};