@vibeorm/migrate 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/ddl/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/ddl/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAGH,OAAO,KAAK,EAAmB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAajE,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,aAAa,CAAC;AAI9D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAChC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,EAAE,CAAC,EAAE,QAAQ,CAAC;CACf,GAAG,MAAM,EAAE,CAkLX"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/ddl/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAGH,OAAO,KAAK,EAAmB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAajE,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,aAAa,CAAC;AAI9D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAChC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,EAAE,CAAC,EAAE,QAAQ,CAAC;CACf,GAAG,MAAM,EAAE,CA0LX"}

package/dist/differ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../src/differ.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAU,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAKjE,OAAO,KAAK,EAAqB,aAAa,EAAE,MAAM,YAAY,CAAC;AAkCnE;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAClC,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,aAAa,EAAE,CAsDlB"}
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../src/differ.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAU,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAKjE,OAAO,KAAK,EAAqB,aAAa,EAAE,MAAM,YAAY,CAAC;AAoCnE;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAClC,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,aAAa,EAAE,CA0DlB"}

package/dist/index.js

@@ -21,6 +21,10 @@ function describeStep(params) {
       return `alter column "${step.table}"."${step.column}" (${step.changes.join(", ")})`;
     case "createIndex":
       return `create ${step.unique ? "unique " : ""}index "${step.name}" on "${step.table}"`;
+    case "addCheck":
+      return `add check "${step.name}" on "${step.table}"`;
+    case "dropCheck":
+      return `drop check "${step.name}" on "${step.table}"`;
     case "dropIndex":
       return `drop index "${step.name}"`;
     case "addForeignKey":
@@ -389,6 +393,32 @@ function sqliteEnumCheckName(params) {
   return `${params.table}_${params.column}_enum_${params.enumName}`;
 }
 var ENUM_CHECK_PATTERN = /CONSTRAINT "((?:[^"]|"")+)_enum_((?:[^"]|"")+)" CHECK \("((?:[^"]|"")+)" IN \(([^)]*)\)\)/g;
+function parseSqliteNamedChecks(params) {
+  const { tableSql } = params;
+  const result = [];
+  for (const match of tableSql.matchAll(/CONSTRAINT "((?:[^"]|"")+)" CHECK\s*\(/g)) {
+    const name = match[1].replaceAll('""', '"');
+    const open = (match.index ?? 0) + match[0].length - 1;
+    let depth = 0;
+    let close = -1;
+    for (let index = open;index < tableSql.length; index++) {
+      const char = tableSql[index];
+      if (char === "(")
+        depth += 1;
+      else if (char === ")") {
+        depth -= 1;
+        if (depth === 0) {
+          close = index;
+          break;
+        }
+      }
+    }
+    if (close === -1)
+      continue;
+    result.push({ name, expression: tableSql.slice(open + 1, close) });
+  }
+  return result;
+}
 function parseSqliteEnumChecks(params) {
   const result = [];
   for (const match of params.tableSql.matchAll(ENUM_CHECK_PATTERN)) {
@@ -599,7 +629,10 @@ function normalizeModel(params) {
   const pk = normalizePk({ model });
   const indexes = normalizeIndexes({ model, table });
   const fks = normalizeFks({ model, table, schema });
-  return { model, table, columns, pk, indexes, fks };
+  const checks = new Map;
+  for (const check of model.checks ?? [])
+    checks.set(check.name, check.expression);
+  return { model, table, columns, pk, indexes, fks, checks };
 }
 function normalizePk(params) {
   const { model } = params;
@@ -624,7 +657,8 @@ function normalizeIndexes(params) {
       };
     });
     const where = index.where;
-    const key = indexComparisonKey({ unique, kind, columns, where });
+    const nullsNotDistinct = unique && index.nullsNotDistinct === true;
+    const key = indexComparisonKey({ unique, kind, columns, where, nullsNotDistinct });
     if (result.has(key))
       return;
     const name = index.name ?? `${table}_${columns.map((column) => column.name).join("_")}_${unique ? "key" : "idx"}`;
@@ -634,7 +668,8 @@ function normalizeIndexes(params) {
       kind,
       unique,
       columns,
-      ...where === undefined ? {} : { where }
+      ...where === undefined ? {} : { where },
+      ...nullsNotDistinct ? { nullsNotDistinct: true } : {}
     });
   };
   for (const index of model.indexes)
@@ -647,9 +682,9 @@ function normalizeIndexes(params) {
   return result;
 }
 function indexComparisonKey(params) {
-  const { unique, kind, columns, where } = params;
+  const { unique, kind, columns, where, nullsNotDistinct } = params;
   const cols = columns.map((column) => `${column.name}${column.desc ? " desc" : ""}`).join(",");
-  return `${unique ? "u" : "i"}:${kind}:${cols}:${normalizeWhere({ where })}`;
+  return `${unique ? "u" : "i"}${nullsNotDistinct === true ? "n" : ""}:${kind}:${cols}:${normalizeWhere({ where })}`;
 }
 function normalizeWhere(params) {
   const { where } = params;
@@ -748,6 +783,8 @@ function diffSchemas(params) {
     dropColumn: [],
     dropPrimaryKey: [],
     addPrimaryKey: [],
+    dropCheck: [],
+    addCheck: [],
     createIndex: [],
     addForeignKey: [],
     createJoinTable: [],
@@ -772,6 +809,8 @@ function diffSchemas(params) {
     ...buckets.dropColumn,
     ...buckets.dropPrimaryKey,
     ...buckets.addPrimaryKey,
+    ...buckets.dropCheck,
+    ...buckets.addCheck,
     ...buckets.createIndex,
     ...buckets.addForeignKey,
     ...buckets.createJoinTable,
@@ -881,6 +920,7 @@ function createWholeTable(params) {
     table: table.table,
     columns: [...table.columns.values()].map((column) => column.field),
     primaryKey: table.pk,
+    checks: [...table.checks].map(([name, expression]) => ({ name, expression })),
     destructive: false
   });
   for (const index of table.indexes.values()) {
@@ -892,6 +932,7 @@ function createWholeTable(params) {
       unique: index.unique,
       columns: index.columns,
       ...index.where === undefined ? {} : { where: index.where },
+      ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
       destructive: false
     });
   }
@@ -973,6 +1014,16 @@ function diffOneTable(params) {
       });
     }
   }
+  for (const [name, expression] of current.checks) {
+    if (previous.checks.has(name))
+      continue;
+    buckets.addCheck.push({ kind: "addCheck", table, name, expression, destructive: false });
+  }
+  for (const [name] of previous.checks) {
+    if (current.checks.has(name))
+      continue;
+    buckets.dropCheck.push({ kind: "dropCheck", table, name, destructive: false });
+  }
   for (const [key, index] of current.indexes) {
     if (previous.indexes.has(key))
       continue;
@@ -984,6 +1035,7 @@ function diffOneTable(params) {
       unique: index.unique,
       columns: index.columns,
       ...index.where === undefined ? {} : { where: index.where },
+      ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {},
       destructive: false
     });
   }
@@ -1065,6 +1117,9 @@ function renderStep(params) {
         const pkCols = step.primaryKey.map((column) => q(column)).join(", ");
         lines.push(`  CONSTRAINT ${q(`${step.table}_pkey`)} PRIMARY KEY (${pkCols})`);
       }
+      for (const check of step.checks ?? []) {
+        lines.push(`  CONSTRAINT ${q(check.name)} CHECK (${check.expression})`);
+      }
       return [`CREATE TABLE ${q(step.table)} (
 ${lines.join(`,
 `)}
@@ -1085,13 +1140,20 @@ ${lines.join(`,
       const unique = step.unique ? "UNIQUE " : "";
       const using = !step.unique && step.indexKind !== "btree" ? ` USING ${step.indexKind}` : "";
       const cols = step.columns.map((column) => `${q(column.name)}${column.desc ? " DESC" : ""}`).join(", ");
+      const nulls = step.nullsNotDistinct === true ? " NULLS NOT DISTINCT" : "";
       const where = step.where === undefined ? "" : ` WHERE ${step.where}`;
       return [
-        `CREATE ${unique}INDEX ${q(step.name)} ON ${q(step.table)}${using} (${cols})${where};`
+        `CREATE ${unique}INDEX ${q(step.name)} ON ${q(step.table)}${using} (${cols})${nulls}${where};`
       ];
     }
     case "dropIndex":
       return [`DROP INDEX ${q(step.name)};`];
+    case "addCheck":
+      return [
+        `ALTER TABLE ${q(step.table)} ADD CONSTRAINT ${q(step.name)} CHECK (${step.expression});`
+      ];
+    case "dropCheck":
+      return [`ALTER TABLE ${q(step.table)} DROP CONSTRAINT ${q(step.name)};`];
     case "addForeignKey": {
       const cols = step.columns.map((column) => q(column)).join(", ");
       const refCols = step.refColumns.map((column) => q(column)).join(", ");
@@ -1245,6 +1307,8 @@ function renderSqliteSteps(params) {
       case "dropForeignKey":
       case "addPrimaryKey":
       case "dropPrimaryKey":
+      case "addCheck":
+      case "dropCheck":
         markRebuild(step.table);
         break;
       case "addColumn":
@@ -1288,6 +1352,7 @@ function renderSqliteSteps(params) {
           constraintTable: step.table,
           columns: step.columns,
           primaryKey: step.primaryKey,
+          checks: step.checks ?? [],
           fks: (foldedFks.get(step.table) ?? []).map((fk) => ({
             constraintName: fk.constraintName,
             columns: fk.columns,
@@ -1299,6 +1364,9 @@ function renderSqliteSteps(params) {
           enums
         }));
         break;
+      case "addCheck":
+      case "dropCheck":
+        break;
       case "createJoinTable": {
         const aType = sqliteStorageType({ field: { ...step.a.field, isList: false } });
         const bType = sqliteStorageType({ field: { ...step.b.field, isList: false } });
@@ -1333,7 +1401,8 @@ function renderSqliteSteps(params) {
             unique: step.unique,
             kind: step.indexKind,
             columns: step.columns,
-            where: step.where
+            where: step.where,
+            nullsNotDistinct: step.nullsNotDistinct
           }));
         }
         break;
@@ -1389,6 +1458,7 @@ function renderTableRebuild(params) {
     constraintTable: table,
     columns: [...target.columns.values()].map((column) => column.field),
     primaryKey: target.pk,
+    checks: [...target.checks].map(([name, expression]) => ({ name, expression })),
     fks: [...target.fks.values()].map((fk) => ({
       constraintName: fk.constraintName,
       columns: fk.columns,
@@ -1412,7 +1482,8 @@ function renderTableRebuild(params) {
       unique: index.unique,
       kind: index.kind,
       columns: index.columns,
-      where: index.where
+      where: index.where,
+      nullsNotDistinct: index.nullsNotDistinct
     }));
   }
   statements.push("PRAGMA foreign_key_check;", "COMMIT;", "PRAGMA foreign_keys=ON;");
@@ -1470,6 +1541,9 @@ function createTableSql(params) {
   if (primaryKey.length > 0 && autoincrementPk === undefined) {
     lines.push(`  PRIMARY KEY (${primaryKey.map((column) => q2(column)).join(", ")})`);
   }
+  for (const check of params.checks) {
+    lines.push(`  CONSTRAINT ${q2(check.name)} CHECK (${check.expression})`);
+  }
   for (const fk of fks) {
     lines.push(`  CONSTRAINT ${q2(fk.constraintName)} FOREIGN KEY (${fk.columns.map((column) => q2(column)).join(", ")}) REFERENCES ${q2(fk.refTable)} (${fk.refColumns.map((column) => q2(column)).join(", ")}) ON DELETE ${fk.onDelete} ON UPDATE ${fk.onUpdate}`);
   }
@@ -1525,6 +1599,13 @@ function columnDefSql2(params) {
 }
 function createIndexSql(params) {
   const { table, name, unique, kind, columns, where } = params;
+  if (params.nullsNotDistinct === true) {
+    throw unsupportedCapability4({
+      dialect: "sqlite",
+      feature: `UNIQUE NULLS NOT DISTINCT (index "${name}")`,
+      hint: "sqlite treats NULLs as distinct in unique indexes and has no switch \u2014 gate the flag per dialect"
+    });
+  }
   if (!unique && kind !== "btree") {
     throw unsupportedCapability4({
       dialect: "sqlite",
@@ -1583,6 +1664,9 @@ function renderStep2(params) {
       if (step.primaryKey.length > 0) {
         lines.push(`  PRIMARY KEY (${step.primaryKey.map((column) => q3(column)).join(", ")})`);
       }
+      for (const check of step.checks ?? []) {
+        lines.push(`  CONSTRAINT ${q3(check.name)} CHECK (${check.expression})`);
+      }
       return [`CREATE TABLE ${q3(step.table)} (
 ${lines.join(`,
 `)}
@@ -1609,6 +1693,13 @@ ${lines.join(`,
           hint: "mysql has no partial indexes \u2014 drop the WHERE predicate or gate the index per dialect"
         });
       }
+      if (step.nullsNotDistinct === true) {
+        throw unsupportedCapability5({
+          dialect: "mysql",
+          feature: `UNIQUE NULLS NOT DISTINCT (index "${step.name}")`,
+          hint: "mysql treats NULLs as distinct in unique indexes and has no switch \u2014 gate the flag per dialect"
+        });
+      }
       if (!step.unique && step.indexKind !== "btree") {
         throw unsupportedCapability5({
           dialect: "mysql",
@@ -1621,6 +1712,12 @@ ${lines.join(`,
         `CREATE ${step.unique ? "UNIQUE " : ""}INDEX ${q3(step.name)} ON ${q3(step.table)} (${cols});`
       ];
     }
+    case "addCheck":
+      return [
+        `ALTER TABLE ${q3(step.table)} ADD CONSTRAINT ${q3(step.name)} CHECK (${step.expression});`
+      ];
+    case "dropCheck":
+      return [`ALTER TABLE ${q3(step.table)} DROP CHECK ${q3(step.name)};`];
     case "dropIndex": {
       if (step.table === undefined) {
         throw new VibeError7({
@@ -2561,6 +2658,18 @@ var CONSTRAINTS_QUERY = `
     AND n.nspname = 'public'
   ORDER BY cl.relname, c.conname, k.ord;
 `;
+var CHECKS_QUERY = `
+  SELECT
+    cl.relname AS table_name,
+    c.conname AS constraint_name,
+    pg_get_constraintdef(c.oid) AS definition
+  FROM pg_catalog.pg_constraint c
+  JOIN pg_catalog.pg_class cl    ON cl.oid = c.conrelid
+  JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
+  WHERE c.contype = 'c'
+    AND n.nspname = 'public'
+  ORDER BY cl.relname, c.conname;
+`;
 var FOREIGN_KEYS_QUERY = `
   SELECT
     c.conname   AS constraint_name,
@@ -2606,14 +2715,15 @@ var INDEXES_QUERY = `
 `;
 async function introspectPostgres(params) {
   const { executor } = params;
-  const [tableRows, viewRows, columnRows, constraintRows, fkRows, enumRows, indexRows] = await Promise.all([
+  const [tableRows, viewRows, columnRows, constraintRows, fkRows, enumRows, indexRows, checkRows] = await Promise.all([
     executor({ text: TABLES_QUERY }),
     executor({ text: VIEWS_QUERY }),
     executor({ text: COLUMNS_QUERY }),
     executor({ text: CONSTRAINTS_QUERY }),
     executor({ text: FOREIGN_KEYS_QUERY }),
     executor({ text: ENUMS_QUERY }),
-    executor({ text: INDEXES_QUERY })
+    executor({ text: INDEXES_QUERY }),
+    executor({ text: CHECKS_QUERY })
   ]);
   const tables = tableRows.map((row) => row.table_name);
   const views = viewRows.map((row) => row.table_name);
@@ -2668,6 +2778,17 @@ async function introspectPostgres(params) {
         entry.columns.push(columnName);
     }
   }
+  const checksByTable = new Map;
+  for (const row of checkRows) {
+    const table = row.table_name;
+    const name = row.constraint_name;
+    const expression = stripCheckDefinition({ definition: String(row.definition ?? "") });
+    const list = checksByTable.get(table);
+    if (list === undefined)
+      checksByTable.set(table, [{ name, expression }]);
+    else
+      list.push({ name, expression });
+  }
   const fkGroupsByName = new Map;
   for (const row of fkRows) {
     const constraintName = row.constraint_name;
@@ -2727,7 +2848,8 @@ async function introspectPostgres(params) {
       uniquesByConstraint,
       constraintNames,
       indexes,
-      enumNames
+      enumNames,
+      checks: checksByTable.get(table) ?? []
     }));
   }
   for (const view of views) {
@@ -2739,7 +2861,8 @@ async function introspectPostgres(params) {
       uniquesByConstraint,
       constraintNames,
       indexes: [],
-      enumNames
+      enumNames,
+      checks: []
     }));
   }
   addFkRelations({ models, fkGroups, joinTables });
@@ -2769,8 +2892,9 @@ function buildModel(params) {
   for (const index of tableIndexes) {
     if (!index.unique)
       continue;
-    if (index.columns.length === 1)
+    if (index.columns.length === 1 && index.where === undefined && index.nullsNotDistinct !== true) {
       uniqueSingles.add(index.columns[0].name);
+    }
   }
   const fields = tableColumns.map((column) => buildField({ column, pk, uniqueSingles, enumNames }));
   const modelIndexes = [];
@@ -2782,8 +2906,9 @@ function buildModel(params) {
     });
   }
   for (const index of tableIndexes) {
-    if (index.unique && index.columns.length === 1)
+    if (index.unique && index.columns.length === 1 && index.where === undefined && index.nullsNotDistinct !== true) {
       continue;
+    }
     modelIndexes.push({
       name: index.name,
       kind: index.unique ? "unique" : index.kind,
@@ -2791,7 +2916,8 @@ function buildModel(params) {
         name: column.name,
         ...column.desc ? { sort: "desc" } : {}
       })),
-      ...index.where === undefined ? {} : { where: index.where }
+      ...index.where === undefined ? {} : { where: index.where },
+      ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {}
     });
   }
   return {
@@ -2799,10 +2925,16 @@ function buildModel(params) {
     fields,
     relations: [],
     indexes: modelIndexes,
+    ...params.checks.length === 0 ? {} : { checks: params.checks },
     isView,
     ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
   };
 }
+function stripCheckDefinition(params) {
+  const trimmed = params.definition.trim();
+  const match = trimmed.match(/^CHECK\s*\((.*)\)$/is);
+  return match === null ? trimmed : match[1].trim();
+}
 function buildField(params) {
   const { column, pk, uniqueSingles, enumNames } = params;
   const mapped = reverseMapType({ column, enumNames });
@@ -2953,7 +3085,10 @@ function parseIndexDef(params) {
     const nameOnly = trimmed.replace(/ (DESC|ASC)( NULLS (FIRST|LAST))?$/i, "");
     return { name: nameOnly.replaceAll('"', ""), desc };
   });
-  const tail = def.slice(end + 1).trim();
+  let tail = def.slice(end + 1).trim();
+  const nullsNotDistinct = /^NULLS NOT DISTINCT\b/i.test(tail);
+  if (nullsNotDistinct)
+    tail = tail.slice("NULLS NOT DISTINCT".length).trim();
   const whereMatch = tail.match(/^WHERE (.*)$/);
   const whereRaw = whereMatch?.[1];
   return {
@@ -2962,7 +3097,8 @@ function parseIndexDef(params) {
     unique: head[1] !== undefined,
     kind: head[2].toLowerCase(),
     columns,
-    ...whereRaw === undefined ? {} : { where: whereRaw }
+    ...whereRaw === undefined ? {} : { where: whereRaw },
+    ...nullsNotDistinct ? { nullsNotDistinct: true } : {}
   };
 }
 function splitTopLevel(params) {
@@ -3026,6 +3162,7 @@ async function introspectSqlite(params) {
   const indexes = [];
   const uniqueSinglesByTable = new Map;
   const modelIndexesByTable = new Map;
+  const checksByTable = new Map;
   const fkGroups = [];
   const enumsByColumn = new Map;
   const enumRegistry = new Map;
@@ -3033,15 +3170,18 @@ async function introspectSqlite(params) {
   for (const table of tables) {
     const columns = await readColumns({ executor, table: table.name });
     columnsByTable.set(table.name, columns);
+    const enumCheckNames = new Set;
     for (const check of parseSqliteEnumChecks({ tableSql: table.sql ?? "" })) {
       enumsByColumn.set(`${table.name}.${check.column}`, {
         enumName: check.enumName,
         values: check.values
       });
+      enumCheckNames.add(sqliteEnumCheckName({ table: table.name, column: check.column, enumName: check.enumName }));
       if (!enumRegistry.has(check.enumName)) {
         enumRegistry.set(check.enumName, { name: check.enumName, values: check.values });
       }
     }
+    checksByTable.set(table.name, parseSqliteNamedChecks({ tableSql: table.sql ?? "" }).filter((check) => !enumCheckNames.has(check.name)));
     if (/PRIMARY KEY AUTOINCREMENT/i.test(table.sql ?? "")) {
       autoincrementTables.add(table.name);
     }
@@ -3077,7 +3217,8 @@ async function introspectSqlite(params) {
       uniqueSingles: uniqueSinglesByTable.get(table.name) ?? new Set,
       modelIndexes: modelIndexesByTable.get(table.name) ?? [],
       enumsByColumn,
-      autoincrement: autoincrementTables.has(table.name)
+      autoincrement: autoincrementTables.has(table.name),
+      checks: checksByTable.get(table.name) ?? []
     }));
   }
   for (const view of views) {
@@ -3088,7 +3229,8 @@ async function introspectSqlite(params) {
       uniqueSingles: new Set,
       modelIndexes: [],
       enumsByColumn,
-      autoincrement: false
+      autoincrement: false,
+      checks: []
     }));
   }
   addFkRelations({ models, fkGroups, joinTables });
@@ -3289,6 +3431,7 @@ function buildModel2(params) {
     fields,
     relations: [],
     indexes: [...modelIndexes],
+    ...params.checks.length === 0 ? {} : { checks: params.checks },
     isView,
     ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
   };
@@ -3394,6 +3537,19 @@ var REFERENTIAL_QUERY = `
   FROM information_schema.referential_constraints
   WHERE constraint_schema = DATABASE();
 `;
+var CHECKS_QUERY2 = `
+  SELECT
+    tc.table_name AS table_name,
+    tc.constraint_name AS constraint_name,
+    cc.check_clause AS definition
+  FROM information_schema.table_constraints tc
+  JOIN information_schema.check_constraints cc
+    ON cc.constraint_schema = tc.constraint_schema
+   AND cc.constraint_name = tc.constraint_name
+  WHERE tc.table_schema = DATABASE()
+    AND tc.constraint_type = 'CHECK'
+  ORDER BY tc.table_name, tc.constraint_name;
+`;
 var MYSQL_RULE_TO_CASCADE = {
   "NO ACTION": "NoAction",
   RESTRICT: "Restrict",
@@ -3407,14 +3563,26 @@ function catalogField(params) {
 }
 async function introspectMysql(params) {
   const { executor } = params;
-  const [tableRows, viewRows, columnRows, statisticRows, fkRows, refRows] = await Promise.all([
+  const [tableRows, viewRows, columnRows, statisticRows, fkRows, refRows, checkRows] = await Promise.all([
     executor({ text: TABLES_QUERY2 }),
     executor({ text: VIEWS_QUERY2 }),
     executor({ text: COLUMNS_QUERY2 }),
     executor({ text: STATISTICS_QUERY }),
     executor({ text: FOREIGN_KEYS_QUERY2 }),
-    executor({ text: REFERENTIAL_QUERY })
+    executor({ text: REFERENTIAL_QUERY }),
+    executor({ text: CHECKS_QUERY2 })
   ]);
+  const checksByTable = new Map;
+  for (const row of checkRows) {
+    const table = catalogField({ row, name: "table_name" });
+    const name = catalogField({ row, name: "constraint_name" });
+    const expression = stripBalancedOuterParens(String(catalogField({ row, name: "definition" }) ?? ""));
+    const list = checksByTable.get(table);
+    if (list === undefined)
+      checksByTable.set(table, [{ name, expression }]);
+    else
+      list.push({ name, expression });
+  }
   const tables = tableRows.map((row) => catalogField({ row, name: "table_name" }));
   const views = viewRows.map((row) => catalogField({ row, name: "table_name" }));
   const columns = columnRows.map((row) => ({
@@ -3524,10 +3692,26 @@ async function introspectMysql(params) {
   for (const table of tables) {
     if (joinTables.has(table))
       continue;
-    models.push(buildModel3({ table, isView: false, columns, pkByTable, indexes, enums }));
+    models.push(buildModel3({
+      table,
+      isView: false,
+      columns,
+      pkByTable,
+      indexes,
+      enums,
+      checks: checksByTable.get(table) ?? []
+    }));
   }
   for (const view of views) {
-    models.push(buildModel3({ table: view, isView: true, columns, pkByTable: new Map, indexes: [], enums }));
+    models.push(buildModel3({
+      table: view,
+      isView: true,
+      columns,
+      pkByTable: new Map,
+      indexes: [],
+      enums,
+      checks: []
+    }));
   }
   addFkRelations({ models, fkGroups, joinTables });
   addJoinTableRelations({ models, joinTables });
@@ -3584,10 +3768,28 @@ function buildModel3(params) {
     fields,
     relations: [],
     indexes: modelIndexes,
+    ...params.checks.length === 0 ? {} : { checks: params.checks },
     isView,
     ...pk.length > 1 ? { primaryKey: { fields: pk } } : {}
   };
 }
+function stripBalancedOuterParens(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")"))
+    return trimmed;
+  let depth = 0;
+  for (let index = 0;index < trimmed.length; index++) {
+    const char = trimmed[index];
+    if (char === "(")
+      depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0 && index < trimmed.length - 1)
+        return trimmed;
+    }
+  }
+  return trimmed.slice(1, -1).trim();
+}
 var CANONICAL_MYSQL = {
   "varchar(191)": "String",
   "tinyint(1)": "Boolean",
@@ -3855,4 +4057,4 @@ export {
   MIGRATIONS_TABLE_NAME
 };
 
-//# debugId=5088DA7EA679FA1464756E2164756E21
+//# debugId=CA4C1473A398313F64756E2164756E21