kysely-gen 0.10.0 → 0.12.0

package/README.md

@@ -52,6 +52,7 @@ npx kysely-gen --dialect mysql --url mysql://user:pass@localhost:3306/db
 | `--include-pattern <glob>` | Only include matching tables |
 | `--exclude-pattern <glob>` | Exclude matching tables |
 | `--zod` | Generate Zod schemas instead of TypeScript interfaces |
+| `--no-boolean-coerce` | Output `0 \| 1` instead of coercing to `boolean` for CHECK constraints |
 
 ## Zod Schema Generation
 
@@ -159,6 +160,21 @@ export interface DB {
 - All MSSQL types: `uniqueidentifier`, `datetime2`, `datetimeoffset`, `money`, `xml`, `varbinary`, etc.
 - Both URL (`mssql://`) and ADO.NET connection string formats
 
+### Boolean Coercion (SQLite/MSSQL)
+
+SQLite and MSSQL store booleans as integers (0/1). When a `CHECK(col IN (0, 1))` constraint is detected, kysely-gen generates:
+
+**TypeScript:** `boolean`
+**Zod:** `z.union([z.literal(0), z.literal(1)]).transform(v => v === 1)`
+
+The Zod transform coerces the raw 0/1 from the database to `true`/`false`, ensuring runtime validation passes.
+
+Use `--no-boolean-coerce` to output raw `0 | 1` instead:
+
+```sh
+kysely-gen --zod --no-boolean-coerce
+```
+
 ## Type Mappings
 
 Types are generated to match the default behavior of each database driver. If you customize your driver's type parsers, the generated types may not match.

package/dist/cli.js

@@ -109667,6 +109667,35 @@ function transformColumn(column, enums, enumResolver, mapType, options, unknownT
         types: [type, { kind: "primitive", value: "null" }]
       };
     }
+  } else if (column.checkConstraint) {
+    if (column.checkConstraint.type === "boolean") {
+      if (options?.noBooleanCoerce) {
+        type = {
+          kind: "union",
+          types: [
+            { kind: "literal", value: 0 },
+            { kind: "literal", value: 1 }
+          ]
+        };
+      } else {
+        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 +109752,179 @@ 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;
+}
+var MSSQL_IN_REGEX = /\[\w+\]\s+IN\s*\(([^)]+)\)/i;
+function parseMssqlCheckConstraint(definition) {
+  if (!definition || definition.trim() === "")
+    return null;
+  const inMatch = definition.match(MSSQL_IN_REGEX);
+  if (inMatch) {
+    const valuesPart = inMatch[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 };
+    }
+  }
+  if (definition.includes(" OR ")) {
+    const values = parseMssqlOrChain(definition);
+    if (values !== null && values.length > 0) {
+      return { type: "string", values };
+    }
+  }
+  return null;
+}
+function parseMssqlOrChain(definition) {
+  const values = [];
+  let match;
+  const regex2 = /\[\w+\]='((?:[^']|'')*)'/g;
+  while ((match = regex2.exec(definition)) !== null) {
+    let value = match[1];
+    value = value.replace(/''/g, "'");
+    values.push(value);
+  }
+  return values.length > 0 ? values : null;
+}
+
 // 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 +109944,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 +109989,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 +110010,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 +110056,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 +110202,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 +110718,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 +110746,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 +110755,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 +110782,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 +110809,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) {
@@ -110606,11 +110907,22 @@ class SqliteDialect2 {
 
 // src/dialects/mssql/introspect.ts
 async function introspectMssql(db, options) {
-  const [baseTables, views] = await Promise.all([
+  const [baseTables, views, checkConstraints] = await Promise.all([
     introspectTables4(db, options.schemas),
-    introspectViews4(db, options.schemas)
+    introspectViews4(db, options.schemas),
+    introspectCheckConstraints3(db, options.schemas)
   ]);
-  const tables = [...baseTables, ...views];
+  const tables = [...baseTables, ...views].map((table) => ({
+    ...table,
+    columns: table.columns.map((column) => {
+      const key = `${table.schema}.${table.name}.${column.name}`;
+      const checkConstraint = checkConstraints.get(key);
+      return {
+        ...column,
+        ...checkConstraint && { checkConstraint }
+      };
+    })
+  }));
   return {
     tables,
     enums: []
@@ -110686,6 +110998,35 @@ function buildTableMetadata2(rows, isView) {
   }
   return Array.from(tableMap.values());
 }
+async function introspectCheckConstraints3(db, schemas) {
+  const rawConstraints = await sql`
+    SELECT
+      s.name AS schema_name,
+      t.name AS table_name,
+      c.name AS column_name,
+      cc.definition AS check_definition
+    FROM sys.check_constraints cc
+    JOIN sys.tables t ON cc.parent_object_id = t.object_id
+    JOIN sys.schemas s ON t.schema_id = s.schema_id
+    LEFT JOIN sys.columns c ON cc.parent_column_id = c.column_id AND c.object_id = t.object_id
+    WHERE cc.is_disabled = 0
+      AND cc.parent_column_id > 0
+      AND s.name IN (${sql.join(schemas.map((s) => sql`${s}`))})
+  `.execute(db);
+  const constraintMap = new Map;
+  for (const row of rawConstraints.rows) {
+    if (!row.column_name)
+      continue;
+    const key = `${row.schema_name}.${row.table_name}.${row.column_name}`;
+    if (constraintMap.has(key))
+      continue;
+    const parsed = parseMssqlCheckConstraint(row.check_definition);
+    if (parsed) {
+      constraintMap.set(key, parsed);
+    }
+  }
+  return constraintMap;
+}
 
 // src/dialects/mssql/type-mapper.ts
 function mapMssqlType(dataType, options) {
@@ -111289,20 +111630,51 @@ 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` };
-    const modifiers = [];
-    if (column.isNullable)
-      modifiers.push("nullable");
-    const isOptional = mode === "update" || mode === "insert" && (column.isAutoIncrement || column.hasDefaultValue);
-    if (isOptional)
-      modifiers.push("optional");
+    if (modifiers.length > 0) {
+      schema = { kind: "zod-modified", schema, modifiers };
+    }
+  } else if (column.checkConstraint) {
+    if (column.checkConstraint.type === "boolean") {
+      const unionSchema = {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-literal", value: 0 },
+          { kind: "zod-literal", value: 1 }
+        ]
+      };
+      if (options?.noBooleanCoerce) {
+        schema = unionSchema;
+      } else {
+        schema = {
+          kind: "zod-transform",
+          schema: unionSchema,
+          transformFn: "v => v === 1"
+        };
+      }
+    } 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 {
-    const isOptional = mode === "update" || mode === "insert" && (column.isAutoIncrement || column.hasDefaultValue);
     schema = mapPostgresTypeToZod(column.dataType, {
       isNullable: column.isNullable,
       isArray: column.isArray,
@@ -111446,6 +111818,8 @@ function serializeZodSchema(node) {
       return serializeZodReference(node);
     case "zod-custom":
       return serializeZodCustom(node);
+    case "zod-transform":
+      return serializeZodTransform(node);
   }
 }
 function serializeZodPrimitive(node) {
@@ -111495,6 +111869,9 @@ function serializeZodReference(node) {
 function serializeZodCustom(node) {
   return `z.custom<${node.typeReference}>()`;
 }
+function serializeZodTransform(node) {
+  return `${serializeZodSchema(node.schema)}.transform(${node.transformFn})`;
+}
 function serializeZodDeclaration(node) {
   switch (node.kind) {
     case "zod-import":
@@ -111521,7 +111898,7 @@ function serializeZod(program2) {
 
 // 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)").option("--zod", "Generate Zod schemas with inferred types instead of TypeScript interfaces").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").option("--no-boolean-coerce", "Output 0 | 1 instead of coercing to boolean for CHECK(col IN (0, 1))").action(async (options) => {
   try {
     await generate(options);
   } catch (error2) {
@@ -111610,10 +111987,12 @@ async function generate(options) {
   spinner.succeed(`Found ${source_default.bold(tableCount)} tables and ${source_default.bold(enumCount)} enums`);
   let code;
   let warnings = [];
+  const noBooleanCoerce = options.booleanCoerce === false;
   if (options.zod) {
     spinner.start("Generating Zod schemas...");
     const zodProgram = transformDatabaseToZod(metadata, {
-      camelCase: options.camelCase
+      camelCase: options.camelCase,
+      noBooleanCoerce
     });
     code = serializeZod(zodProgram);
   } else {
@@ -111622,7 +112001,8 @@ async function generate(options) {
       dialectName,
       camelCase: options.camelCase,
       includePattern: options.includePattern.length > 0 ? options.includePattern : undefined,
-      excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
+      excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined,
+      noBooleanCoerce
     });
     code = serialize(astProgram);
     warnings = tsWarnings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely-gen",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Database type generator for Kysely - Supports PostgreSQL, MySQL, SQLite, and MSSQL",
   "type": "module",
   "license": "MIT",