kysely-gen 0.9.1 → 0.11.0

package/README.md

@@ -51,6 +51,54 @@ npx kysely-gen --dialect mysql --url mysql://user:pass@localhost:3306/db
 | `--camel-case` | Convert names to camelCase |
 | `--include-pattern <glob>` | Only include matching tables |
 | `--exclude-pattern <glob>` | Exclude matching tables |
+| `--zod` | Generate Zod schemas instead of TypeScript interfaces |
+
+## Zod Schema Generation
+
+Generate Zod validation schemas with inferred types instead of TypeScript interfaces. Requires Zod v4+:
+
+```sh
+npm install zod@4
+npx kysely-gen --zod
+```
+
+This generates `db-schemas.ts` with Zod schemas and inferred types:
+
+```typescript
+import { z } from 'zod';
+
+export const userSchema = z.object({
+  id: z.number(),
+  email: z.string(),
+  name: z.string().nullable(),
+  createdAt: z.date(),
+});
+
+export const newUserSchema = z.object({
+  id: z.number().optional(),
+  email: z.string(),
+  name: z.string().nullable().optional(),
+  createdAt: z.union([z.date(), z.string()]).optional(),
+});
+
+export const userUpdateSchema = z.object({
+  id: z.number().optional(),
+  email: z.string().optional(),
+  name: z.string().nullable().optional(),
+  createdAt: z.union([z.date(), z.string()]).optional(),
+});
+
+export type User = z.infer<typeof userSchema>;
+export type NewUser = z.infer<typeof newUserSchema>;
+export type UserUpdate = z.infer<typeof userUpdateSchema>;
+```
+
+Three schemas are generated per table:
+- **Select schema** (`userSchema`): What you get from queries
+- **Insert schema** (`newUserSchema`): For inserts - auto-increment/default columns are optional
+- **Update schema** (`userUpdateSchema`): For updates - all columns are optional
+
+The `--zod` flag replaces TypeScript interface generation. Types are inferred from schemas via `z.infer<>`, ensuring they never drift.
 
 ## Example
 

package/dist/cli.js

@@ -109667,6 +109667,25 @@ function transformColumn(column, enums, enumResolver, mapType, options, unknownT
         types: [type, { kind: "primitive", value: "null" }]
       };
     }
+  } else if (column.checkConstraint) {
+    if (column.checkConstraint.type === "boolean") {
+      type = { kind: "primitive", value: "boolean" };
+      if (column.isNullable) {
+        type = {
+          kind: "union",
+          types: [type, { kind: "primitive", value: "null" }]
+        };
+      }
+    } else {
+      const literalTypes = column.checkConstraint.values.map((v) => ({
+        kind: "literal",
+        value: v
+      }));
+      if (column.isNullable) {
+        literalTypes.push({ kind: "primitive", value: "null" });
+      }
+      type = { kind: "union", types: literalTypes };
+    }
   } else {
     type = mapType(column.dataType, {
       isNullable: column.isNullable,
@@ -109723,25 +109742,139 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 
+// src/utils/check-constraint-parser.ts
+var ANY_ARRAY_REGEX = /= ANY \(\(?ARRAY\[(.*?)\]\)?(?:::[\w\[\]]+)?\)/;
+function parseCheckConstraint(definition) {
+  const anyArrayMatch = definition.match(ANY_ARRAY_REGEX);
+  if (anyArrayMatch) {
+    const arrayContent = anyArrayMatch[1];
+    if (!arrayContent || arrayContent.trim() === "")
+      return null;
+    const numericValues = parseNumericArray(arrayContent);
+    if (numericValues !== null) {
+      return { type: "number", values: numericValues };
+    }
+    const stringValues = parseStringArray(arrayContent);
+    if (stringValues !== null && stringValues.length > 0) {
+      return { type: "string", values: stringValues };
+    }
+  }
+  const orValues = parseOrChain(definition);
+  if (orValues !== null && orValues.length > 0) {
+    return { type: "string", values: orValues };
+  }
+  return null;
+}
+function parseNumericArray(arrayContent) {
+  const isNumeric = /^\s*-?\d+(\s*,\s*-?\d+)*\s*$/.test(arrayContent);
+  if (!isNumeric)
+    return null;
+  const values = arrayContent.split(",").map((v) => parseInt(v.trim(), 10));
+  if (values.some((v) => isNaN(v)))
+    return null;
+  if (values.length === 0)
+    return null;
+  return values;
+}
+function parseStringArray(arrayContent) {
+  const values = [];
+  let current = "";
+  let inQuote = false;
+  let i = 0;
+  while (i < arrayContent.length) {
+    const char = arrayContent[i];
+    if (char === "'" && !inQuote) {
+      inQuote = true;
+      i++;
+      continue;
+    }
+    if (char === "'" && inQuote) {
+      if (arrayContent[i + 1] === "'") {
+        current += "'";
+        i += 2;
+        continue;
+      }
+      values.push(current);
+      current = "";
+      inQuote = false;
+      i++;
+      continue;
+    }
+    if (inQuote) {
+      current += char;
+    }
+    i++;
+  }
+  return values.length > 0 ? values : null;
+}
+function parseOrChain(definition) {
+  const singleValueRegex = /\([^)]+= '([^']+)'(?:::[\w]+)?\)/g;
+  const values = [];
+  let match;
+  if (!definition.includes(" OR ")) {
+    return null;
+  }
+  while ((match = singleValueRegex.exec(definition)) !== null) {
+    let value = match[1];
+    value = value.replace(/''/g, "'");
+    values.push(value);
+  }
+  return values.length > 0 ? values : null;
+}
+var SQLITE_IN_REGEX = /\w+\s+IN\s*\(([^)]+)\)/i;
+function parseSqliteCheckConstraint(definition) {
+  const match = definition.match(SQLITE_IN_REGEX);
+  if (!match)
+    return null;
+  const valuesPart = match[1];
+  if (!valuesPart || valuesPart.trim() === "")
+    return null;
+  const numericValues = parseNumericArray(valuesPart);
+  if (numericValues !== null) {
+    if (isBooleanPattern(numericValues)) {
+      return { type: "boolean" };
+    }
+    return { type: "number", values: numericValues };
+  }
+  const stringValues = parseStringArray(valuesPart);
+  if (stringValues !== null && stringValues.length > 0) {
+    return { type: "string", values: stringValues };
+  }
+  return null;
+}
+function isBooleanPattern(values) {
+  if (values.length !== 2)
+    return false;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[0] === 0 && sorted[1] === 1;
+}
+
 // src/dialects/postgres/introspect.ts
 async function introspectPostgres(db, options) {
-  const [domains, partitions, baseTables, regularViews, materializedViews, enums] = await Promise.all([
+  const [domains, partitions, baseTables, regularViews, materializedViews, enums, checkConstraints, domainCheckConstraints] = await Promise.all([
     introspectDomains(db),
     introspectPartitions(db),
     introspectTables(db, options.schemas),
     introspectViews(db, options.schemas),
     introspectMaterializedViews(db, options.schemas),
-    introspectEnums(db, options.schemas)
+    introspectEnums(db, options.schemas),
+    introspectCheckConstraints(db, options.schemas),
+    introspectDomainCheckConstraints(db, options.schemas)
   ]);
   const tables = [...baseTables, ...regularViews, ...materializedViews].map((table) => {
     const isPartition = partitions.some((partition) => partition.schema === table.schema && partition.name === table.name);
     return {
       ...table,
       isPartition: isPartition || undefined,
-      columns: table.columns.map((column) => ({
-        ...column,
-        dataType: getRootType(column, domains)
-      }))
+      columns: table.columns.map((column) => {
+        const rootType = getRootType(column, domains);
+        const checkConstraint = getCheckConstraint(table.schema, table.name, column, checkConstraints, domainCheckConstraints, domains);
+        return {
+          ...column,
+          dataType: rootType,
+          ...checkConstraint && { checkConstraint }
+        };
+      })
     };
   });
   return {
@@ -109761,6 +109894,8 @@ async function introspectTables(db, schemas) {
       c.is_nullable,
       c.is_identity,
       c.column_default,
+      c.domain_name,
+      c.domain_schema,
       pg_catalog.col_description(
         (c.table_schema||'.'||c.table_name)::regclass::oid,
         c.ordinal_position
@@ -109804,6 +109939,10 @@ async function introspectTables(db, schemas) {
       if (row.column_comment) {
         columnMetadata.comment = row.column_comment;
       }
+      if (row.domain_name) {
+        columnMetadata.domainName = row.domain_name;
+        columnMetadata.domainSchema = row.domain_schema ?? undefined;
+      }
       table.columns.push(columnMetadata);
     }
   }
@@ -109821,6 +109960,8 @@ async function introspectViews(db, schemas) {
       c.is_nullable,
       c.is_identity,
       c.column_default,
+      c.domain_name,
+      c.domain_schema,
       pg_catalog.col_description(
         (c.table_schema||'.'||c.table_name)::regclass::oid,
         c.ordinal_position
@@ -109865,6 +110006,10 @@ async function introspectViews(db, schemas) {
       if (row.column_comment) {
         columnMetadata.comment = row.column_comment;
       }
+      if (row.domain_name) {
+        columnMetadata.domainName = row.domain_name;
+        columnMetadata.domainSchema = row.domain_schema ?? undefined;
+      }
       table.columns.push(columnMetadata);
     }
   }
@@ -110007,6 +110152,72 @@ function parsePostgresArray(value) {
   }
   return [value];
 }
+async function introspectCheckConstraints(db, schemas) {
+  const rawConstraints = await sql`
+    SELECT
+      n.nspname AS table_schema,
+      c.relname AS table_name,
+      a.attname AS column_name,
+      pg_get_constraintdef(pgc.oid) AS check_definition
+    FROM pg_constraint pgc
+    JOIN pg_class c ON pgc.conrelid = c.oid
+    JOIN pg_namespace n ON c.relnamespace = n.oid
+    JOIN pg_attribute a ON a.attrelid = pgc.conrelid AND a.attnum = ANY(pgc.conkey)
+    WHERE pgc.contype = 'c'
+      AND array_length(pgc.conkey, 1) = 1
+      AND n.nspname = ANY(${schemas})
+  `.execute(db);
+  const constraintMap = new Map;
+  for (const row of rawConstraints.rows) {
+    const key = `${row.table_schema}.${row.table_name}.${row.column_name}`;
+    if (constraintMap.has(key))
+      continue;
+    const parsed = parseCheckConstraint(row.check_definition);
+    if (parsed) {
+      constraintMap.set(key, parsed);
+    }
+  }
+  return constraintMap;
+}
+async function introspectDomainCheckConstraints(db, schemas) {
+  const rawConstraints = await sql`
+    SELECT
+      n.nspname AS domain_schema,
+      t.typname AS domain_name,
+      pg_get_constraintdef(pgc.oid) AS check_definition
+    FROM pg_constraint pgc
+    JOIN pg_type t ON pgc.contypid = t.oid
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE pgc.contype = 'c'
+      AND n.nspname = ANY(${schemas})
+  `.execute(db);
+  const constraintMap = new Map;
+  for (const row of rawConstraints.rows) {
+    const key = `${row.domain_schema}.${row.domain_name}`;
+    if (constraintMap.has(key))
+      continue;
+    const parsed = parseCheckConstraint(row.check_definition);
+    if (parsed) {
+      constraintMap.set(key, parsed);
+    }
+  }
+  return constraintMap;
+}
+function getCheckConstraint(tableSchema, tableName, column, checkConstraints, domainCheckConstraints, domains) {
+  const columnKey = `${tableSchema}.${tableName}.${column.name}`;
+  const directConstraint = checkConstraints.get(columnKey);
+  if (directConstraint) {
+    return directConstraint;
+  }
+  if (column.domainName && column.domainSchema) {
+    const domainKey = `${column.domainSchema}.${column.domainName}`;
+    const domainConstraint = domainCheckConstraints.get(domainKey);
+    if (domainConstraint) {
+      return domainConstraint;
+    }
+  }
+  return;
+}
 
 // src/dialects/postgres/type-mapper.ts
 function helper(name, options) {
@@ -110457,10 +110668,27 @@ class MysqlDialect2 {
   }
 }
 
+// src/utils/sqlite-ddl-parser.ts
+function parseSqliteTableDDL(sql2) {
+  const constraints = [];
+  const checkRegex = /CHECK\s*\(\s*(\w+)\s+IN\s*\(([^)]+)\)\s*\)/gi;
+  let match;
+  while ((match = checkRegex.exec(sql2)) !== null) {
+    const columnName = match[1];
+    const valuesPart = match[2];
+    constraints.push({
+      columnName,
+      definition: `${columnName} IN (${valuesPart})`
+    });
+  }
+  return constraints;
+}
+
 // src/dialects/sqlite/introspect.ts
 async function introspectSqlite(db, _options) {
+  const checkConstraints = await introspectCheckConstraints2(db);
   const [baseTables, views] = await Promise.all([
-    introspectTables3(db),
+    introspectTables3(db, checkConstraints),
     introspectViews3(db)
   ]);
   return {
@@ -110468,7 +110696,7 @@ async function introspectSqlite(db, _options) {
     enums: []
   };
 }
-async function introspectTables3(db) {
+async function introspectTables3(db, checkConstraints) {
   const rawTables = await sql`
     SELECT name, type FROM sqlite_master
     WHERE type = 'table'
@@ -110477,7 +110705,7 @@ async function introspectTables3(db) {
   `.execute(db);
   const tables = [];
   for (const rawTable of rawTables.rows) {
-    const columns = await introspectColumns(db, rawTable.name, false);
+    const columns = await introspectColumns(db, rawTable.name, false, checkConstraints);
     tables.push({
       schema: "main",
       name: rawTable.name,
@@ -110504,20 +110732,23 @@ async function introspectViews3(db) {
   }
   return tables;
 }
-async function introspectColumns(db, tableName, isView) {
+async function introspectColumns(db, tableName, isView, checkConstraints) {
   const rawColumns = await sql`
     PRAGMA table_info(${sql.raw(`'${tableName}'`)})
   `.execute(db);
   return rawColumns.rows.map((col) => {
     const isIntegerPk = col.pk === 1 && col.type.toUpperCase() === "INTEGER";
     const isAutoIncrement = !isView && isIntegerPk;
+    const constraintKey = `${tableName}.${col.name}`;
+    const checkConstraint = checkConstraints?.get(constraintKey);
     return {
       name: col.name,
       dataType: normalizeDataType2(col.type),
       dataTypeSchema: "main",
       isNullable: col.notnull === 0 && col.pk === 0,
       isAutoIncrement,
-      hasDefaultValue: col.dflt_value !== null || isAutoIncrement
+      hasDefaultValue: col.dflt_value !== null || isAutoIncrement,
+      ...checkConstraint && { checkConstraint }
     };
   });
 }
@@ -110528,6 +110759,26 @@ function normalizeDataType2(type) {
   }
   return lowerType;
 }
+async function introspectCheckConstraints2(db) {
+  const result = await sql`
+    SELECT name, sql FROM sqlite_master
+    WHERE type = 'table'
+      AND name NOT LIKE 'sqlite_%'
+      AND sql IS NOT NULL
+  `.execute(db);
+  const constraints = new Map;
+  for (const row of result.rows) {
+    const parsed = parseSqliteTableDDL(row.sql);
+    for (const { columnName, definition } of parsed) {
+      const constraint = parseSqliteCheckConstraint(definition);
+      if (constraint) {
+        const key = `${row.name}.${columnName}`;
+        constraints.set(key, constraint);
+      }
+    }
+  }
+  return constraints;
+}
 
 // src/dialects/sqlite/type-mapper.ts
 function mapSqliteType(dataType, options) {
@@ -111124,9 +111375,420 @@ function detectDialect(connectionString) {
   }
 }
 
+// src/zod/type-mapper.ts
+function mapPostgresTypeToZod(dataType, options) {
+  const { isNullable, isArray, isOptional, mode } = options;
+  if (isArray || dataType.endsWith("[]")) {
+    const baseTypeName = dataType.endsWith("[]") ? dataType.slice(0, -2) : dataType;
+    const elementSchema = mapPostgresTypeToZod(baseTypeName, {
+      isNullable: false,
+      isArray: false,
+      isOptional: false,
+      mode
+    });
+    return applyModifiers({ kind: "zod-array", element: elementSchema }, isNullable, isOptional);
+  }
+  const baseSchema = mapScalarType(dataType, mode);
+  return applyModifiers(baseSchema, isNullable, isOptional);
+}
+function applyModifiers(schema, isNullable, isOptional) {
+  const modifiers = [];
+  if (isNullable)
+    modifiers.push("nullable");
+  if (isOptional)
+    modifiers.push("optional");
+  if (modifiers.length > 0) {
+    return { kind: "zod-modified", schema, modifiers };
+  }
+  return schema;
+}
+function mapScalarType(dataType, mode) {
+  switch (dataType) {
+    case "int2":
+    case "int4":
+    case "smallint":
+    case "integer":
+    case "float4":
+    case "float8":
+    case "real":
+    case "double precision":
+      return { kind: "zod-primitive", method: "number" };
+    case "int8":
+    case "bigint":
+      if (mode === "select") {
+        return { kind: "zod-primitive", method: "string" };
+      }
+      return {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-primitive", method: "string" },
+          { kind: "zod-primitive", method: "number" },
+          { kind: "zod-primitive", method: "bigint" }
+        ]
+      };
+    case "numeric":
+    case "decimal":
+      if (mode === "select") {
+        return { kind: "zod-primitive", method: "string" };
+      }
+      return {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-primitive", method: "string" },
+          { kind: "zod-primitive", method: "number" }
+        ]
+      };
+    case "varchar":
+    case "char":
+    case "text":
+    case "citext":
+    case "uuid":
+    case "money":
+    case "time":
+    case "timetz":
+      return { kind: "zod-primitive", method: "string" };
+    case "bool":
+    case "boolean":
+      return { kind: "zod-primitive", method: "boolean" };
+    case "timestamp":
+    case "timestamptz":
+    case "date":
+      if (mode === "select") {
+        return { kind: "zod-primitive", method: "date" };
+      }
+      return {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-primitive", method: "date" },
+          { kind: "zod-primitive", method: "string" }
+        ]
+      };
+    case "interval":
+      return { kind: "zod-primitive", method: "unknown" };
+    case "json":
+    case "jsonb":
+      return { kind: "zod-primitive", method: "unknown" };
+    case "bytea":
+      return { kind: "zod-custom", typeReference: "Buffer" };
+    case "point":
+      return {
+        kind: "zod-object",
+        properties: [
+          { name: "x", schema: { kind: "zod-primitive", method: "number" } },
+          { name: "y", schema: { kind: "zod-primitive", method: "number" } }
+        ]
+      };
+    case "circle":
+      return {
+        kind: "zod-object",
+        properties: [
+          { name: "x", schema: { kind: "zod-primitive", method: "number" } },
+          { name: "y", schema: { kind: "zod-primitive", method: "number" } },
+          { name: "radius", schema: { kind: "zod-primitive", method: "number" } }
+        ]
+      };
+    case "int4range":
+    case "int8range":
+    case "numrange":
+    case "daterange":
+    case "tsrange":
+    case "tstzrange":
+      return { kind: "zod-primitive", method: "string" };
+    default:
+      return { kind: "zod-primitive", method: "unknown" };
+  }
+}
+
+// src/zod/transform.ts
+function uncapitalize(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function getSchemaName(baseName, mode) {
+  const uncap = uncapitalize(baseName);
+  switch (mode) {
+    case "select":
+      return `${uncap}Schema`;
+    case "insert":
+      return `new${baseName}Schema`;
+    case "update":
+      return `${uncap}UpdateSchema`;
+  }
+}
+function getTypeName(baseName, mode) {
+  switch (mode) {
+    case "select":
+      return baseName;
+    case "insert":
+      return `New${baseName}`;
+    case "update":
+      return `${baseName}Update`;
+  }
+}
+function transformEnumToZod(enumMeta, resolver) {
+  const name = resolver.getName(enumMeta);
+  return {
+    kind: "zod-schema-declaration",
+    name: `${uncapitalize(name)}Schema`,
+    schema: {
+      kind: "zod-enum",
+      values: enumMeta.values
+    },
+    exported: true
+  };
+}
+function transformColumnToZod(column, enums, enumResolver, mode, options) {
+  const columnName = options?.camelCase ? toCamelCase(column.name) : column.name;
+  const matchingEnum = enums.find((e) => e.name === column.dataType && e.schema === (column.dataTypeSchema ?? "public"));
+  let schema;
+  const modifiers = [];
+  if (column.isNullable)
+    modifiers.push("nullable");
+  const isOptional = mode === "update" || mode === "insert" && (column.isAutoIncrement || column.hasDefaultValue);
+  if (isOptional)
+    modifiers.push("optional");
+  if (matchingEnum) {
+    const enumName = enumResolver.getName(matchingEnum);
+    schema = { kind: "zod-reference", name: `${uncapitalize(enumName)}Schema` };
+    if (modifiers.length > 0) {
+      schema = { kind: "zod-modified", schema, modifiers };
+    }
+  } else if (column.checkConstraint) {
+    if (column.checkConstraint.type === "boolean") {
+      schema = { kind: "zod-primitive", method: "boolean" };
+    } else if (column.checkConstraint.type === "string") {
+      schema = { kind: "zod-enum", values: column.checkConstraint.values };
+    } else {
+      schema = {
+        kind: "zod-union",
+        schemas: column.checkConstraint.values.map((v) => ({
+          kind: "zod-literal",
+          value: v
+        }))
+      };
+    }
+    if (modifiers.length > 0) {
+      schema = { kind: "zod-modified", schema, modifiers };
+    }
+  } else {
+    schema = mapPostgresTypeToZod(column.dataType, {
+      isNullable: column.isNullable,
+      isArray: column.isArray,
+      isOptional,
+      mode
+    });
+  }
+  return { name: columnName, schema };
+}
+function transformTableToZod(table, enums, enumResolver, mode, options) {
+  const baseName = toPascalCase(singularize(table.name));
+  const schemaName = getSchemaName(baseName, mode);
+  const properties = table.columns.map((col) => transformColumnToZod(col, enums, enumResolver, mode, options));
+  return {
+    kind: "zod-schema-declaration",
+    name: schemaName,
+    schema: { kind: "zod-object", properties },
+    exported: true
+  };
+}
+function createInferExport(baseName, mode) {
+  return {
+    kind: "zod-infer-export",
+    typeName: getTypeName(baseName, mode),
+    schemaName: getSchemaName(baseName, mode)
+  };
+}
+function transformDatabaseToZod(metadata, options) {
+  const declarations = [];
+  declarations.push({ kind: "zod-import" });
+  const enumResolver = new EnumNameResolver(metadata.enums);
+  for (const enumMeta of metadata.enums) {
+    declarations.push(transformEnumToZod(enumMeta, enumResolver));
+  }
+  for (const table of metadata.tables) {
+    const baseName = toPascalCase(singularize(table.name));
+    declarations.push(transformTableToZod(table, metadata.enums, enumResolver, "select", options));
+    declarations.push(transformTableToZod(table, metadata.enums, enumResolver, "insert", options));
+    declarations.push(transformTableToZod(table, metadata.enums, enumResolver, "update", options));
+    declarations.push(createInferExport(baseName, "select"));
+    declarations.push(createInferExport(baseName, "insert"));
+    declarations.push(createInferExport(baseName, "update"));
+  }
+  return { declarations };
+}
+
+// src/zod/serialize.ts
+var RESERVED_WORDS2 = new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "let",
+  "static",
+  "implements",
+  "interface",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "await",
+  "abstract",
+  "as",
+  "async",
+  "declare",
+  "from",
+  "get",
+  "is",
+  "module",
+  "namespace",
+  "of",
+  "require",
+  "set",
+  "type"
+]);
+function escapeString2(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function needsQuotes2(name) {
+  if (RESERVED_WORDS2.has(name))
+    return true;
+  if (/^\d/.test(name))
+    return true;
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
+    return true;
+  return false;
+}
+function serializePropertyName2(name) {
+  return needsQuotes2(name) ? `'${escapeString2(name)}'` : name;
+}
+function serializeZodSchema(node) {
+  switch (node.kind) {
+    case "zod-primitive":
+      return serializeZodPrimitive(node);
+    case "zod-literal":
+      return serializeZodLiteral(node);
+    case "zod-union":
+      return serializeZodUnion(node);
+    case "zod-enum":
+      return serializeZodEnum(node);
+    case "zod-array":
+      return serializeZodArray(node);
+    case "zod-object":
+      return serializeZodObject(node);
+    case "zod-modified":
+      return serializeZodModified(node);
+    case "zod-reference":
+      return serializeZodReference(node);
+    case "zod-custom":
+      return serializeZodCustom(node);
+  }
+}
+function serializeZodPrimitive(node) {
+  return `z.${node.method}()`;
+}
+function serializeZodLiteral(node) {
+  if (typeof node.value === "string") {
+    return `z.literal('${escapeString2(node.value)}')`;
+  }
+  return `z.literal(${node.value})`;
+}
+function serializeZodUnion(node) {
+  const schemas = node.schemas.map(serializeZodSchema).join(", ");
+  return `z.union([${schemas}])`;
+}
+function serializeZodEnum(node) {
+  const values = node.values.map((v) => `'${escapeString2(v)}'`).join(", ");
+  return `z.enum([${values}])`;
+}
+function serializeZodArray(node) {
+  return `z.array(${serializeZodSchema(node.element)})`;
+}
+function serializeZodObject(node) {
+  if (node.properties.length === 0) {
+    return "z.object({})";
+  }
+  const props = node.properties.map((p) => serializeZodProperty(p)).join(`,
+`);
+  return `z.object({
+${props},
+})`;
+}
+function serializeZodProperty(node) {
+  const name = serializePropertyName2(node.name);
+  return `  ${name}: ${serializeZodSchema(node.schema)}`;
+}
+function serializeZodModified(node) {
+  let result = serializeZodSchema(node.schema);
+  for (const mod of node.modifiers) {
+    result += `.${mod}()`;
+  }
+  return result;
+}
+function serializeZodReference(node) {
+  return node.name;
+}
+function serializeZodCustom(node) {
+  return `z.custom<${node.typeReference}>()`;
+}
+function serializeZodDeclaration(node) {
+  switch (node.kind) {
+    case "zod-import":
+      return "import { z } from 'zod';";
+    case "zod-schema-declaration":
+      return serializeZodSchemaDeclaration(node);
+    case "zod-infer-export":
+      return serializeZodInferExport(node);
+  }
+}
+function serializeZodSchemaDeclaration(node) {
+  const exported = node.exported ? "export " : "";
+  return `${exported}const ${node.name} = ${serializeZodSchema(node.schema)};`;
+}
+function serializeZodInferExport(node) {
+  return `export type ${node.typeName} = z.infer<typeof ${node.schemaName}>;`;
+}
+function serializeZod(program2) {
+  return program2.declarations.map(serializeZodDeclaration).join(`
+
+`) + `
+`;
+}
+
 // src/cli.ts
 var program2 = new Command;
-program2.name("kysely-gen").description("Generate Kysely types from your database").version("0.1.0").option("-o, --out <path>", "Output file path", "./db.d.ts").option("-s, --schema <name>", "Schema to introspect (can be specified multiple times)", collect, []).option("--url <connection-string>", "Database connection string (overrides DATABASE_URL env)").option("-d, --dialect <name>", "Database dialect (postgres, mysql, sqlite). Auto-detected from URL if not specified").option("--camel-case", "Convert column and table names to camelCase (use with Kysely CamelCasePlugin)").option("--include-pattern <pattern>", "Only include tables matching glob pattern (schema.table format)", collect, []).option("--exclude-pattern <pattern>", "Exclude tables matching glob pattern (schema.table format)", collect, []).option("--print", "Output to stdout instead of writing to file").option("--verify", "Verify types match existing file (exit 1 if different)").action(async (options) => {
+program2.name("kysely-gen").description("Generate Kysely types from your database").version("0.1.0").option("-o, --out <path>", "Output file path", "./db.d.ts").option("-s, --schema <name>", "Schema to introspect (can be specified multiple times)", collect, []).option("--url <connection-string>", "Database connection string (overrides DATABASE_URL env)").option("-d, --dialect <name>", "Database dialect (postgres, mysql, sqlite). Auto-detected from URL if not specified").option("--camel-case", "Convert column and table names to camelCase (use with Kysely CamelCasePlugin)").option("--include-pattern <pattern>", "Only include tables matching glob pattern (schema.table format)", collect, []).option("--exclude-pattern <pattern>", "Exclude tables matching glob pattern (schema.table format)", collect, []).option("--print", "Output to stdout instead of writing to file").option("--verify", "Verify types match existing file (exit 1 if different)").option("--zod", "Generate Zod schemas with inferred types instead of TypeScript interfaces").action(async (options) => {
   try {
     await generate(options);
   } catch (error2) {
@@ -111176,7 +111838,8 @@ async function generate(options) {
     dialectName = detected;
   }
   const dialect = getDialect2(dialectName);
-  const outputPath = options.out;
+  const defaultOutputPath = options.zod ? "./db-schemas.ts" : "./db.d.ts";
+  const outputPath = options.out === "./db.d.ts" && options.zod ? defaultOutputPath : options.out;
   const defaultSchema = dialectName === "sqlite" ? "main" : dialectName === "mssql" ? "dbo" : "public";
   const schemas = options.schema.length > 0 ? options.schema : [defaultSchema];
   log("");
@@ -111212,14 +111875,25 @@ async function generate(options) {
     return;
   }
   spinner.succeed(`Found ${source_default.bold(tableCount)} tables and ${source_default.bold(enumCount)} enums`);
-  spinner.start("Generating TypeScript types...");
-  const { program: astProgram, warnings } = transformDatabase(metadata, {
-    dialectName,
-    camelCase: options.camelCase,
-    includePattern: options.includePattern.length > 0 ? options.includePattern : undefined,
-    excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
-  });
-  const code = serialize(astProgram);
+  let code;
+  let warnings = [];
+  if (options.zod) {
+    spinner.start("Generating Zod schemas...");
+    const zodProgram = transformDatabaseToZod(metadata, {
+      camelCase: options.camelCase
+    });
+    code = serializeZod(zodProgram);
+  } else {
+    spinner.start("Generating TypeScript types...");
+    const { program: astProgram, warnings: tsWarnings } = transformDatabase(metadata, {
+      dialectName,
+      camelCase: options.camelCase,
+      includePattern: options.includePattern.length > 0 ? options.includePattern : undefined,
+      excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
+    });
+    code = serialize(astProgram);
+    warnings = tsWarnings;
+  }
   if (options.verify) {
     const absolutePath = resolve(outputPath);
     const existing = await readFile(absolutePath, "utf-8").catch(() => null);
@@ -111240,13 +111914,14 @@ async function generate(options) {
     await db.destroy();
     process.exit(1);
   }
+  const outputLabel = options.zod ? "Zod schemas" : "Types";
   if (printMode) {
-    spinner.succeed("Types generated");
+    spinner.succeed(`${outputLabel} generated`);
     process.stdout.write(code);
   } else {
     const absolutePath = resolve(outputPath);
     await writeFile(absolutePath, code, "utf-8");
-    spinner.succeed(`Types written to ${source_default.cyan(absolutePath)}`);
+    spinner.succeed(`${outputLabel} written to ${source_default.cyan(absolutePath)}`);
   }
   if (warnings.length > 0) {
     log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely-gen",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "Database type generator for Kysely - Supports PostgreSQL, MySQL, SQLite, and MSSQL",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,9 @@
     "typegen",
     "type-generator",
     "database",
-    "sql"
+    "sql",
+    "zod",
+    "validation"
   ],
   "engines": {
     "node": ">=20.0.0",
@@ -73,7 +75,8 @@
     "mysql2": "^3.11.0",
     "tarn": "^3.0.2",
     "tedious": "^18.0.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "zod": "^4.3.5"
   },
   "peerDependencies": {
     "kysely": ">=0.27.0 <1.0.0",
@@ -81,7 +84,8 @@
     "mysql2": ">=3.0.0 <4.0.0",
     "better-sqlite3": ">=9.0.0 <13.0.0",
     "tedious": ">=16.0.0 <19.0.0",
-    "tarn": ">=3.0.0 <4.0.0"
+    "tarn": ">=3.0.0 <4.0.0",
+    "zod": ">=4.0.0 <5.0.0"
   },
   "peerDependenciesMeta": {
     "pg": {
@@ -98,6 +102,9 @@
     },
     "tarn": {
       "optional": true
+    },
+    "zod": {
+      "optional": true
     }
   }
 }