pg2zod 2.0.0

package/dist/src-18pV45Fu.js

@@ -0,0 +1,835 @@
+import pg from "pg";
+
+//#region src/introspect.ts
+const { Pool } = pg;
+/**
+* Introspect a PostgreSQL database and return complete metadata
+*/
+async function introspectDatabase(config, options = {}) {
+	const pool = new Pool(config);
+	try {
+		const schemas = options.schemas ?? ["public"];
+		const [tables, enums, compositeTypes, rangeTypes, domains] = await Promise.all([
+			introspectTables(pool, schemas, options),
+			introspectEnums(pool, schemas),
+			introspectCompositeTypes(pool, schemas),
+			introspectRangeTypes(pool, schemas),
+			introspectDomains(pool, schemas)
+		]);
+		return {
+			tables,
+			enums,
+			compositeTypes,
+			rangeTypes,
+			domains
+		};
+	} finally {
+		await pool.end();
+	}
+}
+/**
+* Introspect tables and their columns
+*/
+async function introspectTables(pool, schemas, options) {
+	const schemaFilter = schemas.map((_, i) => `$${i + 1}`).join(", ");
+	const columnsQuery = `
+    SELECT 
+      c.table_schema,
+      c.table_name,
+      c.column_name,
+      c.data_type,
+      c.is_nullable,
+      c.column_default,
+      c.character_maximum_length,
+      c.numeric_precision,
+      c.numeric_scale,
+      c.datetime_precision,
+      c.udt_name,
+      c.domain_name,
+      COALESCE(
+        (SELECT array_ndims(ARRAY[]::text[]) FROM information_schema.element_types e 
+         WHERE e.object_schema = c.table_schema 
+         AND e.object_name = c.table_name 
+         AND e.object_type = 'TABLE'
+         AND e.collection_type_identifier = c.dtd_identifier
+        ), 0
+      ) as array_dimensions
+    FROM information_schema.columns c
+    WHERE c.table_schema IN (${schemaFilter})
+    ORDER BY c.table_schema, c.table_name, c.ordinal_position
+  `;
+	const columnsResult = await pool.query(columnsQuery, schemas);
+	const constraintsQuery = `
+    SELECT 
+      tc.table_schema,
+      tc.table_name,
+      tc.constraint_name,
+      cc.check_clause,
+      ccu.column_name
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.check_constraints cc 
+      ON tc.constraint_name = cc.constraint_name 
+      AND tc.constraint_schema = cc.constraint_schema
+    LEFT JOIN information_schema.constraint_column_usage ccu
+      ON tc.constraint_name = ccu.constraint_name
+      AND tc.constraint_schema = ccu.constraint_schema
+    WHERE tc.constraint_type = 'CHECK'
+      AND tc.table_schema IN (${schemaFilter})
+  `;
+	const constraintsResult = await pool.query(constraintsQuery, schemas);
+	const primaryKeysQuery = `
+    SELECT 
+      tc.table_schema,
+      tc.table_name,
+      kcu.column_name
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+    WHERE tc.constraint_type = 'PRIMARY KEY'
+      AND tc.table_schema IN (${schemaFilter})
+    ORDER BY kcu.ordinal_position
+  `;
+	const primaryKeysResult = await pool.query(primaryKeysQuery, schemas);
+	const uniqueConstraintsQuery = `
+    SELECT 
+      tc.table_schema,
+      tc.table_name,
+      tc.constraint_name,
+      array_agg(kcu.column_name ORDER BY kcu.ordinal_position) as columns
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+    WHERE tc.constraint_type = 'UNIQUE'
+      AND tc.table_schema IN (${schemaFilter})
+    GROUP BY tc.table_schema, tc.table_name, tc.constraint_name
+  `;
+	const uniqueConstraintsResult = await pool.query(uniqueConstraintsQuery, schemas);
+	const tableMap = /* @__PURE__ */ new Map();
+	for (const row of columnsResult.rows) {
+		const tableKey = `${row.table_schema}.${row.table_name}`;
+		if (!tableMap.has(tableKey)) tableMap.set(tableKey, {
+			tableName: row.table_name,
+			schemaName: row.table_schema,
+			columns: [],
+			checkConstraints: [],
+			primaryKeys: [],
+			uniqueConstraints: []
+		});
+		const table = tableMap.get(tableKey);
+		const isArray = row.data_type === "ARRAY";
+		table.columns.push({
+			columnName: row.column_name,
+			dataType: row.data_type,
+			isNullable: row.is_nullable === "YES",
+			columnDefault: row.column_default,
+			characterMaximumLength: row.character_maximum_length,
+			numericPrecision: row.numeric_precision,
+			numericScale: row.numeric_scale,
+			datetimePrecision: row.datetime_precision,
+			udtName: row.udt_name,
+			domainName: row.domain_name,
+			arrayDimensions: row.array_dimensions || 0,
+			isArray
+		});
+	}
+	for (const row of constraintsResult.rows) {
+		const tableKey = `${row.table_schema}.${row.table_name}`;
+		const table = tableMap.get(tableKey);
+		if (table) table.checkConstraints.push({
+			constraintName: row.constraint_name,
+			checkClause: row.check_clause,
+			columnName: row.column_name
+		});
+	}
+	for (const row of primaryKeysResult.rows) {
+		const tableKey = `${row.table_schema}.${row.table_name}`;
+		const table = tableMap.get(tableKey);
+		if (table) table.primaryKeys.push(row.column_name);
+	}
+	for (const row of uniqueConstraintsResult.rows) {
+		const tableKey = `${row.table_schema}.${row.table_name}`;
+		const table = tableMap.get(tableKey);
+		if (table) table.uniqueConstraints.push({
+			constraintName: row.constraint_name,
+			columns: row.columns
+		});
+	}
+	let tables = Array.from(tableMap.values());
+	if (options.tables) tables = tables.filter((t) => options.tables.includes(t.tableName));
+	if (options.excludeTables) tables = tables.filter((t) => !options.excludeTables.includes(t.tableName));
+	return tables;
+}
+/**
+* Introspect enum types
+*/
+async function introspectEnums(pool, schemas) {
+	const query = `
+    SELECT 
+      t.typname as enum_name,
+      n.nspname as schema_name,
+      array_agg(e.enumlabel ORDER BY e.enumsortorder) as enum_values
+    FROM pg_type t
+    JOIN pg_enum e ON t.oid = e.enumtypid
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE n.nspname IN (${schemas.map((_, i) => `$${i + 1}`).join(", ")})
+    GROUP BY t.typname, n.nspname
+    ORDER BY t.typname
+  `;
+	return (await pool.query(query, schemas)).rows.map((row) => {
+		let enumValues;
+		if (Array.isArray(row.enum_values)) enumValues = row.enum_values;
+		else if (typeof row.enum_values === "string") if (row.enum_values.startsWith("{") && row.enum_values.endsWith("}")) enumValues = row.enum_values.slice(1, -1).split(",").map((v) => v.trim());
+		else enumValues = [row.enum_values];
+		else enumValues = [row.enum_values];
+		return {
+			enumName: row.enum_name,
+			enumValues,
+			schemaName: row.schema_name
+		};
+	});
+}
+/**
+* Introspect composite types
+*/
+async function introspectCompositeTypes(pool, schemas) {
+	const query = `
+    SELECT 
+      t.typname as type_name,
+      n.nspname as schema_name,
+      a.attname as attribute_name,
+      a.attnum as attribute_number,
+      format_type(a.atttypid, a.atttypmod) as data_type
+    FROM pg_type t
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    JOIN pg_class c ON t.typrelid = c.oid
+    JOIN pg_attribute a ON c.oid = a.attrelid
+    WHERE t.typtype = 'c'
+      AND n.nspname IN (${schemas.map((_, i) => `$${i + 1}`).join(", ")})
+      AND a.attnum > 0
+      AND NOT a.attisdropped
+    ORDER BY t.typname, a.attnum
+  `;
+	const result = await pool.query(query, schemas);
+	const typeMap = /* @__PURE__ */ new Map();
+	for (const row of result.rows) {
+		const typeKey = `${row.schema_name}.${row.type_name}`;
+		if (!typeMap.has(typeKey)) typeMap.set(typeKey, {
+			typeName: row.type_name,
+			schemaName: row.schema_name,
+			attributes: []
+		});
+		typeMap.get(typeKey).attributes.push({
+			attributeName: row.attribute_name,
+			dataType: row.data_type,
+			attributeNumber: row.attribute_number
+		});
+	}
+	return Array.from(typeMap.values());
+}
+/**
+* Introspect range types
+*/
+async function introspectRangeTypes(pool, schemas) {
+	const query = `
+    SELECT 
+      t.typname as range_name,
+      n.nspname as schema_name,
+      format_type(r.rngsubtype, NULL) as subtype
+    FROM pg_type t
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    JOIN pg_range r ON t.oid = r.rngtypid
+    WHERE n.nspname IN (${schemas.map((_, i) => `$${i + 1}`).join(", ")})
+    ORDER BY t.typname
+  `;
+	return (await pool.query(query, schemas)).rows.map((row) => ({
+		rangeName: row.range_name,
+		subtype: row.subtype,
+		schemaName: row.schema_name
+	}));
+}
+/**
+* Introspect domain types
+*/
+async function introspectDomains(pool, schemas) {
+	const schemaFilter = schemas.map((_, i) => `$${i + 1}`).join(", ");
+	const domainsQuery = `
+    SELECT 
+      t.typname as domain_name,
+      n.nspname as schema_name,
+      format_type(t.typbasetype, t.typtypmod) as data_type,
+      t.typnotnull as is_not_null,
+      t.typdefault as domain_default,
+      information_schema._pg_char_max_length(t.typbasetype, t.typtypmod) as character_maximum_length,
+      information_schema._pg_numeric_precision(t.typbasetype, t.typtypmod) as numeric_precision,
+      information_schema._pg_numeric_scale(t.typbasetype, t.typtypmod) as numeric_scale
+    FROM pg_type t
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE t.typtype = 'd'
+      AND n.nspname IN (${schemaFilter})
+    ORDER BY t.typname
+  `;
+	const domainsResult = await pool.query(domainsQuery, schemas);
+	const constraintsQuery = `
+    SELECT 
+      t.typname as domain_name,
+      n.nspname as schema_name,
+      c.conname as constraint_name,
+      pg_get_constraintdef(c.oid) as check_clause
+    FROM pg_constraint c
+    JOIN pg_type t ON c.contypid = t.oid
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE c.contype = 'c'
+      AND n.nspname IN (${schemaFilter})
+  `;
+	const constraintsResult = await pool.query(constraintsQuery, schemas);
+	const domains = domainsResult.rows.map((row) => ({
+		domainName: row.domain_name,
+		dataType: row.data_type,
+		schemaName: row.schema_name,
+		characterMaximumLength: row.character_maximum_length,
+		numericPrecision: row.numeric_precision,
+		numericScale: row.numeric_scale,
+		isNullable: !row.is_not_null,
+		domainDefault: row.domain_default,
+		checkConstraints: []
+	}));
+	for (const row of constraintsResult.rows) {
+		const domain = domains.find((d) => d.domainName === row.domain_name && d.schemaName === row.schema_name);
+		if (domain) domain.checkConstraints.push({
+			constraintName: row.constraint_name,
+			checkClause: row.check_clause,
+			columnName: null
+		});
+	}
+	return domains;
+}
+
+//#endregion
+//#region src/type-mapper.ts
+/**
+* Map PostgreSQL column to Zod schema string with strict validation
+*/
+function mapColumnToZod(column, metadata, options, warnings) {
+	if (column.domainName) {
+		const domain = metadata.domains.find((d) => d.domainName === column.domainName);
+		if (domain) {
+			let schema = `${toPascalCase(domain.schemaName)}${toPascalCase(domain.domainName)}Schema`;
+			return column.isNullable ? `${schema}.nullable()` : schema;
+		}
+	}
+	if (column.isArray) {
+		let arraySchema = `z.array(${mapBaseTypeToZod(column, metadata, options, warnings)})`;
+		if (column.arrayDimensions > 1) for (let i = 1; i < column.arrayDimensions; i++) arraySchema = `z.array(${arraySchema})`;
+		return column.isNullable ? `${arraySchema}.nullable()` : arraySchema;
+	}
+	const baseSchema = mapBaseTypeToZod(column, metadata, options, warnings);
+	return column.isNullable ? `${baseSchema}.nullable()` : baseSchema;
+}
+/**
+* Map base PostgreSQL type to Zod
+*/
+function mapBaseTypeToZod(column, metadata, options, warnings) {
+	let udtName = column.udtName;
+	const dataType = column.dataType.toLowerCase();
+	if (column.isArray && udtName.startsWith("_")) udtName = udtName.substring(1);
+	if (options.customTypeMappings?.[udtName]) return options.customTypeMappings[udtName];
+	const enumType = metadata.enums.find((e) => e.enumName === udtName);
+	if (enumType) return `${toPascalCase(enumType.schemaName)}${toPascalCase(enumType.enumName)}Schema`;
+	const compositeType = metadata.compositeTypes.find((t) => t.typeName === udtName);
+	if (compositeType) return `${toPascalCase(compositeType.schemaName)}${toPascalCase(compositeType.typeName)}CompositeSchema`;
+	const rangeType = metadata.rangeTypes.find((r) => r.rangeName === udtName);
+	if (rangeType) return `${toPascalCase(rangeType.schemaName)}${toPascalCase(rangeType.rangeName)}Schema`;
+	switch (dataType === "array" ? udtName : dataType) {
+		case "smallint":
+		case "integer":
+		case "int":
+		case "int2":
+		case "int4": return "z.number().int()";
+		case "bigint":
+		case "int8": return "z.bigint()";
+		case "decimal":
+		case "numeric":
+			if (column.numericPrecision !== null && column.numericScale !== null) return `z.number() /* precision: ${column.numericPrecision}, scale: ${column.numericScale} */`;
+			return "z.number()";
+		case "real":
+		case "float4": return "z.number()";
+		case "double precision":
+		case "float8": return "z.number()";
+		case "money": return "z.string().regex(/^\\$?[0-9,]+(\\.\\d{2})?$/)";
+		case "character varying":
+		case "varchar":
+			if (column.characterMaximumLength) return `z.string().max(${column.characterMaximumLength})`;
+			return "z.string()";
+		case "character":
+		case "char":
+			if (column.characterMaximumLength) return `z.string().length(${column.characterMaximumLength})`;
+			return "z.string()";
+		case "text": return "z.string()";
+		case "citext": return "z.string()";
+		case "boolean":
+		case "bool": return "z.boolean()";
+		case "timestamp":
+		case "timestamp without time zone": return "z.date()";
+		case "timestamp with time zone":
+		case "timestamptz": return "z.date()";
+		case "date": return "z.date()";
+		case "time":
+		case "time without time zone": return "z.iso.time()";
+		case "time with time zone":
+		case "timetz": return "z.string().regex(/^\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?[+-]\\d{2}:\\d{2}$/)";
+		case "interval": return "z.iso.duration()";
+		case "uuid": return "z.uuid()";
+		case "json": return "z.record(z.string(), z.unknown())";
+		case "jsonb": return "z.record(z.string(), z.unknown())";
+		case "inet": return "z.union([z.ipv4(), z.ipv6()])";
+		case "cidr": return "z.union([z.cidrv4(), z.cidrv6()])";
+		case "macaddr": return "z.mac()";
+		case "macaddr8": return "z.string().regex(/^([0-9A-Fa-f]{2}[:-]){7}([0-9A-Fa-f]{2})$/)";
+		case "bit":
+			if (column.characterMaximumLength) return `z.string().regex(/^[01]{${column.characterMaximumLength}}$/)`;
+			return "z.string().regex(/^[01]+$/)";
+		case "bit varying":
+		case "varbit":
+			if (column.characterMaximumLength) return `z.string().regex(/^[01]{0,${column.characterMaximumLength}}$/)`;
+			return "z.string().regex(/^[01]*$/)";
+		case "point": return "z.tuple([z.number(), z.number()])";
+		case "line": return "z.object({ a: z.number(), b: z.number(), c: z.number() })";
+		case "lseg": return "z.tuple([z.tuple([z.number(), z.number()]), z.tuple([z.number(), z.number()])])";
+		case "box": return "z.tuple([z.tuple([z.number(), z.number()]), z.tuple([z.number(), z.number()])])";
+		case "path": return "z.array(z.tuple([z.number(), z.number()]))";
+		case "polygon": return "z.array(z.tuple([z.number(), z.number()]))";
+		case "circle": return "z.object({ center: z.tuple([z.number(), z.number()]), radius: z.number() })";
+		case "tsvector": return "z.string() /* tsvector */";
+		case "tsquery": return "z.string() /* tsquery */";
+		case "xml": return "z.string() /* XML */";
+		case "bytea": return "z.instanceof(Buffer)";
+		case "oid": return "z.number().int().positive()";
+		case "regproc":
+		case "regprocedure":
+		case "regoper":
+		case "regoperator":
+		case "regclass":
+		case "regtype":
+		case "regrole":
+		case "regnamespace":
+		case "regconfig":
+		case "regdictionary": return "z.string() /* PostgreSQL OID reference */";
+		case "pg_lsn": return "z.string().regex(/^[0-9A-F]+\\/[0-9A-F]+$/)";
+		default:
+			const warning = `Unknown type: ${dataType} (udt: ${udtName}) in column ${column.columnName}`;
+			warnings.push(warning);
+			if (options.strictMode) throw new Error(warning);
+			return "z.unknown() /* unmapped type */";
+	}
+}
+/**
+* Apply check constraints as Zod refinements
+*/
+function applyCheckConstraints(columnName, baseSchema, constraints) {
+	let schema = baseSchema;
+	for (const constraint of constraints) {
+		const checkClause = constraint.checkClause.toLowerCase();
+		const geMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*>=\\s*([\\d.]+)`));
+		if (geMatch) {
+			const value = geMatch[1];
+			if (schema.includes("z.number()")) schema = schema.replace("z.number()", `z.number().min(${value})`);
+			else if (schema.includes("z.bigint()")) schema = schema.replace("z.bigint()", `z.bigint().min(${value}n)`);
+			continue;
+		}
+		const gtMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*>\\s*([\\d.]+)`));
+		if (gtMatch) {
+			const value = parseFloat(gtMatch[1]);
+			if (schema.includes("z.number()")) schema = schema.replace("z.number()", `z.number().min(${value + Number.EPSILON})`);
+			continue;
+		}
+		const leMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*<=\\s*([\\d.]+)`));
+		if (leMatch) {
+			const value = leMatch[1];
+			if (schema.includes("z.number()")) schema = schema.replace("z.number()", `z.number().max(${value})`);
+			else if (schema.includes("z.bigint()")) schema = schema.replace("z.bigint()", `z.bigint().max(${value}n)`);
+			continue;
+		}
+		const ltMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*<\\s*([\\d.]+)`));
+		if (ltMatch) {
+			const value = parseFloat(ltMatch[1]);
+			if (schema.includes("z.number()")) schema = schema.replace("z.number()", `z.number().max(${value - Number.EPSILON})`);
+			continue;
+		}
+		const betweenMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*between\\s*([\\d.]+)\\s*and\\s*([\\d.]+)`));
+		if (betweenMatch) {
+			const [, min, max] = betweenMatch;
+			if (schema.includes("z.number()")) schema = schema.replace("z.number()", `z.number().min(${min}).max(${max})`);
+			continue;
+		}
+		const inMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*in\\s*\\(([^)]+)\\)`));
+		if (inMatch) {
+			const values = inMatch[1].split(",").map((v) => v.trim().replace(/'/g, ""));
+			if (schema.includes("z.string()")) schema = `z.enum([${values.map((v) => `'${v}'`).join(", ")}])`;
+			continue;
+		}
+		const anyArrayMatch = checkClause.match(/* @__PURE__ */ new RegExp(`\\(?${columnName}\\s*=\\s*any\\s*\\(array\\[([^\\]]+)\\]`));
+		if (anyArrayMatch) {
+			const values = anyArrayMatch[1].split(",").map((v) => {
+				const match = v.trim().match(/'([^']+)'/);
+				return match ? match[1] : null;
+			}).filter((v) => v !== null);
+			if (values.length > 0 && schema.includes("z.string()")) {
+				schema = `z.enum([${values.map((v) => `'${v}'`).join(", ")}])`;
+				continue;
+			}
+		}
+		const regexMatch = checkClause.match(/* @__PURE__ */ new RegExp(`${columnName}\\s*~\\s*'([^']+)'`));
+		if (regexMatch) {
+			const pattern = regexMatch[1];
+			if (schema.includes("z.string()")) schema = schema.replace("z.string()", `z.string().regex(/${pattern}/)`);
+			continue;
+		}
+		const lengthMatch = checkClause.match(/* @__PURE__ */ new RegExp(`length\\(${columnName}\\)\\s*([><=]+)\\s*([\\d]+)`));
+		if (lengthMatch) {
+			const [, operator, value] = lengthMatch;
+			if (schema.includes("z.string()")) {
+				if (operator === ">=" || operator === ">") schema = schema.replace("z.string()", `z.string().min(${value})`);
+				else if (operator === "<=" || operator === "<") schema = schema.replace("z.string()", `z.string().max(${value})`);
+			}
+			continue;
+		}
+		schema += ` /* CHECK: ${constraint.checkClause} */`;
+	}
+	return schema;
+}
+/**
+* Convert snake_case to PascalCase
+*/
+function toPascalCase(str) {
+	return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+/**
+* Convert snake_case to camelCase
+*/
+function toCamelCase(str) {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+//#endregion
+//#region src/generator.ts
+/**
+* Generate Zod schemas from database metadata
+*/
+function generateSchemas(metadata, options = {}) {
+	const warnings = [];
+	const schemas = [];
+	const enums = metadata.enums.map((enumType) => ({
+		name: toPascalCase(enumType.schemaName) + toPascalCase(enumType.enumName),
+		code: generateEnumSchema(enumType.enumName, enumType.enumValues, options, enumType.schemaName)
+	}));
+	const ranges = metadata.rangeTypes.map((rangeType) => ({
+		name: toPascalCase(rangeType.schemaName) + toPascalCase(rangeType.rangeName),
+		code: generateRangeSchema(rangeType.rangeName, rangeType.subtype, metadata, options, warnings, rangeType.schemaName)
+	}));
+	const compositeTypes = options.includeCompositeTypes ? metadata.compositeTypes.map((compositeType) => ({
+		name: toPascalCase(compositeType.schemaName) + toPascalCase(compositeType.typeName) + "Composite",
+		code: generateCompositeTypeSchema(compositeType, metadata, options, warnings)
+	})) : [];
+	const domains = metadata.domains.map((domain) => ({
+		name: toPascalCase(domain.schemaName) + toPascalCase(domain.domainName),
+		code: generateDomainSchema(domain, metadata, options, warnings)
+	}));
+	for (const table of metadata.tables) {
+		const schema = generateTableSchema(table, metadata, options, warnings);
+		schemas.push(schema);
+	}
+	return {
+		schemas,
+		enums,
+		compositeTypes,
+		domains,
+		ranges,
+		warnings
+	};
+}
+/**
+* Generate enum schema
+*/
+function generateEnumSchema(enumName, values, options, schemaPrefix) {
+	const baseName = toPascalCase(enumName);
+	const fullName = schemaPrefix ? `${toPascalCase(schemaPrefix)}${baseName}` : baseName;
+	const schemaName = `${fullName}Schema`;
+	const typeName = fullName;
+	const valuesStr = values.map((v) => `'${v}'`).join(", ");
+	let code = "";
+	if (options.includeComments) code += `/** PostgreSQL enum: ${enumName} */\n`;
+	code += `export const ${schemaName} = z.enum([${valuesStr}]);\n`;
+	code += `export type ${typeName} = z.infer<typeof ${schemaName}>;\n`;
+	return code;
+}
+/**
+* Generate range type schema
+*/
+function generateRangeSchema(rangeName, subtype, _metadata, options, _warnings, schemaPrefix) {
+	const baseName = toPascalCase(rangeName);
+	const fullName = schemaPrefix ? `${toPascalCase(schemaPrefix)}${baseName}` : baseName;
+	const schemaName = `${fullName}Schema`;
+	const typeName = fullName;
+	const subtypeSchema = mapSubtypeToZod(subtype, _metadata);
+	let code = "";
+	if (options.includeComments) code += `/** PostgreSQL range type: ${rangeName}<${subtype}> */\n`;
+	code += `export const ${schemaName} = z.tuple([${subtypeSchema}.nullable(), ${subtypeSchema}.nullable()]);\n`;
+	code += `export type ${typeName} = z.infer<typeof ${schemaName}>;\n`;
+	return code;
+}
+/**
+* Map PostgreSQL subtype to Zod for range types
+*/
+function mapSubtypeToZod(subtype, _metadata) {
+	switch (subtype.toLowerCase()) {
+		case "integer":
+		case "int":
+		case "int4": return "z.number().int()";
+		case "bigint":
+		case "int8": return "z.bigint()";
+		case "numeric":
+		case "decimal": return "z.number()";
+		case "date": return "z.date()";
+		case "timestamp":
+		case "timestamp without time zone":
+		case "timestamp with time zone":
+		case "timestamptz": return "z.date()";
+		default: return "z.unknown()";
+	}
+}
+/**
+* Generate composite type schema
+*/
+function generateCompositeTypeSchema(compositeType, metadata, options, warnings) {
+	const baseName = toPascalCase(compositeType.typeName);
+	const fullName = `${toPascalCase(compositeType.schemaName)}${baseName}Composite`;
+	const schemaName = `${fullName}Schema`;
+	const typeName = fullName;
+	let code = "";
+	if (options.includeComments) code += `/** PostgreSQL composite type: ${compositeType.typeName} */\n`;
+	code += `export const ${schemaName} = z.object({\n`;
+	for (const attr of compositeType.attributes) {
+		const fieldName = options.useCamelCase ? toCamelCase(attr.attributeName) : attr.attributeName;
+		const zodType = mapColumnToZod({
+			columnName: attr.attributeName,
+			dataType: attr.dataType,
+			isNullable: true,
+			columnDefault: null,
+			characterMaximumLength: null,
+			numericPrecision: null,
+			numericScale: null,
+			datetimePrecision: null,
+			udtName: attr.dataType,
+			domainName: null,
+			arrayDimensions: 0,
+			isArray: false
+		}, metadata, options, warnings);
+		if (options.includeComments) code += `  /** ${attr.dataType} */\n`;
+		code += `  ${fieldName}: ${zodType},\n`;
+	}
+	code += `});\n`;
+	code += `export type ${typeName} = z.infer<typeof ${schemaName}>;\n`;
+	return code;
+}
+/**
+* Generate domain schema
+*/
+function generateDomainSchema(domain, metadata, options, warnings) {
+	const baseName = toPascalCase(domain.domainName);
+	const fullName = `${toPascalCase(domain.schemaName)}${baseName}`;
+	const schemaName = `${fullName}Schema`;
+	const typeName = fullName;
+	let zodType = mapColumnToZod({
+		columnName: domain.domainName,
+		dataType: domain.dataType,
+		isNullable: domain.isNullable,
+		columnDefault: domain.domainDefault,
+		characterMaximumLength: domain.characterMaximumLength,
+		numericPrecision: domain.numericPrecision,
+		numericScale: domain.numericScale,
+		datetimePrecision: null,
+		udtName: domain.dataType,
+		domainName: null,
+		arrayDimensions: 0,
+		isArray: false
+	}, metadata, options, warnings);
+	if (domain.checkConstraints.length > 0) zodType = applyCheckConstraints(domain.domainName, zodType, domain.checkConstraints);
+	let code = "";
+	if (options.includeComments) code += `/** PostgreSQL domain: ${domain.domainName} (base: ${domain.dataType}) */\n`;
+	code += `export const ${schemaName} = ${zodType};\n`;
+	code += `export type ${typeName} = z.infer<typeof ${schemaName}>;\n`;
+	return code;
+}
+/**
+* Generate table schema
+*/
+function generateTableSchema(table, metadata, options, warnings) {
+	const schemaName = `${toPascalCase(table.schemaName)}${toPascalCase(table.tableName)}`;
+	const readSchemaName = `${schemaName}Schema`;
+	const insertSchemaName = `${schemaName}InsertSchema`;
+	const updateSchemaName = `${schemaName}UpdateSchema`;
+	const typeName = schemaName;
+	const insertTypeName = `${schemaName}Insert`;
+	const updateTypeName = `${schemaName}Update`;
+	let readCode = "";
+	if (options.includeComments) readCode += `/** Table: ${table.schemaName}.${table.tableName} */\n`;
+	readCode += `export const ${readSchemaName} = z.object({\n`;
+	for (const column of table.columns) {
+		const fieldName = options.useCamelCase ? toCamelCase(column.columnName) : column.columnName;
+		let zodType = mapColumnToZod(column, metadata, options, warnings);
+		const columnConstraints = table.checkConstraints.filter((c) => c.columnName === column.columnName);
+		if (columnConstraints.length > 0) zodType = applyCheckConstraints(column.columnName, zodType, columnConstraints);
+		if (options.includeComments) {
+			const commentParts = [column.dataType];
+			if (column.columnDefault) commentParts.push(`default: ${column.columnDefault}`);
+			readCode += `  /** ${commentParts.join(", ")} */\n`;
+		}
+		readCode += `  ${fieldName}: ${zodType},\n`;
+	}
+	readCode += `});\n`;
+	readCode += `export type ${typeName} = z.infer<typeof ${readSchemaName}>;\n`;
+	let insertCode;
+	let updateCode;
+	if (options.generateInputSchemas !== false) {
+		const optionalFields = [];
+		for (const column of table.columns) {
+			const fieldName = options.useCamelCase ? toCamelCase(column.columnName) : column.columnName;
+			const hasDefault = column.columnDefault !== null;
+			const isSerial = column.columnDefault?.includes("nextval") ?? false;
+			if (isSerial || column.columnDefault?.includes("gen_random_uuid()") || hasDefault) {
+				let zodType = mapColumnToZod(column, metadata, options, warnings);
+				const columnConstraints = table.checkConstraints.filter((c) => c.columnName === column.columnName);
+				if (columnConstraints.length > 0) zodType = applyCheckConstraints(column.columnName, zodType, columnConstraints);
+				zodType = `${zodType}.optional()`;
+				let comment;
+				if (options.includeComments) {
+					const commentParts = [column.dataType];
+					if (hasDefault) commentParts.push(`default: ${column.columnDefault}`);
+					if (isSerial) commentParts.push("auto-generated");
+					comment = commentParts.join(", ");
+				}
+				optionalFields.push({
+					fieldName,
+					zodType,
+					comment
+				});
+			}
+		}
+		insertCode = "";
+		if (options.includeComments) insertCode += `/** Insert schema for ${table.tableName} */\n`;
+		if (optionalFields.length === 0) insertCode += `export const ${insertSchemaName} = ${readSchemaName};\n`;
+		else {
+			insertCode += `export const ${insertSchemaName} = ${readSchemaName}.extend({\n`;
+			for (const field of optionalFields) {
+				if (field.comment) insertCode += `  /** ${field.comment} */\n`;
+				insertCode += `  ${field.fieldName}: ${field.zodType},\n`;
+			}
+			insertCode += `});\n`;
+		}
+		insertCode += `export type ${insertTypeName} = z.infer<typeof ${insertSchemaName}>;\n`;
+		updateCode = "";
+		if (options.includeComments) updateCode += `/** Update schema for ${table.tableName} (all fields optional) */\n`;
+		updateCode += `export const ${updateSchemaName} = ${readSchemaName}.partial();\n`;
+		updateCode += `export type ${updateTypeName} = z.infer<typeof ${updateSchemaName}>;\n`;
+	}
+	return {
+		tableName: table.tableName,
+		schemaName: table.schemaName,
+		readSchema: readCode,
+		inputSchema: insertCode,
+		typeDefinitions: `${readCode}${insertCode ? "\n" + insertCode : ""}${updateCode ? "\n" + updateCode : ""}`
+	};
+}
+/**
+* Format the complete output file
+*/
+function formatOutput(result) {
+	let output = `/**\n`;
+	output += ` * ==========================================\n`;
+	output += ` *     | GENERATED BY PG-TO-ZOD (TBP) |\n`;
+	output += ` * ==========================================\n`;
+	output += ` *\n`;
+	output += ` * ⚠️ DO NOT EDIT THIS FILE MANUALLY!\n`;
+	output += ` *\n`;
+	output += ` * This file was automatically generated from\n`;
+	output += ` * your PostgreSQL database schema.\n`;
+	output += ` *\n`;
+	output += ` * To regenerate, run:\n`;
+	output += ` *   pg-to-zod --url <connection-url> -o <file>\n`;
+	output += ` *\n`;
+	output += ` * Any manual changes will be overwritten when\n`;
+	output += ` * the code is regenerated.\n`;
+	output += ` * ==========================================\n`;
+	output += ` */\n\n`;
+	output += `import { z } from 'zod';\n\n`;
+	if (result.enums.length > 0) {
+		output += `// ============================================\n`;
+		output += `// Enums\n`;
+		output += `// ============================================\n\n`;
+		for (const enumSchema of result.enums) output += enumSchema.code + "\n";
+	}
+	if (result.domains.length > 0) {
+		output += `// ============================================\n`;
+		output += `// Domains\n`;
+		output += `// ============================================\n\n`;
+		for (const domain of result.domains) output += domain.code + "\n";
+	}
+	if (result.ranges.length > 0) {
+		output += `// ============================================\n`;
+		output += `// Range Types\n`;
+		output += `// ============================================\n\n`;
+		for (const range of result.ranges) output += range.code + "\n";
+	}
+	if (result.compositeTypes.length > 0) {
+		output += `// ============================================\n`;
+		output += `// Composite Types\n`;
+		output += `// ============================================\n\n`;
+		for (const compositeType of result.compositeTypes) output += compositeType.code + "\n";
+	}
+	if (result.schemas.length > 0) {
+		output += `// ============================================\n`;
+		output += `// Tables\n`;
+		output += `// ============================================\n\n`;
+		for (const schema of result.schemas) output += schema.typeDefinitions + "\n";
+	}
+	if (result.warnings.length > 0) {
+		output += `// ============================================\n`;
+		output += `// Warnings\n`;
+		output += `// ============================================\n`;
+		output += `// The following warnings were generated:\n`;
+		for (const warning of result.warnings) output += `// - ${warning}\n`;
+	}
+	return output;
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Main function: introspect database and generate Zod schemas
+*/
+async function generateZodSchemas(config, options = {}) {
+	return generateSchemas(await introspectDatabase(config, options), options);
+}
+/**
+* Convenience function: generate schemas and return formatted output string
+*/
+async function generateZodSchemasString(config, options = {}) {
+	return formatOutput(await generateZodSchemas(config, options));
+}
+/**
+* Default export
+*/
+var src_default = {
+	generateZodSchemas,
+	generateZodSchemasString,
+	introspectDatabase,
+	generateSchemas,
+	formatOutput
+};
+
+//#endregion
+export { generateSchemas as a, toPascalCase as c, formatOutput as i, introspectDatabase as l, generateZodSchemasString as n, mapColumnToZod as o, src_default as r, toCamelCase as s, generateZodSchemas as t };
+//# sourceMappingURL=src-18pV45Fu.js.map