tempest-db-js 0.3.0 → 0.5.0

package/dist/migrations/index.cjs

@@ -1,58 +1,162 @@
 'use strict';
 
+// src/expressions.ts
+function renderPortableToken(token, dialect) {
+  switch (token) {
+    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))))";
+  }
+}
+
 // src/index.ts
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
 }
+function bindsParameters(value) {
+  return value.kind === "expression" && typeof value.expression === "object" && "parts" in value.expression;
+}
+function parseReference(ref, options) {
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0 || dot === ref.length - 1) {
+    throw new Error(`Invalid foreign key reference "${ref}"; expected "table.column".`);
+  }
+  return {
+    table: ref.slice(0, dot),
+    column: ref.slice(dot + 1),
+    onDelete: options?.onDelete,
+    onUpdate: options?.onUpdate
+  };
+}
 var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null) {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null, dbName = null) {
     this.type = type;
     this.flags = flags;
     this.defaultValue = defaultValue;
     this.onUpdateValue = onUpdateValue;
+    this.reference = reference;
+    this.dbName = dbName;
   }
   type;
   flags;
   defaultValue;
   onUpdateValue;
-  primaryKey() {
+  reference;
+  dbName;
+  /** Clone this column with one facet replaced, carrying every other over. */
+  derive(patch) {
     return new _Column(
       this.type,
-      { ...this.flags, primaryKey: true, hasDefault: true },
-      this.defaultValue,
-      this.onUpdateValue
+      patch.flags ?? this.flags,
+      patch.defaultValue !== void 0 ? patch.defaultValue : this.defaultValue,
+      patch.onUpdateValue !== void 0 ? patch.onUpdateValue : this.onUpdateValue,
+      patch.reference !== void 0 ? patch.reference : this.reference,
+      patch.dbName !== void 0 ? patch.dbName : this.dbName
     );
   }
+  primaryKey() {
+    return this.derive({ flags: { ...this.flags, primaryKey: true, hasDefault: true } });
+  }
   notNull() {
-    return new _Column(
-      this.type,
-      { ...this.flags, notNull: true },
-      this.defaultValue,
-      this.onUpdateValue
-    );
+    return this.derive({ flags: { ...this.flags, notNull: true } });
+  }
+  /**
+   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
+   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
+   */
+  unique() {
+    return this.derive({ flags: { ...this.flags, unique: true } });
+  }
+  /**
+   * Map this property to a differently-named database column, à la SQLAlchemy's
+   * `mapped_column("consumer_name")` (Django's `db_column`, Prisma's `@map`).
+   *
+   * The override applies everywhere the name reaches SQL — select, insert,
+   * update, delete, where, order by, group by, returning, conflict targets, the
+   * migration IR and the drift check — while the TypeScript row keeps the
+   * property name. Use it to keep a `snake_case` schema behind a `camelCase`
+   * model; {@link Model.naming} does the same for a whole table at once.
+   *
+   * @param dbName The real column name in the database.
+   * @returns A new column bound to that name.
+   * @throws Error When `dbName` is empty.
+   *
+   * @example
+   * ```ts
+   * class ApiKey extends Model {
+   *   static tablename = "api_keys";
+   *   consumerName = column.text().name("consumer_name").notNull();
+   * }
+   * ```
+   */
+  name(dbName) {
+    if (dbName.length === 0) {
+      throw new Error("column.name() requires a non-empty database column name.");
+    }
+    return this.derive({ dbName });
+  }
+  /**
+   * Declare a foreign-key reference to another table's column, à la SQLAlchemy's
+   * `mapped_column(ForeignKey("table.column", ondelete=...))`. DDL-only — does
+   * not change the inferred type.
+   *
+   * @param ref The target as `"table.column"` (e.g. `"users.id"`).
+   * @param options Optional `onDelete` / `onUpdate` referential actions.
+   * @returns A new column carrying the reference.
+   * @throws Error When `ref` is not a valid `"table.column"` string.
+   */
+  references(ref, options) {
+    return this.derive({ reference: parseReference(ref, options) });
   }
   /**
    * Set the insert-time default: a constant value of type `T`, or a portable
    * server-side expression from {@link sql} (e.g. `sql.now()`, `sql.uuidv4()`).
+   *
+   * @param value The literal default, or a {@link sql} expression.
+   * @returns A new column carrying the default.
+   * @throws Error When given a `sql.expr` fragment — a `DEFAULT` clause has
+   *   nowhere to bind parameters; use `sql.raw()` for a verbatim expression.
    */
   default(value) {
     const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(
-      this.type,
-      { ...this.flags, hasDefault: true },
-      resolved,
-      this.onUpdateValue
-    );
+    if (bindsParameters(resolved)) {
+      throw new Error(
+        "sql.expr`...` binds parameters and cannot be a column default \u2014 use sql.raw() for a verbatim DEFAULT expression."
+      );
+    }
+    return this.derive({
+      flags: { ...this.flags, hasDefault: true },
+      defaultValue: resolved
+    });
   }
   /**
    * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
    * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
+   *
+   * @param value The literal value, or a {@link sql} expression.
+   * @returns A new column carrying the on-update value.
+   * @throws Error When given a `sql.expr` fragment (see {@link Column.default}).
    */
   onUpdate(value) {
     const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(this.type, this.flags, this.defaultValue, resolved);
+    if (bindsParameters(resolved)) {
+      throw new Error(
+        "sql.expr`...` binds parameters and cannot be an onUpdate default \u2014 use sql.raw() for a verbatim expression."
+      );
+    }
+    return this.derive({ onUpdateValue: resolved });
   }
 };
+function toSnakeCase(name) {
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
 var columnsCache = /* @__PURE__ */ new WeakMap();
 function columnsOf(model) {
   const cached = columnsCache.get(model);
@@ -67,23 +171,75 @@ function columnsOf(model) {
   columnsCache.set(model, out);
   return out;
 }
+var nameMapCache = /* @__PURE__ */ new WeakMap();
+function columnNamesOf(model) {
+  const cached = nameMapCache.get(model);
+  if (cached !== void 0) return cached;
+  const strategy = model.naming ?? "preserve";
+  const map = {};
+  const seen = /* @__PURE__ */ new Map();
+  let renamed = false;
+  for (const [prop, col] of Object.entries(columnsOf(model))) {
+    const dbName = col.dbName ?? (strategy === "snake_case" ? toSnakeCase(prop) : prop);
+    const collision = seen.get(dbName);
+    if (collision !== void 0) {
+      throw new Error(
+        `${model.tablename}: properties "${collision}" and "${prop}" both map to column "${dbName}".`
+      );
+    }
+    seen.set(dbName, prop);
+    map[prop] = dbName;
+    if (dbName !== prop) renamed = true;
+  }
+  const result = renamed ? map : null;
+  nameMapCache.set(model, result);
+  return result;
+}
 
 // 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 = {};
@@ -128,6 +284,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");
@@ -162,6 +322,8 @@ function renderColumnType(type, dialect) {
         return "NUMERIC";
       case "blob":
         return "BLOB";
+      case "array":
+        throw new Error(unsupportedArray("sqlite"));
       default:
         return "TEXT";
     }
@@ -203,6 +365,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) {
@@ -241,27 +405,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";
   }
@@ -270,10 +446,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) {
@@ -296,14 +509,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);
   });
@@ -312,6 +527,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)} (
@@ -345,10 +561,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);
@@ -358,6 +602,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",
@@ -410,7 +655,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;
 }
@@ -421,9 +666,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 = [];
@@ -452,6 +762,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]) {
@@ -594,6 +905,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 });
@@ -823,6 +1142,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'",
@@ -842,14 +1194,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);
@@ -887,6 +1264,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]) {
@@ -895,6 +1300,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";
@@ -942,20 +1395,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);
@@ -972,9 +1471,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) {
@@ -988,6 +1487,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]) {
@@ -1059,6 +1572,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 };
 }
@@ -1080,7 +1617,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) {