tempest-db-js 0.3.0 → 0.5.0

package/dist/{chunk-OP7FRDI5.js → chunk-EPMLFNFK.js}

@@ -1,4 +1,4 @@
-import { columnsOf } from './chunk-Q32CBI2A.js';
+import { renderPortableToken, columnNamesOf, columnsOf } from './chunk-5QQMVTS5.js';
 
 // src/migrations/operations.ts
 var IrreversibleMigration = class extends Error {
@@ -31,6 +31,10 @@ function invert(op) {
       return { kind: "rename_column", table: op.table, from: op.to, to: op.from };
     case "recreate_table":
       return { kind: "recreate_table", from: op.to, to: op.from };
+    case "add_constraint":
+      return { kind: "drop_constraint", table: op.table, constraint: op.constraint };
+    case "drop_constraint":
+      return { kind: "add_constraint", table: op.table, constraint: op.constraint };
     case "execute":
       if (op.down === null) {
         throw new IrreversibleMigration("execute() operation has no down SQL");
@@ -112,6 +116,8 @@ function renderColumnType(type, dialect) {
         return "NUMERIC";
       case "blob":
         return "BLOB";
+      case "array":
+        throw new Error(unsupportedArray("sqlite"));
       default:
         return "TEXT";
     }
@@ -153,6 +159,8 @@ function renderColumnType(type, dialect) {
         return "CHAR(36)";
       case "enum":
         return `ENUM(${(meta.values ?? []).map(quoteLiteral).join(", ")})`;
+      case "array":
+        throw new Error(unsupportedArray("mysql"));
     }
   }
   switch (kind) {
@@ -191,27 +199,39 @@ function renderColumnType(type, dialect) {
       return "UUID";
     case "enum":
       return "TEXT";
+    case "array":
+      return `${renderColumnType(arrayElement(meta.element), dialect)}[]`;
   }
 }
-function renderDefault(def, dialect) {
+function unsupportedArray(dialect) {
+  return `column.array() is PostgreSQL-only \u2014 ${dialect} has no native array type. Model the column as JSON there, accepting that array operators will not work.`;
+}
+function arrayElement(element) {
+  if (!element) {
+    throw new Error(
+      "An array column has no element type \u2014 build it with column.array()."
+    );
+  }
+  return element;
+}
+function renderDefault(def, dialect, type) {
   if (def.kind === "expression") {
     const expr = def.expression;
-    if (typeof expr === "object") return expr.raw;
-    switch (expr) {
-      case "now":
-        return dialect === "postgresql" ? "now()" : "CURRENT_TIMESTAMP";
-      case "current_date":
-        return "CURRENT_DATE";
-      case "current_time":
-        return "CURRENT_TIME";
-      case "uuidv4":
-        if (dialect === "postgresql") return "gen_random_uuid()";
-        if (dialect === "mysql") return "(UUID())";
-        return "(lower(hex(randomblob(16))))";
+    if (typeof expr === "object") {
+      if ("raw" in expr) return expr.raw;
+      throw new Error(
+        "sql.expr`...` binds parameters and cannot be rendered as a DEFAULT \u2014 use sql.raw()."
+      );
     }
+    return renderPortableToken(expr, dialect);
   }
   const value = def.value;
   if (value === null) return "NULL";
+  if (Array.isArray(value) && type?.kind === "array") {
+    const elementType = renderColumnType(arrayElement(type.meta.element), dialect);
+    const items = value.map((v) => renderDefault({ kind: "literal", value: v }, dialect));
+    return `ARRAY[${items.join(", ")}]::${elementType}[]`;
+  }
   if (typeof value === "boolean") {
     return dialect === "postgresql" ? value ? "TRUE" : "FALSE" : value ? "1" : "0";
   }
@@ -220,10 +240,47 @@ function renderDefault(def, dialect) {
   if (typeof value === "object") return quoteLiteral(JSON.stringify(value));
   return quoteLiteral(String(value));
 }
+function renderFkAction(action) {
+  return action.toUpperCase();
+}
+function renderFkActions(fk) {
+  let sql = "";
+  if (fk.onDelete) sql += ` ON DELETE ${renderFkAction(fk.onDelete)}`;
+  if (fk.onUpdate) sql += ` ON UPDATE ${renderFkAction(fk.onUpdate)}`;
+  return sql;
+}
+function columnConstraintSuffix(col, dialect) {
+  let sql = "";
+  if (col.unique) sql += " UNIQUE";
+  if (col.references) {
+    const ref = col.references;
+    sql += ` REFERENCES ${quoteId(ref.table, dialect)} (${quoteId(ref.column, dialect)})`;
+    sql += renderFkActions(ref);
+  }
+  return sql;
+}
+function renderUniqueConstraint(uc, dialect) {
+  const cols = uc.columns.map((c) => quoteId(c, dialect)).join(", ");
+  return `CONSTRAINT ${quoteId(uc.name, dialect)} UNIQUE (${cols})`;
+}
+function renderForeignKeyConstraint(fk, dialect) {
+  const cols = fk.columns.map((c) => quoteId(c, dialect)).join(", ");
+  const refCols = fk.refColumns.map((c) => quoteId(c, dialect)).join(", ");
+  return `CONSTRAINT ${quoteId(fk.name, dialect)} FOREIGN KEY (${cols}) REFERENCES ${quoteId(fk.refTable, dialect)} (${refCols})${renderFkActions(fk)}`;
+}
+function tableConstraintClauses(table, dialect) {
+  return [
+    ...table.uniqueConstraints.map((uc) => renderUniqueConstraint(uc, dialect)),
+    ...table.foreignKeys.map((fk) => renderForeignKeyConstraint(fk, dialect))
+  ];
+}
 function renderColumnDef(col, dialect) {
   let sql = `${quoteId(col.name, dialect)} ${renderColumnType(col.type, dialect)}`;
   if (col.notNull) sql += " NOT NULL";
-  if (col.default !== null) sql += ` DEFAULT ${renderDefault(col.default, dialect)}`;
+  if (col.default !== null) {
+    sql += ` DEFAULT ${renderDefault(col.default, dialect, col.type)}`;
+  }
+  sql += columnConstraintSuffix(col, dialect);
   return sql;
 }
 function enumTypeName(table, column) {
@@ -246,14 +303,16 @@ function renderCreateTable(table, dialect) {
       typeStmts.push(`CREATE TYPE ${quoteId(typeName, dialect)} AS ENUM (${values})`);
       let def = `${quoteId(c.name, dialect)} ${quoteId(typeName, dialect)}`;
       if (c.notNull) def += " NOT NULL";
-      if (c.default !== null) def += ` DEFAULT ${renderDefault(c.default, dialect)}`;
-      return def;
+      if (c.default !== null) {
+        def += ` DEFAULT ${renderDefault(c.default, dialect, c.type)}`;
+      }
+      return def + columnConstraintSuffix(c, dialect);
     }
     if (dialect === "postgresql" && isAutoIncrementPk(table, c)) {
-      return `${quoteId(c.name, dialect)} ${postgresSerialType(c.type.kind)}`;
+      return `${quoteId(c.name, dialect)} ${postgresSerialType(c.type.kind)}${columnConstraintSuffix(c, dialect)}`;
     }
     if (dialect === "mysql" && isAutoIncrementPk(table, c)) {
-      return `${quoteId(c.name, dialect)} ${renderColumnType(c.type, dialect)} NOT NULL AUTO_INCREMENT`;
+      return `${quoteId(c.name, dialect)} ${renderColumnType(c.type, dialect)} NOT NULL AUTO_INCREMENT${columnConstraintSuffix(c, dialect)}`;
     }
     return renderColumnDef(c, dialect);
   });
@@ -262,6 +321,7 @@ function renderCreateTable(table, dialect) {
       `PRIMARY KEY (${table.primaryKey.map((c) => quoteId(c, dialect)).join(", ")})`
     );
   }
+  cols.push(...tableConstraintClauses(table, dialect));
   return [
     ...typeStmts,
     `CREATE TABLE ${quoteId(table.name, dialect)} (
@@ -295,10 +355,38 @@ function renderOperation(op, dialect) {
       return renderAlterColumn(op.table, op.to, dialect);
     case "recreate_table":
       return dialect === "sqlite" ? renderSqliteRebuild(op.from, op.to) : renderTableDiff(op.from, op.to, dialect);
+    case "add_constraint":
+      return renderAddConstraint(op.table, op.constraint, dialect);
+    case "drop_constraint":
+      return renderDropConstraint(op.table, op.constraint, dialect);
     case "execute":
       return [op.up];
   }
 }
+function renderAddConstraint(table, constraint, dialect) {
+  if (dialect === "sqlite") {
+    throw new Error(
+      `add_constraint on SQLite needs a table-rebuild (recreate_table); constraint ${constraint.constraint.name} on ${table}`
+    );
+  }
+  const clause = constraint.type === "unique" ? renderUniqueConstraint(constraint.constraint, dialect) : renderForeignKeyConstraint(constraint.constraint, dialect);
+  return [`ALTER TABLE ${quoteId(table, dialect)} ADD ${clause}`];
+}
+function renderDropConstraint(table, constraint, dialect) {
+  if (dialect === "sqlite") {
+    throw new Error(
+      `drop_constraint on SQLite needs a table-rebuild (recreate_table); constraint ${constraint.constraint.name} on ${table}`
+    );
+  }
+  const t = quoteId(table, dialect);
+  const name = quoteId(constraint.constraint.name, dialect);
+  if (dialect === "mysql") {
+    return [
+      constraint.type === "unique" ? `ALTER TABLE ${t} DROP INDEX ${name}` : `ALTER TABLE ${t} DROP FOREIGN KEY ${name}`
+    ];
+  }
+  return [`ALTER TABLE ${t} DROP CONSTRAINT ${name}`];
+}
 function renderSqliteRebuild(from, to) {
   const tmp = `__new_${to.name}`;
   const common = Object.keys(to.columns).filter((c) => c in from.columns);
@@ -308,6 +396,7 @@ function renderSqliteRebuild(from, to) {
       `PRIMARY KEY (${to.primaryKey.map((c) => quoteId(c, "sqlite")).join(", ")})`
     );
   }
+  cols.push(...tableConstraintClauses(to, "sqlite"));
   const commonSql = common.map((c) => quoteId(c, "sqlite")).join(", ");
   return [
     "PRAGMA foreign_keys=off",
@@ -360,7 +449,7 @@ function renderAlterColumn(table, to, dialect) {
     to.notNull ? `ALTER TABLE ${t} ALTER COLUMN ${c} SET NOT NULL` : `ALTER TABLE ${t} ALTER COLUMN ${c} DROP NOT NULL`
   );
   stmts.push(
-    to.default !== null ? `ALTER TABLE ${t} ALTER COLUMN ${c} SET DEFAULT ${renderDefault(to.default, dialect)}` : `ALTER TABLE ${t} ALTER COLUMN ${c} DROP DEFAULT`
+    to.default !== null ? `ALTER TABLE ${t} ALTER COLUMN ${c} SET DEFAULT ${renderDefault(to.default, dialect, to.type)}` : `ALTER TABLE ${t} ALTER COLUMN ${c} DROP DEFAULT`
   );
   return stmts;
 }
@@ -371,9 +460,74 @@ function columnSignature(col) {
     type: col.type,
     notNull: col.notNull,
     primaryKey: col.primaryKey,
-    default: col.default
+    default: col.default,
+    unique: col.unique,
+    references: col.references
   });
 }
+function uniqueSignature(uc) {
+  return JSON.stringify({ columns: uc.columns });
+}
+function foreignKeySignature(fk) {
+  return JSON.stringify({
+    columns: fk.columns,
+    refTable: fk.refTable,
+    refColumns: fk.refColumns,
+    onDelete: fk.onDelete ?? null,
+    onUpdate: fk.onUpdate ?? null
+  });
+}
+function diffConstraints(current, target) {
+  const ops = [];
+  const table = target.name;
+  const currentUq = new Map(current.uniqueConstraints.map((u) => [u.name, u]));
+  const targetUq = new Map(target.uniqueConstraints.map((u) => [u.name, u]));
+  for (const [name, cur] of currentUq) {
+    const tgt = targetUq.get(name);
+    if (!tgt || uniqueSignature(cur) !== uniqueSignature(tgt)) {
+      ops.push(dropUnique(table, cur));
+    }
+  }
+  for (const [name, tgt] of targetUq) {
+    const cur = currentUq.get(name);
+    if (!cur || uniqueSignature(cur) !== uniqueSignature(tgt)) {
+      ops.push(addUnique(table, tgt));
+    }
+  }
+  const currentFk = new Map(current.foreignKeys.map((f) => [f.name, f]));
+  const targetFk = new Map(target.foreignKeys.map((f) => [f.name, f]));
+  for (const [name, cur] of currentFk) {
+    const tgt = targetFk.get(name);
+    if (!tgt || foreignKeySignature(cur) !== foreignKeySignature(tgt)) {
+      ops.push(dropForeignKey(table, cur));
+    }
+  }
+  for (const [name, tgt] of targetFk) {
+    const cur = currentFk.get(name);
+    if (!cur || foreignKeySignature(cur) !== foreignKeySignature(tgt)) {
+      ops.push(addForeignKey(table, tgt));
+    }
+  }
+  return ops;
+}
+function uniqueNamed(uc) {
+  return { type: "unique", constraint: uc };
+}
+function foreignKeyNamed(fk) {
+  return { type: "foreignKey", constraint: fk };
+}
+function addUnique(table, uc) {
+  return { kind: "add_constraint", table, constraint: uniqueNamed(uc) };
+}
+function dropUnique(table, uc) {
+  return { kind: "drop_constraint", table, constraint: uniqueNamed(uc) };
+}
+function addForeignKey(table, fk) {
+  return { kind: "add_constraint", table, constraint: foreignKeyNamed(fk) };
+}
+function dropForeignKey(table, fk) {
+  return { kind: "drop_constraint", table, constraint: foreignKeyNamed(fk) };
+}
 function diffSchema(current, target) {
   const ops = [];
   const drops = [];
@@ -402,6 +556,7 @@ function diffSchema(current, target) {
         ops.push({ kind: "drop_column", table: name, column: currentCol });
       }
     }
+    ops.push(...diffConstraints(currentTable, targetTable));
   }
   for (const [name, currentTable] of Object.entries(current.tables)) {
     if (!target.tables[name]) {
@@ -466,21 +621,49 @@ function heads(migrations) {
 }
 
 // src/migrations/ir.ts
+function constraintName(prefix, table, columns) {
+  return `${prefix}_${table}_${columns.join("_")}`;
+}
 function reflectTable(model) {
+  const names = columnNamesOf(model);
+  const toColumn = (prop) => names?.[prop] ?? prop;
   const columns = {};
   const primaryKey = [];
-  for (const [name, col] of Object.entries(columnsOf(model))) {
+  for (const [prop, col] of Object.entries(columnsOf(model))) {
     const isPk = col.flags.primaryKey;
+    const name = toColumn(prop);
     columns[name] = {
       name,
       type: col.type,
       notNull: col.flags.notNull || isPk,
       primaryKey: isPk,
-      default: col.defaultValue
+      default: col.defaultValue,
+      unique: col.flags.unique,
+      references: col.reference
     };
     if (isPk) primaryKey.push(name);
   }
-  return { name: model.tablename, columns, primaryKey };
+  const uniqueConstraints = [];
+  const foreignKeys = [];
+  for (const c of model.tableArgs?.() ?? []) {
+    const cols = c.columns.map(toColumn);
+    if (c.kind === "unique") {
+      uniqueConstraints.push({
+        name: c.name ?? constraintName("uq", model.tablename, cols),
+        columns: cols
+      });
+    } else {
+      foreignKeys.push({
+        name: c.name ?? constraintName("fk", model.tablename, cols),
+        columns: cols,
+        refTable: c.refTable,
+        refColumns: c.refColumns,
+        onDelete: c.onDelete,
+        onUpdate: c.onUpdate
+      });
+    }
+  }
+  return { name: model.tablename, columns, primaryKey, uniqueConstraints, foreignKeys };
 }
 function reflectSchema(models) {
   const tables = {};
@@ -517,6 +700,39 @@ function affinityToKind(affinity) {
       return "text";
   }
 }
+function sqliteForeignKeys(driver, table) {
+  const rows = driver.execute(`PRAGMA foreign_key_list(${JSON.stringify(table)})`, []).rows;
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const list = byId.get(r.id) ?? [];
+    list.push(r);
+    byId.set(r.id, list);
+  }
+  const fks = [];
+  for (const group of byId.values()) {
+    const ordered = [...group].sort((a, b) => a.seq - b.seq);
+    const columns = ordered.map((r) => r.from);
+    fks.push({
+      name: `fk_${table}_${columns.join("_")}`,
+      columns,
+      refTable: ordered[0]?.table ?? "",
+      refColumns: ordered.map((r) => r.to)
+    });
+  }
+  return fks;
+}
+function sqliteUniques(driver, table) {
+  const indexes = driver.execute(`PRAGMA index_list(${JSON.stringify(table)})`, []).rows;
+  const uniques = [];
+  for (const idx of indexes) {
+    if (Number(idx.unique) !== 1 || idx.origin === "pk") continue;
+    const cols = driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, []).rows.sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+    if (cols.length > 0) {
+      uniques.push({ name: `uq_${table}_${cols.join("_")}`, columns: cols });
+    }
+  }
+  return uniques;
+}
 function introspectSqlite(driver) {
   const tablesRows = driver.execute(
     "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name != 'tempest_db_js_migrations'",
@@ -536,14 +752,39 @@ function introspectSqlite(driver) {
         type: { kind: affinityToKind(affinity), meta: {} },
         notNull: Number(col.notnull) === 1 || isPk,
         primaryKey: isPk,
-        default: null
+        default: null,
+        unique: false,
+        references: null
       };
       if (isPk) primaryKey.push(col.name);
     }
-    tables[tableName] = { name: tableName, columns, primaryKey };
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      primaryKey,
+      uniqueConstraints: sqliteUniques(driver, tableName),
+      foreignKeys: sqliteForeignKeys(driver, tableName)
+    };
   }
   return { tables };
 }
+function constraintKeys(table) {
+  const fks = /* @__PURE__ */ new Set();
+  const uniques = /* @__PURE__ */ new Set();
+  for (const col of Object.values(table.columns)) {
+    if (col.unique) uniques.add(col.name);
+    if (col.references) {
+      fks.add(`${col.name}=>${col.references.table}(${col.references.column})`);
+    }
+  }
+  for (const uc of table.uniqueConstraints) {
+    uniques.add([...uc.columns].sort().join(","));
+  }
+  for (const fk of table.foreignKeys) {
+    fks.add(`${fk.columns.join(",")}=>${fk.refTable}(${fk.refColumns.join(",")})`);
+  }
+  return { fks, uniques };
+}
 function checkDrift(driver, models) {
   const actual = introspectSqlite(driver);
   const expected = reflectSchema(models);
@@ -581,6 +822,34 @@ function checkDrift(driver, models) {
         );
       }
     }
+    const expectedKeys = constraintKeys(expectedTable);
+    const actualKeys = constraintKeys(actualTable);
+    for (const fk of expectedKeys.fks) {
+      if (!actualKeys.fks.has(fk)) {
+        issues.push(`foreign key "${tableName}: ${fk}" is missing from the database`);
+      }
+    }
+    for (const fk of actualKeys.fks) {
+      if (!expectedKeys.fks.has(fk)) {
+        issues.push(
+          `foreign key "${tableName}: ${fk}" exists in the database but not in the model`
+        );
+      }
+    }
+    for (const uq of expectedKeys.uniques) {
+      if (!actualKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" is missing from the database`
+        );
+      }
+    }
+    for (const uq of actualKeys.uniques) {
+      if (!expectedKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" exists in the database but not in the model`
+        );
+      }
+    }
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -589,6 +858,54 @@ function checkDrift(driver, models) {
   }
   return issues;
 }
+function pgTypeToColumnType(dataType, udtName) {
+  if (dataType.toLowerCase() === "array") {
+    return {
+      kind: "array",
+      meta: { element: { kind: pgUdtToKind(udtName.replace(/^_/, "")), meta: {} } }
+    };
+  }
+  return { kind: pgTypeToKind(dataType, udtName), meta: {} };
+}
+function pgUdtToKind(udtName) {
+  switch (udtName) {
+    case "int2":
+      return "smallint";
+    case "int4":
+      return "integer";
+    case "int8":
+      return "bigint";
+    case "float4":
+      return "real";
+    case "float8":
+      return "double";
+    case "numeric":
+      return "numeric";
+    case "varchar":
+      return "varchar";
+    case "bpchar":
+      return "char";
+    case "bool":
+      return "boolean";
+    case "date":
+      return "date";
+    case "time":
+    case "timetz":
+      return "time";
+    case "timestamp":
+    case "timestamptz":
+      return "timestamp";
+    case "bytea":
+      return "blob";
+    case "json":
+    case "jsonb":
+      return "json";
+    case "uuid":
+      return "uuid";
+    default:
+      return "text";
+  }
+}
 function pgTypeToKind(dataType, udtName) {
   const t = dataType.toLowerCase();
   if (t === "user-defined") return "enum";
@@ -636,20 +953,66 @@ async function introspectPostgres(driver) {
       const isPk = pkSet.has(name);
       columns[name] = {
         name,
-        type: {
-          kind: pgTypeToKind(String(col.data_type), String(col.udt_name)),
-          meta: {}
-        },
+        type: pgTypeToColumnType(String(col.data_type), String(col.udt_name)),
         notNull: col.is_nullable === "NO" || isPk,
         primaryKey: isPk,
-        default: null
+        default: null,
+        unique: false,
+        references: null
       };
       if (isPk) primaryKey.push(name);
     }
-    tables[tableName] = { name: tableName, columns, primaryKey };
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      primaryKey,
+      uniqueConstraints: await postgresUniques(driver, tableName),
+      foreignKeys: await postgresForeignKeys(driver, tableName)
+    };
   }
   return { tables };
 }
+async function postgresForeignKeys(driver, table) {
+  const result = await driver.execute(
+    `SELECT c.conname AS name,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols,
+            cf.relname AS ref_table,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.confkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.confrelid AND a.attnum = k.attnum) AS ref_cols
+       FROM pg_constraint c
+       JOIN pg_class cf ON cf.oid = c.confrelid
+      WHERE c.contype = 'f' AND c.conrelid = $1::regclass`,
+    [table]
+  );
+  return result.rows.map((r) => ({
+    name: String(r.name),
+    columns: r.cols ?? [],
+    refTable: String(r.ref_table),
+    refColumns: r.ref_cols ?? []
+  }));
+}
+async function postgresUniques(driver, table) {
+  const result = await driver.execute(
+    `SELECT c.conname AS name,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols
+       FROM pg_constraint c
+      WHERE c.contype = 'u' AND c.conrelid = $1::regclass`,
+    [table]
+  );
+  return result.rows.map((r) => ({
+    name: String(r.name),
+    columns: r.cols ?? []
+  }));
+}
+function describeKind(type) {
+  if (type.kind !== "array") return type.kind;
+  return `${type.meta.element ? describeKind(type.meta.element) : "unknown"}[]`;
+}
 async function checkDriftPostgres(driver, models) {
   const actual = await introspectPostgres(driver);
   const expected = reflectSchema(models);
@@ -666,9 +1029,9 @@ async function checkDriftPostgres(driver, models) {
         issues.push(`column "${tableName}.${colName}" is missing from the database`);
         continue;
       }
-      if (expectedCol.type.kind !== actualCol.type.kind) {
+      if (describeKind(expectedCol.type) !== describeKind(actualCol.type)) {
         issues.push(
-          `column "${tableName}.${colName}" type differs: model ${expectedCol.type.kind}, db ${actualCol.type.kind}`
+          `column "${tableName}.${colName}" type differs: model ${describeKind(expectedCol.type)}, db ${describeKind(actualCol.type)}`
         );
       }
       if (expectedCol.notNull !== actualCol.notNull) {
@@ -682,6 +1045,20 @@ async function checkDriftPostgres(driver, models) {
         );
       }
     }
+    const expectedKeys = constraintKeys(expectedTable);
+    const actualKeys = constraintKeys(actualTable);
+    for (const fk of expectedKeys.fks) {
+      if (!actualKeys.fks.has(fk)) {
+        issues.push(`foreign key "${tableName}: ${fk}" is missing from the database`);
+      }
+    }
+    for (const uq of expectedKeys.uniques) {
+      if (!actualKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" is missing from the database`
+        );
+      }
+    }
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -697,7 +1074,9 @@ function columnShape(col) {
     type: col.type,
     notNull: col.notNull,
     primaryKey: col.primaryKey,
-    default: col.default
+    default: col.default,
+    unique: col.unique,
+    references: col.references
   });
 }
 function tableShape(columns) {
@@ -816,6 +1195,14 @@ var Op = class {
   recreateTable(from, to) {
     this.run({ kind: "recreate_table", from, to });
   }
+  /** Add a table-level unique / foreign-key constraint. */
+  addConstraint(table, constraint) {
+    this.run({ kind: "add_constraint", table, constraint });
+  }
+  /** Drop a table-level unique / foreign-key constraint. */
+  dropConstraint(table, constraint) {
+    this.run({ kind: "drop_constraint", table, constraint });
+  }
   /** Raw SQL escape hatch (e.g. a data migration). `down` may be `null`. */
   execute(up, down = null) {
     this.run({ kind: "execute", up, down });
@@ -1084,6 +1471,30 @@ function applyOperation(schema, op) {
       }
       break;
     }
+    case "add_constraint": {
+      const t = tables[op.table];
+      if (t) {
+        tables[op.table] = op.constraint.type === "unique" ? {
+          ...t,
+          uniqueConstraints: [...t.uniqueConstraints, op.constraint.constraint]
+        } : { ...t, foreignKeys: [...t.foreignKeys, op.constraint.constraint] };
+      }
+      break;
+    }
+    case "drop_constraint": {
+      const t = tables[op.table];
+      if (t) {
+        const dropName = op.constraint.constraint.name;
+        tables[op.table] = op.constraint.type === "unique" ? {
+          ...t,
+          uniqueConstraints: t.uniqueConstraints.filter((u) => u.name !== dropName)
+        } : {
+          ...t,
+          foreignKeys: t.foreignKeys.filter((f) => f.name !== dropName)
+        };
+      }
+      break;
+    }
   }
   return { tables };
 }
@@ -1221,5 +1632,5 @@ function runMigrationCli(argv, config) {
 }
 
 export { AsyncMigrationRunner, CyclicMigrationGraph, IrreversibleMigration, MigrationRunner, Op, UnknownRevision, applyOperation, applyRenames, checkDrift, checkDriftPostgres, defineMigrationConfig, detectRenames, diffSchema, emptySchema, generateMigration, heads, introspectPostgres, introspectSqlite, invert, invertAll, makeRevisionId, reflectSchema, reflectTable, renderColumnDef, renderColumnType, renderDefault, renderOperation, replaySchema, runMigrationCli, sqliteAffinity, topoOrder };
-//# sourceMappingURL=chunk-OP7FRDI5.js.map
-//# sourceMappingURL=chunk-OP7FRDI5.js.map
+//# sourceMappingURL=chunk-EPMLFNFK.js.map
+//# sourceMappingURL=chunk-EPMLFNFK.js.map