kysely-gen 0.11.0 → 0.12.1

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

@@ -109669,7 +109669,17 @@ function transformColumn(column, enums, enumResolver, mapType, options, unknownT
     }
   } else if (column.checkConstraint) {
     if (column.checkConstraint.type === "boolean") {
-      type = { kind: "primitive", value: "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",
@@ -109848,6 +109858,46 @@ function isBooleanPattern(values) {
   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) {
@@ -110857,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: []
@@ -110937,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) {
@@ -111554,7 +111644,17 @@ function transformColumnToZod(column, enums, enumResolver, mode, options) {
     }
   } else if (column.checkConstraint) {
     if (column.checkConstraint.type === "boolean") {
-      schema = { kind: "zod-primitive", method: "boolean" };
+      if (options?.noBooleanCoerce) {
+        schema = {
+          kind: "zod-union",
+          schemas: [
+            { kind: "zod-literal", value: 0 },
+            { kind: "zod-literal", value: 1 }
+          ]
+        };
+      } else {
+        schema = { kind: "zod-coerce", method: "boolean" };
+      }
     } else if (column.checkConstraint.type === "string") {
       schema = { kind: "zod-enum", values: column.checkConstraint.values };
     } else {
@@ -111713,6 +111813,10 @@ function serializeZodSchema(node) {
       return serializeZodReference(node);
     case "zod-custom":
       return serializeZodCustom(node);
+    case "zod-transform":
+      return serializeZodTransform(node);
+    case "zod-coerce":
+      return serializeZodCoerce(node);
   }
 }
 function serializeZodPrimitive(node) {
@@ -111762,6 +111866,12 @@ function serializeZodReference(node) {
 function serializeZodCustom(node) {
   return `z.custom<${node.typeReference}>()`;
 }
+function serializeZodTransform(node) {
+  return `${serializeZodSchema(node.schema)}.transform(${node.transformFn})`;
+}
+function serializeZodCoerce(node) {
+  return `z.coerce.${node.method}()`;
+}
 function serializeZodDeclaration(node) {
   switch (node.kind) {
     case "zod-import":
@@ -111788,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) {
@@ -111877,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 {
@@ -111889,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.11.0",
+  "version": "0.12.1",
   "description": "Database type generator for Kysely - Supports PostgreSQL, MySQL, SQLite, and MSSQL",
   "type": "module",
   "license": "MIT",