kysely-gen 0.12.0 → 0.13.0

package/dist/cli.js

@@ -109898,6 +109898,44 @@ function parseMssqlOrChain(definition) {
   }
   return values.length > 0 ? values : null;
 }
+var MYSQL_IN_REGEX = /^[\s(]*`?(\w+)`?\s+IN\s*\(([^)]+)\)/i;
+function parseMysqlCheckConstraint(definition) {
+  if (!definition || definition.trim() === "")
+    return null;
+  const match = definition.match(MYSQL_IN_REGEX);
+  if (!match)
+    return null;
+  const columnName = match[1];
+  const valuesPart = match[2];
+  if (!valuesPart || valuesPart.trim() === "")
+    return null;
+  const numericValues = parseNumericArray(valuesPart);
+  if (numericValues !== null) {
+    if (isBooleanPattern(numericValues)) {
+      return { columnName, constraint: { type: "boolean" } };
+    }
+    return { columnName, constraint: { type: "number", values: numericValues } };
+  }
+  const stringValues = parseMysqlStringArray(valuesPart);
+  if (stringValues !== null && stringValues.length > 0) {
+    return { columnName, constraint: { type: "string", values: stringValues } };
+  }
+  return null;
+}
+function parseMysqlStringArray(arrayContent) {
+  const values = [];
+  const mysqlValueRegex = /_\w+\\'([^'\\]*)\\'/g;
+  let match;
+  while ((match = mysqlValueRegex.exec(arrayContent)) !== null) {
+    let value = match[1];
+    value = value.replace(/''/g, "'");
+    values.push(value);
+  }
+  if (values.length > 0) {
+    return values;
+  }
+  return parseStringArray(arrayContent);
+}
 
 // src/dialects/postgres/introspect.ts
 async function introspectPostgres(db, options) {
@@ -110441,11 +110479,22 @@ function isEnumType(columnType) {
 
 // src/dialects/mysql/introspect.ts
 async function introspectMysql(db, options) {
-  const [baseTables, views] = await Promise.all([
+  const [baseTables, views, checkConstraints] = await Promise.all([
     introspectTables2(db, options.schemas),
-    introspectViews2(db, options.schemas)
+    introspectViews2(db, options.schemas),
+    introspectCheckConstraints2(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 }
+      };
+    })
+  }));
   const enums = extractEnums(tables);
   return {
     tables,
@@ -110560,6 +110609,31 @@ function extractEnums(tables) {
   }
   return Array.from(enumMap.values());
 }
+async function introspectCheckConstraints2(db, schemas) {
+  const rawConstraints = await sql`
+    SELECT
+      tc.TABLE_SCHEMA AS CONSTRAINT_SCHEMA,
+      tc.TABLE_NAME,
+      cc.CHECK_CLAUSE
+    FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+    JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc
+      ON tc.CONSTRAINT_SCHEMA = cc.CONSTRAINT_SCHEMA
+      AND tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+    WHERE tc.CONSTRAINT_TYPE = 'CHECK'
+      AND tc.TABLE_SCHEMA IN (${sql.join(schemas.map((s) => sql`${s}`))})
+  `.execute(db);
+  const constraintMap = new Map;
+  for (const row of rawConstraints.rows) {
+    const parsed = parseMysqlCheckConstraint(row.CHECK_CLAUSE);
+    if (!parsed)
+      continue;
+    const key = `${row.CONSTRAINT_SCHEMA}.${row.TABLE_NAME}.${parsed.columnName}`;
+    if (constraintMap.has(key))
+      continue;
+    constraintMap.set(key, parsed.constraint);
+  }
+  return constraintMap;
+}
 
 // src/dialects/mysql/type-mapper.ts
 function createColumnType(selectType, insertType, updateType) {
@@ -110736,7 +110810,7 @@ function parseSqliteTableDDL(sql2) {
 
 // src/dialects/sqlite/introspect.ts
 async function introspectSqlite(db, _options) {
-  const checkConstraints = await introspectCheckConstraints2(db);
+  const checkConstraints = await introspectCheckConstraints3(db);
   const [baseTables, views] = await Promise.all([
     introspectTables3(db, checkConstraints),
     introspectViews3(db)
@@ -110809,7 +110883,7 @@ function normalizeDataType2(type) {
   }
   return lowerType;
 }
-async function introspectCheckConstraints2(db) {
+async function introspectCheckConstraints3(db) {
   const result = await sql`
     SELECT name, sql FROM sqlite_master
     WHERE type = 'table'
@@ -110910,7 +110984,7 @@ async function introspectMssql(db, options) {
   const [baseTables, views, checkConstraints] = await Promise.all([
     introspectTables4(db, options.schemas),
     introspectViews4(db, options.schemas),
-    introspectCheckConstraints3(db, options.schemas)
+    introspectCheckConstraints4(db, options.schemas)
   ]);
   const tables = [...baseTables, ...views].map((table) => ({
     ...table,
@@ -110998,7 +111072,7 @@ function buildTableMetadata2(rows, isView) {
   }
   return Array.from(tableMap.values());
 }
-async function introspectCheckConstraints3(db, schemas) {
+async function introspectCheckConstraints4(db, schemas) {
   const rawConstraints = await sql`
     SELECT
       s.name AS schema_name,
@@ -111644,21 +111718,16 @@ function transformColumnToZod(column, enums, enumResolver, mode, options) {
     }
   } 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"
+          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 };
@@ -111820,6 +111889,8 @@ function serializeZodSchema(node) {
       return serializeZodCustom(node);
     case "zod-transform":
       return serializeZodTransform(node);
+    case "zod-coerce":
+      return serializeZodCoerce(node);
   }
 }
 function serializeZodPrimitive(node) {
@@ -111872,6 +111943,9 @@ function serializeZodCustom(node) {
 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":

package/package.json

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