kysely-gen 0.10.0 → 0.11.0

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) {
@@ -111289,20 +111540,36 @@ 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") {
+      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 {
-    const isOptional = mode === "update" || mode === "insert" && (column.isAutoIncrement || column.hasDefaultValue);
     schema = mapPostgresTypeToZod(column.dataType, {
       isNullable: column.isNullable,
       isArray: column.isArray,

package/package.json

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