tempest-db-js 0.2.0 → 0.4.0

package/dist/migrations/index.cjs

@@ -4,23 +4,38 @@
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "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) {
     this.type = type;
     this.flags = flags;
     this.defaultValue = defaultValue;
     this.onUpdateValue = onUpdateValue;
+    this.reference = reference;
   }
   type;
   flags;
   defaultValue;
   onUpdateValue;
+  reference;
   primaryKey() {
     return new _Column(
       this.type,
       { ...this.flags, primaryKey: true, hasDefault: true },
       this.defaultValue,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
     );
   }
   notNull() {
@@ -28,7 +43,40 @@ var Column = class _Column {
       this.type,
       { ...this.flags, notNull: true },
       this.defaultValue,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
+    );
+  }
+  /**
+   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
+   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
+   */
+  unique() {
+    return new _Column(
+      this.type,
+      { ...this.flags, unique: true },
+      this.defaultValue,
+      this.onUpdateValue,
+      this.reference
+    );
+  }
+  /**
+   * 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 new _Column(
+      this.type,
+      this.flags,
+      this.defaultValue,
+      this.onUpdateValue,
+      parseReference(ref, options)
     );
   }
   /**
@@ -41,7 +89,8 @@ var Column = class _Column {
       this.type,
       { ...this.flags, hasDefault: true },
       resolved,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
     );
   }
   /**
@@ -50,7 +99,7 @@ var Column = class _Column {
    */
   onUpdate(value) {
     const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(this.type, this.flags, this.defaultValue, resolved);
+    return new _Column(this.type, this.flags, this.defaultValue, resolved, this.reference);
   }
 };
 var columnsCache = /* @__PURE__ */ new WeakMap();
@@ -69,6 +118,9 @@ function columnsOf(model) {
 }
 
 // src/migrations/ir.ts
+function constraintName(prefix, table, columns) {
+  return `${prefix}_${table}_${columns.join("_")}`;
+}
 function reflectTable(model) {
   const columns = {};
   const primaryKey = [];
@@ -79,11 +131,32 @@ function reflectTable(model) {
       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?.() ?? []) {
+    if (c.kind === "unique") {
+      uniqueConstraints.push({
+        name: c.name ?? constraintName("uq", model.tablename, c.columns),
+        columns: c.columns
+      });
+    } else {
+      foreignKeys.push({
+        name: c.name ?? constraintName("fk", model.tablename, c.columns),
+        columns: c.columns,
+        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 +201,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");
@@ -140,8 +217,8 @@ function invertAll(ops) {
 }
 
 // src/migrations/ddl.ts
-function quoteId(name) {
-  return `"${name.replace(/"/g, '""')}"`;
+function quoteId(name, dialect) {
+  return dialect === "mysql" ? `\`${name.replace(/`/g, "``")}\`` : `"${name.replace(/"/g, '""')}"`;
 }
 function quoteLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
@@ -166,6 +243,45 @@ function renderColumnType(type, dialect) {
         return "TEXT";
     }
   }
+  if (dialect === "mysql") {
+    switch (kind) {
+      case "smallint":
+        return "SMALLINT";
+      case "integer":
+        return "INT";
+      case "bigint":
+        return "BIGINT";
+      case "numeric":
+        return meta.precision !== void 0 ? `DECIMAL(${meta.precision}${meta.scale !== void 0 ? `, ${meta.scale}` : ""})` : "DECIMAL";
+      case "real":
+        return "FLOAT";
+      case "double":
+        return "DOUBLE";
+      case "varchar":
+        return `VARCHAR(${meta.length ?? 255})`;
+      case "char":
+        return `CHAR(${meta.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "boolean":
+        return "TINYINT(1)";
+      case "date":
+        return "DATE";
+      case "time":
+        return "TIME";
+      case "datetime":
+      case "timestamp":
+        return "DATETIME";
+      case "blob":
+        return "BLOB";
+      case "json":
+        return "JSON";
+      case "uuid":
+        return "CHAR(36)";
+      case "enum":
+        return `ENUM(${(meta.values ?? []).map(quoteLiteral).join(", ")})`;
+    }
+  }
   switch (kind) {
     case "smallint":
       return "SMALLINT";
@@ -210,29 +326,66 @@ function renderDefault(def, dialect) {
     if (typeof expr === "object") return expr.raw;
     switch (expr) {
       case "now":
-        return dialect === "sqlite" ? "CURRENT_TIMESTAMP" : "now()";
+        return dialect === "postgresql" ? "now()" : "CURRENT_TIMESTAMP";
       case "current_date":
         return "CURRENT_DATE";
       case "current_time":
         return "CURRENT_TIME";
       case "uuidv4":
-        return dialect === "sqlite" ? "(lower(hex(randomblob(16))))" : "gen_random_uuid()";
+        if (dialect === "postgresql") return "gen_random_uuid()";
+        if (dialect === "mysql") return "(UUID())";
+        return "(lower(hex(randomblob(16))))";
     }
   }
   const value = def.value;
   if (value === null) return "NULL";
   if (typeof value === "boolean") {
-    return dialect === "sqlite" ? value ? "1" : "0" : value ? "TRUE" : "FALSE";
+    return dialect === "postgresql" ? value ? "TRUE" : "FALSE" : value ? "1" : "0";
   }
   if (typeof value === "number" || typeof value === "bigint") return String(value);
   if (value instanceof Date) return quoteLiteral(value.toISOString());
   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)} ${renderColumnType(col.type, 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)}`;
+  sql += columnConstraintSuffix(col, dialect);
   return sql;
 }
 function enumTypeName(table, column) {
@@ -252,23 +405,29 @@ function renderCreateTable(table, dialect) {
     if (dialect === "postgresql" && c.type.kind === "enum") {
       const typeName = enumTypeName(table.name, c.name);
       const values = (c.type.meta.values ?? []).map(quoteLiteral).join(", ");
-      typeStmts.push(`CREATE TYPE ${quoteId(typeName)} AS ENUM (${values})`);
-      let def = `${quoteId(c.name)} ${quoteId(typeName)}`;
+      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;
+      return def + columnConstraintSuffix(c, dialect);
     }
     if (dialect === "postgresql" && isAutoIncrementPk(table, c)) {
-      return `${quoteId(c.name)} ${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${columnConstraintSuffix(c, dialect)}`;
     }
     return renderColumnDef(c, dialect);
   });
   if (table.primaryKey.length > 0) {
-    cols.push(`PRIMARY KEY (${table.primaryKey.map(quoteId).join(", ")})`);
+    cols.push(
+      `PRIMARY KEY (${table.primaryKey.map((c) => quoteId(c, dialect)).join(", ")})`
+    );
   }
+  cols.push(...tableConstraintClauses(table, dialect));
   return [
     ...typeStmts,
-    `CREATE TABLE ${quoteId(table.name)} (
+    `CREATE TABLE ${quoteId(table.name, dialect)} (
   ${cols.join(",\n  ")}
 )`
   ];
@@ -278,60 +437,97 @@ function renderOperation(op, dialect) {
     case "create_table":
       return renderCreateTable(op.table, dialect);
     case "drop_table":
-      return [`DROP TABLE ${quoteId(op.table.name)}`];
+      return [`DROP TABLE ${quoteId(op.table.name, dialect)}`];
     case "rename_table":
-      return [`ALTER TABLE ${quoteId(op.from)} RENAME TO ${quoteId(op.to)}`];
+      return dialect === "mysql" ? [`RENAME TABLE ${quoteId(op.from, dialect)} TO ${quoteId(op.to, dialect)}`] : [
+        `ALTER TABLE ${quoteId(op.from, dialect)} RENAME TO ${quoteId(op.to, dialect)}`
+      ];
     case "add_column":
       return [
-        `ALTER TABLE ${quoteId(op.table)} ADD COLUMN ${renderColumnDef(op.column, dialect)}`
+        `ALTER TABLE ${quoteId(op.table, dialect)} ADD COLUMN ${renderColumnDef(op.column, dialect)}`
       ];
     case "drop_column":
-      return [`ALTER TABLE ${quoteId(op.table)} DROP COLUMN ${quoteId(op.column.name)}`];
+      return [
+        `ALTER TABLE ${quoteId(op.table, dialect)} DROP COLUMN ${quoteId(op.column.name, dialect)}`
+      ];
     case "rename_column":
       return [
-        `ALTER TABLE ${quoteId(op.table)} RENAME COLUMN ${quoteId(op.from)} TO ${quoteId(op.to)}`
+        `ALTER TABLE ${quoteId(op.table, dialect)} RENAME COLUMN ${quoteId(op.from, dialect)} TO ${quoteId(op.to, dialect)}`
       ];
     case "alter_column":
       return renderAlterColumn(op.table, op.to, dialect);
     case "recreate_table":
-      return dialect === "sqlite" ? renderSqliteRebuild(op.from, op.to) : renderPostgresTableDiff(op.from, op.to);
+      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);
   const cols = Object.values(to.columns).map((c) => renderColumnDef(c, "sqlite"));
   if (to.primaryKey.length > 0) {
-    cols.push(`PRIMARY KEY (${to.primaryKey.map(quoteId).join(", ")})`);
+    cols.push(
+      `PRIMARY KEY (${to.primaryKey.map((c) => quoteId(c, "sqlite")).join(", ")})`
+    );
   }
-  const commonSql = common.map(quoteId).join(", ");
+  cols.push(...tableConstraintClauses(to, "sqlite"));
+  const commonSql = common.map((c) => quoteId(c, "sqlite")).join(", ");
   return [
     "PRAGMA foreign_keys=off",
-    `CREATE TABLE ${quoteId(tmp)} (
+    `CREATE TABLE ${quoteId(tmp, "sqlite")} (
   ${cols.join(",\n  ")}
 )`,
-    common.length > 0 ? `INSERT INTO ${quoteId(tmp)} (${commonSql}) SELECT ${commonSql} FROM ${quoteId(from.name)}` : `-- no common columns to copy from ${from.name}`,
-    `DROP TABLE ${quoteId(from.name)}`,
-    `ALTER TABLE ${quoteId(tmp)} RENAME TO ${quoteId(to.name)}`,
+    common.length > 0 ? `INSERT INTO ${quoteId(tmp, "sqlite")} (${commonSql}) SELECT ${commonSql} FROM ${quoteId(from.name, "sqlite")}` : `-- no common columns to copy from ${from.name}`,
+    `DROP TABLE ${quoteId(from.name, "sqlite")}`,
+    `ALTER TABLE ${quoteId(tmp, "sqlite")} RENAME TO ${quoteId(to.name, "sqlite")}`,
     "PRAGMA foreign_keys=on"
   ];
 }
-function renderPostgresTableDiff(from, to) {
+function renderTableDiff(from, to, dialect) {
   const stmts = [];
   for (const [name, col] of Object.entries(to.columns)) {
     if (!(name in from.columns)) {
       stmts.push(
-        `ALTER TABLE ${quoteId(to.name)} ADD COLUMN ${renderColumnDef(col, "postgresql")}`
+        `ALTER TABLE ${quoteId(to.name, dialect)} ADD COLUMN ${renderColumnDef(col, dialect)}`
       );
     } else {
-      stmts.push(...renderAlterColumn(to.name, col, "postgresql"));
+      stmts.push(...renderAlterColumn(to.name, col, dialect));
     }
   }
   for (const name of Object.keys(from.columns)) {
     if (!(name in to.columns)) {
-      stmts.push(`ALTER TABLE ${quoteId(to.name)} DROP COLUMN ${quoteId(name)}`);
+      stmts.push(
+        `ALTER TABLE ${quoteId(to.name, dialect)} DROP COLUMN ${quoteId(name, dialect)}`
+      );
     }
   }
   return stmts;
@@ -339,11 +535,16 @@ function renderPostgresTableDiff(from, to) {
 function renderAlterColumn(table, to, dialect) {
   if (dialect === "sqlite") {
     throw new Error(
-      `alter_column on SQLite needs batch/table-rebuild (Phase 6e); column ${table}.${to.name}`
+      `alter_column on SQLite needs a table-rebuild (recreate_table); column ${table}.${to.name}`
     );
   }
-  const t = quoteId(table);
-  const c = quoteId(to.name);
+  if (dialect === "mysql") {
+    return [
+      `ALTER TABLE ${quoteId(table, dialect)} MODIFY COLUMN ${renderColumnDef(to, dialect)}`
+    ];
+  }
+  const t = quoteId(table, dialect);
+  const c = quoteId(to.name, dialect);
   const stmts = [
     `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE ${renderColumnType(to.type, dialect)}`
   ];
@@ -362,9 +563,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 = [];
@@ -393,6 +659,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]) {
@@ -535,6 +802,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 });
@@ -634,6 +909,112 @@ var MigrationRunner = class {
     return reverted;
   }
 };
+function quoteIdent(name, dialect) {
+  return dialect === "mysql" ? `\`${name.replace(/`/g, "``")}\`` : `"${name.replace(/"/g, '""')}"`;
+}
+function placeholder(index, dialect) {
+  return dialect === "postgresql" ? `$${index}` : "?";
+}
+var AsyncMigrationRunner = class {
+  constructor(driver, dialect) {
+    this.driver = driver;
+    this.dialect = dialect;
+    this.vt = quoteIdent(VERSION_TABLE, dialect);
+  }
+  driver;
+  dialect;
+  vt;
+  /** Create the version-tracking table if it does not exist. */
+  async ensureVersionTable() {
+    await this.driver.execute(
+      `CREATE TABLE IF NOT EXISTS ${this.vt} (revision ${this.textType()} PRIMARY KEY, applied_at ${this.textType()} NOT NULL, down_revision ${this.textType()} NOT NULL)`,
+      []
+    );
+  }
+  /** A portable "text" column type for the version table. */
+  textType() {
+    return this.dialect === "mysql" ? "VARCHAR(255)" : "TEXT";
+  }
+  /** The set of applied revision ids. */
+  async applied() {
+    await this.ensureVersionTable();
+    const { rows } = await this.driver.execute(`SELECT revision FROM ${this.vt}`, []);
+    return new Set(rows.map((r) => String(r.revision)));
+  }
+  async runOps(ops) {
+    for (const op of ops) {
+      for (const stmt of renderOperation(op, this.dialect)) {
+        const trimmed = stmt.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("--")) continue;
+        await this.driver.execute(stmt, []);
+      }
+    }
+  }
+  async record(migration, appliedAt) {
+    const p = (i) => placeholder(i, this.dialect);
+    await this.driver.execute(
+      `INSERT INTO ${this.vt} (revision, applied_at, down_revision) VALUES (${p(1)}, ${p(2)}, ${p(3)})`,
+      [migration.revision, appliedAt, migration.downRevision.join(",")]
+    );
+  }
+  async forget(revision) {
+    await this.driver.execute(
+      `DELETE FROM ${this.vt} WHERE revision = ${placeholder(1, this.dialect)}`,
+      [revision]
+    );
+  }
+  /**
+   * Apply all pending migrations up to the head(s), in DAG order.
+   *
+   * @param migrations All known migrations.
+   * @param appliedAt Timestamp string to stamp on each applied revision.
+   * @returns The revision ids that were applied this run.
+   */
+  async upgrade(migrations, appliedAt) {
+    const done = await this.applied();
+    const ordered = topoOrder(migrations);
+    const ran = [];
+    for (const migration of ordered) {
+      if (done.has(migration.revision)) continue;
+      const op = new Op();
+      migration.up(op);
+      await this.runOps(op.operations);
+      await this.record(migration, appliedAt);
+      ran.push(migration.revision);
+    }
+    return ran;
+  }
+  /**
+   * Revert the last `steps` applied migrations (default 1), newest first.
+   *
+   * @param migrations All known migrations.
+   * @param steps How many applied revisions to roll back.
+   * @returns The revision ids that were reverted.
+   */
+  async downgrade(migrations, steps = 1) {
+    const done = await this.applied();
+    const ordered = topoOrder(migrations).filter((m) => done.has(m.revision));
+    const toRevert = ordered.slice(-steps).reverse();
+    const reverted = [];
+    for (const migration of toRevert) {
+      const op = new Op();
+      try {
+        migration.down(op);
+      } catch {
+        op.operations.length = 0;
+      }
+      if (op.operations.length === 0) {
+        const upOp = new Op();
+        migration.up(upOp);
+        op.operations.push(...invertAll(upOp.operations));
+      }
+      await this.runOps(op.operations);
+      await this.forget(migration.revision);
+      reverted.push(migration.revision);
+    }
+    return reverted;
+  }
+};
 
 // src/migrations/introspect.ts
 function sqliteAffinity(declared) {
@@ -658,6 +1039,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'",
@@ -677,14 +1091,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);
@@ -722,6 +1161,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]) {
@@ -783,14 +1250,59 @@ async function introspectPostgres(driver) {
         },
         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 ?? []
+  }));
+}
 async function checkDriftPostgres(driver, models) {
   const actual = await introspectPostgres(driver);
   const expected = reflectSchema(models);
@@ -823,6 +1335,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]) {
@@ -894,6 +1420,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 };
 }
@@ -915,7 +1465,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) {
@@ -1123,6 +1675,7 @@ function runMigrationCli(argv, config) {
   }
 }
 
+exports.AsyncMigrationRunner = AsyncMigrationRunner;
 exports.CyclicMigrationGraph = CyclicMigrationGraph;
 exports.IrreversibleMigration = IrreversibleMigration;
 exports.MigrationRunner = MigrationRunner;