tempest-db-js 0.1.0

package/dist/migrations/index.js

@@ -0,0 +1,925 @@
+import { columnsOf } from '../chunk-F36ZSQAN.js';
+
+// src/migrations/ir.ts
+function reflectTable(model) {
+  const columns = {};
+  const primaryKey = [];
+  for (const [name, col] of Object.entries(columnsOf(model))) {
+    const isPk = col.flags.primaryKey;
+    columns[name] = {
+      name,
+      type: col.type,
+      notNull: col.flags.notNull || isPk,
+      primaryKey: isPk,
+      default: col.defaultValue
+    };
+    if (isPk) primaryKey.push(name);
+  }
+  return { name: model.tablename, columns, primaryKey };
+}
+function reflectSchema(models) {
+  const tables = {};
+  for (const model of models) {
+    const table = reflectTable(model);
+    tables[table.name] = table;
+  }
+  return { tables };
+}
+function emptySchema() {
+  return { tables: {} };
+}
+
+// src/migrations/operations.ts
+var IrreversibleMigration = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IrreversibleMigration";
+  }
+};
+function invert(op) {
+  switch (op.kind) {
+    case "create_table":
+      return { kind: "drop_table", table: op.table };
+    case "drop_table":
+      return { kind: "create_table", table: op.table };
+    case "rename_table":
+      return { kind: "rename_table", from: op.to, to: op.from };
+    case "add_column":
+      return { kind: "drop_column", table: op.table, column: op.column };
+    case "drop_column":
+      return { kind: "add_column", table: op.table, column: op.column };
+    case "alter_column":
+      return {
+        kind: "alter_column",
+        table: op.table,
+        name: op.name,
+        from: op.to,
+        to: op.from
+      };
+    case "rename_column":
+      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 "execute":
+      if (op.down === null) {
+        throw new IrreversibleMigration("execute() operation has no down SQL");
+      }
+      return { kind: "execute", up: op.down, down: op.up };
+  }
+}
+function invertAll(ops) {
+  return [...ops].reverse().map(invert);
+}
+
+// src/migrations/ddl.ts
+function quoteId(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function quoteLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function renderColumnType(type, dialect) {
+  const { kind, meta } = type;
+  if (dialect === "sqlite") {
+    switch (kind) {
+      case "smallint":
+      case "integer":
+      case "bigint":
+      case "boolean":
+        return "INTEGER";
+      case "real":
+      case "double":
+        return "REAL";
+      case "numeric":
+        return "NUMERIC";
+      case "blob":
+        return "BLOB";
+      default:
+        return "TEXT";
+    }
+  }
+  switch (kind) {
+    case "smallint":
+      return "SMALLINT";
+    case "integer":
+      return "INTEGER";
+    case "bigint":
+      return "BIGINT";
+    case "numeric":
+      return meta.precision !== void 0 ? `NUMERIC(${meta.precision}${meta.scale !== void 0 ? `, ${meta.scale}` : ""})` : "NUMERIC";
+    case "real":
+      return "REAL";
+    case "double":
+      return "DOUBLE PRECISION";
+    case "varchar":
+      return meta.length !== void 0 ? `VARCHAR(${meta.length})` : "VARCHAR";
+    case "char":
+      return meta.length !== void 0 ? `CHAR(${meta.length})` : "CHAR";
+    case "text":
+      return "TEXT";
+    case "boolean":
+      return "BOOLEAN";
+    case "date":
+      return "DATE";
+    case "time":
+      return meta.withTimezone ? "TIME WITH TIME ZONE" : "TIME";
+    case "datetime":
+    case "timestamp":
+      return meta.withTimezone ? "TIMESTAMP WITH TIME ZONE" : "TIMESTAMP";
+    case "blob":
+      return "BYTEA";
+    case "json":
+      return meta.jsonb ? "JSONB" : "JSON";
+    case "uuid":
+      return "UUID";
+    case "enum":
+      return "TEXT";
+  }
+}
+function renderDefault(def, dialect) {
+  if (def.kind === "expression") {
+    const expr = def.expression;
+    if (typeof expr === "object") return expr.raw;
+    switch (expr) {
+      case "now":
+        return dialect === "sqlite" ? "CURRENT_TIMESTAMP" : "now()";
+      case "current_date":
+        return "CURRENT_DATE";
+      case "current_time":
+        return "CURRENT_TIME";
+      case "uuidv4":
+        return dialect === "sqlite" ? "(lower(hex(randomblob(16))))" : "gen_random_uuid()";
+    }
+  }
+  const value = def.value;
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") {
+    return dialect === "sqlite" ? value ? "1" : "0" : value ? "TRUE" : "FALSE";
+  }
+  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 renderColumnDef(col, dialect) {
+  let sql = `${quoteId(col.name)} ${renderColumnType(col.type, dialect)}`;
+  if (col.notNull) sql += " NOT NULL";
+  if (col.default !== null) sql += ` DEFAULT ${renderDefault(col.default, dialect)}`;
+  return sql;
+}
+function enumTypeName(table, column) {
+  return `${table}_${column}`;
+}
+function renderCreateTable(table, dialect) {
+  const typeStmts = [];
+  const cols = Object.values(table.columns).map((c) => {
+    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)}`;
+      if (c.notNull) def += " NOT NULL";
+      if (c.default !== null) def += ` DEFAULT ${renderDefault(c.default, dialect)}`;
+      return def;
+    }
+    return renderColumnDef(c, dialect);
+  });
+  if (table.primaryKey.length > 0) {
+    cols.push(`PRIMARY KEY (${table.primaryKey.map(quoteId).join(", ")})`);
+  }
+  return [
+    ...typeStmts,
+    `CREATE TABLE ${quoteId(table.name)} (
+  ${cols.join(",\n  ")}
+)`
+  ];
+}
+function renderOperation(op, dialect) {
+  switch (op.kind) {
+    case "create_table":
+      return renderCreateTable(op.table, dialect);
+    case "drop_table":
+      return [`DROP TABLE ${quoteId(op.table.name)}`];
+    case "rename_table":
+      return [`ALTER TABLE ${quoteId(op.from)} RENAME TO ${quoteId(op.to)}`];
+    case "add_column":
+      return [
+        `ALTER TABLE ${quoteId(op.table)} ADD COLUMN ${renderColumnDef(op.column, dialect)}`
+      ];
+    case "drop_column":
+      return [`ALTER TABLE ${quoteId(op.table)} DROP COLUMN ${quoteId(op.column.name)}`];
+    case "rename_column":
+      return [
+        `ALTER TABLE ${quoteId(op.table)} RENAME COLUMN ${quoteId(op.from)} TO ${quoteId(op.to)}`
+      ];
+    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);
+    case "execute":
+      return [op.up];
+  }
+}
+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(", ")})`);
+  }
+  const commonSql = common.map(quoteId).join(", ");
+  return [
+    "PRAGMA foreign_keys=off",
+    `CREATE TABLE ${quoteId(tmp)} (
+  ${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)}`,
+    "PRAGMA foreign_keys=on"
+  ];
+}
+function renderPostgresTableDiff(from, to) {
+  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")}`
+      );
+    } else {
+      stmts.push(...renderAlterColumn(to.name, col, "postgresql"));
+    }
+  }
+  for (const name of Object.keys(from.columns)) {
+    if (!(name in to.columns)) {
+      stmts.push(`ALTER TABLE ${quoteId(to.name)} DROP COLUMN ${quoteId(name)}`);
+    }
+  }
+  return stmts;
+}
+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}`
+    );
+  }
+  const t = quoteId(table);
+  const c = quoteId(to.name);
+  const stmts = [
+    `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE ${renderColumnType(to.type, dialect)}`
+  ];
+  stmts.push(
+    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`
+  );
+  return stmts;
+}
+
+// src/migrations/diff.ts
+function columnSignature(col) {
+  return JSON.stringify({
+    type: col.type,
+    notNull: col.notNull,
+    primaryKey: col.primaryKey,
+    default: col.default
+  });
+}
+function diffSchema(current, target) {
+  const ops = [];
+  const drops = [];
+  for (const [name, targetTable] of Object.entries(target.tables)) {
+    const currentTable = current.tables[name];
+    if (!currentTable) {
+      ops.push({ kind: "create_table", table: targetTable });
+      continue;
+    }
+    for (const [colName, targetCol] of Object.entries(targetTable.columns)) {
+      const currentCol = currentTable.columns[colName];
+      if (!currentCol) {
+        ops.push({ kind: "add_column", table: name, column: targetCol });
+      } else if (columnSignature(currentCol) !== columnSignature(targetCol)) {
+        ops.push({
+          kind: "alter_column",
+          table: name,
+          name: colName,
+          from: currentCol,
+          to: targetCol
+        });
+      }
+    }
+    for (const [colName, currentCol] of Object.entries(currentTable.columns)) {
+      if (!targetTable.columns[colName]) {
+        ops.push({ kind: "drop_column", table: name, column: currentCol });
+      }
+    }
+  }
+  for (const [name, currentTable] of Object.entries(current.tables)) {
+    if (!target.tables[name]) {
+      drops.push({ kind: "drop_table", table: currentTable });
+    }
+  }
+  return [...ops, ...drops];
+}
+
+// src/migrations/graph.ts
+var CyclicMigrationGraph = class extends Error {
+  constructor(remaining) {
+    super(`migration graph has a cycle among: ${remaining.join(", ")}`);
+    this.name = "CyclicMigrationGraph";
+  }
+};
+var UnknownRevision = class extends Error {
+  constructor(revision, parent) {
+    super(`revision ${revision} references unknown parent ${parent}`);
+    this.name = "UnknownRevision";
+  }
+};
+function topoOrder(migrations) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of migrations) byId.set(m.revision, m);
+  const indegree = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const m of migrations) {
+    indegree.set(m.revision, m.downRevision.length);
+    for (const parent of m.downRevision) {
+      if (!byId.has(parent)) throw new UnknownRevision(m.revision, parent);
+      const list = children.get(parent) ?? [];
+      list.push(m.revision);
+      children.set(parent, list);
+    }
+  }
+  const ready = migrations.filter((m) => (indegree.get(m.revision) ?? 0) === 0).map((m) => m.revision).sort();
+  const ordered = [];
+  while (ready.length > 0) {
+    const id = ready.shift();
+    ordered.push(byId.get(id));
+    const next = (children.get(id) ?? []).sort();
+    for (const child of next) {
+      const deg = (indegree.get(child) ?? 0) - 1;
+      indegree.set(child, deg);
+      if (deg === 0) {
+        ready.push(child);
+        ready.sort();
+      }
+    }
+  }
+  if (ordered.length !== migrations.length) {
+    const remaining = migrations.map((m) => m.revision).filter((r) => !ordered.some((o) => o.revision === r));
+    throw new CyclicMigrationGraph(remaining);
+  }
+  return ordered;
+}
+function heads(migrations) {
+  const parents = /* @__PURE__ */ new Set();
+  for (const m of migrations) for (const p of m.downRevision) parents.add(p);
+  return migrations.map((m) => m.revision).filter((r) => !parents.has(r)).sort();
+}
+
+// src/migrations/codegen.ts
+function renderOps(ops) {
+  if (ops.length === 0) return "[]";
+  const body = ops.map((op) => `    ${JSON.stringify(op)},`).join("\n");
+  return `[
+${body}
+  ]`;
+}
+function generateMigration(draft) {
+  let down;
+  try {
+    down = renderOps(invertAll(draft.operations));
+  } catch (error) {
+    down = `(() => { throw new Error(${JSON.stringify(
+      `irreversible migration: ${error.message}`
+    )}); })()`;
+  }
+  return `import type { Migration, Op } from "tempest-db-js/migrations";
+
+export const revision = ${JSON.stringify(draft.revision)};
+export const downRevision: string[] = ${JSON.stringify(draft.downRevision)};
+export const label = ${JSON.stringify(draft.label)};
+
+const upOps = ${renderOps(draft.operations)};
+
+const downOps = ${down};
+
+export const up = (op: Op): void => {
+  for (const operation of upOps) op.run(operation);
+};
+
+export const down = (op: Op): void => {
+  for (const operation of downOps) op.run(operation);
+};
+
+export default { revision, downRevision, label, up, down } satisfies Migration;
+`;
+}
+function makeRevisionId(label, parents) {
+  let hash = 2166136261;
+  for (const ch of `${label}|${[...parents].sort().join(",")}`) {
+    hash ^= ch.charCodeAt(0);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+// src/migrations/runner.ts
+var Op = class {
+  operations = [];
+  /** Record a raw operation (used by autogenerated migrations). */
+  run(operation) {
+    this.operations.push(operation);
+  }
+  createTable(table) {
+    this.run({ kind: "create_table", table });
+  }
+  dropTable(table) {
+    this.run({ kind: "drop_table", table });
+  }
+  renameTable(from, to) {
+    this.run({ kind: "rename_table", from, to });
+  }
+  addColumn(table, column) {
+    this.run({ kind: "add_column", table, column });
+  }
+  dropColumn(table, column) {
+    this.run({ kind: "drop_column", table, column });
+  }
+  alterColumn(table, name, from, to) {
+    this.run({ kind: "alter_column", table, name, from, to });
+  }
+  renameColumn(table, from, to) {
+    this.run({ kind: "rename_column", table, from, to });
+  }
+  /** Rebuild a table (SQLite batch-mode / PostgreSQL per-column alters). */
+  recreateTable(from, to) {
+    this.run({ kind: "recreate_table", from, to });
+  }
+  /** Raw SQL escape hatch (e.g. a data migration). `down` may be `null`. */
+  execute(up, down = null) {
+    this.run({ kind: "execute", up, down });
+  }
+};
+var VERSION_TABLE = "tempest_db_js_migrations";
+var MigrationRunner = class {
+  constructor(driver, dialect) {
+    this.driver = driver;
+    this.dialect = dialect;
+  }
+  driver;
+  dialect;
+  /** Create the version-tracking table if it does not exist. */
+  ensureVersionTable() {
+    this.driver.execute(
+      `CREATE TABLE IF NOT EXISTS "${VERSION_TABLE}" (revision TEXT PRIMARY KEY, applied_at TEXT NOT NULL, down_revision TEXT NOT NULL)`,
+      []
+    );
+  }
+  /** The set of applied revision ids. */
+  applied() {
+    this.ensureVersionTable();
+    const { rows } = this.driver.execute(`SELECT revision FROM "${VERSION_TABLE}"`, []);
+    return new Set(rows.map((r) => String(r.revision)));
+  }
+  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;
+        this.driver.execute(stmt, []);
+      }
+    }
+  }
+  record(migration, appliedAt) {
+    this.driver.execute(
+      `INSERT INTO "${VERSION_TABLE}" (revision, applied_at, down_revision) VALUES (?, ?, ?)`,
+      [migration.revision, appliedAt, migration.downRevision.join(",")]
+    );
+  }
+  forget(revision) {
+    this.driver.execute(`DELETE FROM "${VERSION_TABLE}" WHERE revision = ?`, [revision]);
+  }
+  /**
+   * Apply all pending migrations up to the head(s), in DAG order.
+   *
+   * @param migrations All known migrations.
+   * @param appliedAt Timestamp string to stamp (pass one in — the runtime has no
+   *   wall clock of its own here).
+   * @returns The revision ids that were applied this run.
+   */
+  upgrade(migrations, appliedAt) {
+    const done = 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);
+      this.runOps(op.operations);
+      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.
+   */
+  downgrade(migrations, steps = 1) {
+    const done = 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();
+      if (migration.down.length >= 0) {
+        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));
+      }
+      this.runOps(op.operations);
+      this.forget(migration.revision);
+      reverted.push(migration.revision);
+    }
+    return reverted;
+  }
+};
+
+// src/migrations/introspect.ts
+function sqliteAffinity(declared) {
+  const t = declared.toUpperCase();
+  if (t.includes("INT")) return "INTEGER";
+  if (t.includes("CHAR") || t.includes("CLOB") || t.includes("TEXT")) return "TEXT";
+  if (t.includes("BLOB") || t === "") return "BLOB";
+  if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB")) return "REAL";
+  return "NUMERIC";
+}
+function affinityToKind(affinity) {
+  switch (affinity) {
+    case "INTEGER":
+      return "integer";
+    case "REAL":
+      return "real";
+    case "BLOB":
+      return "blob";
+    case "NUMERIC":
+      return "numeric";
+    default:
+      return "text";
+  }
+}
+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'",
+    []
+  ).rows;
+  const tables = {};
+  for (const row of tablesRows) {
+    const tableName = String(row.name);
+    const info = driver.execute(`PRAGMA table_info(${JSON.stringify(tableName)})`, []).rows;
+    const columns = {};
+    const primaryKey = [];
+    for (const col of info) {
+      const isPk = Number(col.pk) > 0;
+      const affinity = sqliteAffinity(col.type);
+      columns[col.name] = {
+        name: col.name,
+        type: { kind: affinityToKind(affinity), meta: {} },
+        notNull: Number(col.notnull) === 1 || isPk,
+        primaryKey: isPk,
+        default: null
+      };
+      if (isPk) primaryKey.push(col.name);
+    }
+    tables[tableName] = { name: tableName, columns, primaryKey };
+  }
+  return { tables };
+}
+function checkDrift(driver, models) {
+  const actual = introspectSqlite(driver);
+  const expected = reflectSchema(models);
+  const issues = [];
+  for (const [tableName, expectedTable] of Object.entries(expected.tables)) {
+    const actualTable = actual.tables[tableName];
+    if (!actualTable) {
+      issues.push(`table "${tableName}" is missing from the database`);
+      continue;
+    }
+    for (const [colName, expectedCol] of Object.entries(expectedTable.columns)) {
+      const actualCol = actualTable.columns[colName];
+      if (!actualCol) {
+        issues.push(`column "${tableName}.${colName}" is missing from the database`);
+        continue;
+      }
+      const expAff = sqliteAffinity(renderColumnType(expectedCol.type, "sqlite"));
+      const actAff = sqliteAffinity(renderColumnType(actualCol.type, "sqlite"));
+      if (expAff !== actAff) {
+        issues.push(
+          `column "${tableName}.${colName}" affinity differs: model ${expAff}, db ${actAff}`
+        );
+      }
+      if (expectedCol.notNull !== actualCol.notNull) {
+        issues.push(`column "${tableName}.${colName}" nullability differs`);
+      }
+      if (expectedCol.primaryKey !== actualCol.primaryKey) {
+        issues.push(`column "${tableName}.${colName}" primary-key flag differs`);
+      }
+    }
+    for (const colName of Object.keys(actualTable.columns)) {
+      if (!expectedTable.columns[colName]) {
+        issues.push(
+          `column "${tableName}.${colName}" exists in the database but not in the model`
+        );
+      }
+    }
+  }
+  for (const tableName of Object.keys(actual.tables)) {
+    if (!expected.tables[tableName]) {
+      issues.push(`table "${tableName}" exists in the database but not in the models`);
+    }
+  }
+  return issues;
+}
+function pgTypeToKind(dataType, udtName) {
+  const t = dataType.toLowerCase();
+  if (t === "user-defined") return "enum";
+  if (t === "smallint") return "smallint";
+  if (t === "integer") return "integer";
+  if (t === "bigint") return "bigint";
+  if (t === "numeric") return "numeric";
+  if (t === "real") return "real";
+  if (t === "double precision") return "double";
+  if (t === "character varying") return "varchar";
+  if (t === "character") return "char";
+  if (t === "text") return "text";
+  if (t === "boolean") return "boolean";
+  if (t === "date") return "date";
+  if (t.startsWith("time")) return t.startsWith("timestamp") ? "timestamp" : "time";
+  if (t === "bytea") return "blob";
+  if (t === "json") return "json";
+  if (t === "jsonb") return "json";
+  if (t === "uuid") return "uuid";
+  return udtName === "jsonb" ? "json" : "text";
+}
+async function introspectPostgres(driver) {
+  const tablesResult = await driver.execute(
+    "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE' AND table_name != 'tempest_db_js_migrations'",
+    []
+  );
+  const tables = {};
+  for (const row of tablesResult.rows) {
+    const tableName = String(row.table_name);
+    const colsResult = await driver.execute(
+      "SELECT column_name, data_type, udt_name, is_nullable FROM information_schema.columns WHERE table_name = $1",
+      [tableName]
+    );
+    const pkResult = await driver.execute(
+      `SELECT a.attname AS name FROM pg_index i
+       JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+       WHERE i.indrelid = $1::regclass AND i.indisprimary`,
+      [tableName]
+    );
+    const pkSet = new Set(pkResult.rows.map((r) => String(r.name)));
+    const columns = {};
+    const primaryKey = [];
+    for (const col of colsResult.rows) {
+      const name = String(col.column_name);
+      const isPk = pkSet.has(name);
+      columns[name] = {
+        name,
+        type: {
+          kind: pgTypeToKind(String(col.data_type), String(col.udt_name)),
+          meta: {}
+        },
+        notNull: col.is_nullable === "NO" || isPk,
+        primaryKey: isPk,
+        default: null
+      };
+      if (isPk) primaryKey.push(name);
+    }
+    tables[tableName] = { name: tableName, columns, primaryKey };
+  }
+  return { tables };
+}
+async function checkDriftPostgres(driver, models) {
+  const actual = await introspectPostgres(driver);
+  const expected = reflectSchema(models);
+  const issues = [];
+  for (const [tableName, expectedTable] of Object.entries(expected.tables)) {
+    const actualTable = actual.tables[tableName];
+    if (!actualTable) {
+      issues.push(`table "${tableName}" is missing from the database`);
+      continue;
+    }
+    for (const [colName, expectedCol] of Object.entries(expectedTable.columns)) {
+      const actualCol = actualTable.columns[colName];
+      if (!actualCol) {
+        issues.push(`column "${tableName}.${colName}" is missing from the database`);
+        continue;
+      }
+      if (expectedCol.type.kind !== actualCol.type.kind) {
+        issues.push(
+          `column "${tableName}.${colName}" type differs: model ${expectedCol.type.kind}, db ${actualCol.type.kind}`
+        );
+      }
+      if (expectedCol.notNull !== actualCol.notNull) {
+        issues.push(`column "${tableName}.${colName}" nullability differs`);
+      }
+    }
+    for (const colName of Object.keys(actualTable.columns)) {
+      if (!expectedTable.columns[colName]) {
+        issues.push(
+          `column "${tableName}.${colName}" exists in the database but not in the model`
+        );
+      }
+    }
+  }
+  for (const tableName of Object.keys(actual.tables)) {
+    if (!expected.tables[tableName]) {
+      issues.push(`table "${tableName}" exists in the database but not in the models`);
+    }
+  }
+  return issues;
+}
+
+// src/migrations/replay.ts
+function applyOperation(schema, op) {
+  const tables = { ...schema.tables };
+  switch (op.kind) {
+    case "create_table":
+      tables[op.table.name] = op.table;
+      break;
+    case "drop_table":
+      delete tables[op.table.name];
+      break;
+    case "rename_table": {
+      const t = tables[op.from];
+      if (t) {
+        delete tables[op.from];
+        tables[op.to] = { ...t, name: op.to };
+      }
+      break;
+    }
+    case "recreate_table":
+      delete tables[op.from.name];
+      tables[op.to.name] = op.to;
+      break;
+    case "add_column": {
+      const t = tables[op.table];
+      if (t) {
+        tables[op.table] = {
+          ...t,
+          columns: { ...t.columns, [op.column.name]: op.column }
+        };
+      }
+      break;
+    }
+    case "drop_column": {
+      const t = tables[op.table];
+      if (t) {
+        const columns = { ...t.columns };
+        delete columns[op.column.name];
+        tables[op.table] = { ...t, columns };
+      }
+      break;
+    }
+    case "alter_column": {
+      const t = tables[op.table];
+      if (t) {
+        tables[op.table] = {
+          ...t,
+          columns: { ...t.columns, [op.name]: op.to }
+        };
+      }
+      break;
+    }
+    case "rename_column": {
+      const t = tables[op.table];
+      const col = t?.columns[op.from];
+      if (t && col) {
+        const columns = { ...t.columns };
+        delete columns[op.from];
+        columns[op.to] = { ...col, name: op.to };
+        tables[op.table] = { ...t, columns };
+      }
+      break;
+    }
+  }
+  return { tables };
+}
+function replaySchema(migrations) {
+  let schema = emptySchema();
+  for (const migration of topoOrder(migrations)) {
+    const op = new Op();
+    migration.up(op);
+    for (const operation of op.operations) {
+      schema = applyOperation(schema, operation);
+    }
+  }
+  return schema;
+}
+
+// src/migrations/cli.ts
+function ok(lines) {
+  return { code: 0, lines };
+}
+function fail(lines) {
+  return { code: 1, lines };
+}
+function pending(config, runner) {
+  const done = runner.applied();
+  return topoOrder(config.migrations).filter((m) => !done.has(m.revision));
+}
+function runMigrationCli(argv, config) {
+  const [command, ...rest] = argv;
+  const runner = new MigrationRunner(config.driver, config.dialect);
+  const appliedAt = config.appliedAt ?? "1970-01-01T00:00:00.000Z";
+  switch (command) {
+    case "current": {
+      const applied = [...runner.applied()].sort();
+      return ok(applied.length > 0 ? applied : ["(no migrations applied)"]);
+    }
+    case "heads":
+      return ok(heads(config.migrations));
+    case "history": {
+      const done = runner.applied();
+      return ok(
+        topoOrder(config.migrations).map(
+          (m) => `${done.has(m.revision) ? "\u2713" : "\xB7"} ${m.revision}${m.label ? ` \u2014 ${m.label}` : ""}`
+        )
+      );
+    }
+    case "upgrade": {
+      if (rest.includes("--sql")) {
+        const lines = [];
+        for (const migration of pending(config, runner)) {
+          const op = new Op();
+          migration.up(op);
+          lines.push(`-- ${migration.revision}`);
+          for (const operation of op.operations) {
+            for (const stmt of renderOperation(operation, config.dialect))
+              lines.push(`${stmt};`);
+          }
+        }
+        return ok(lines.length > 0 ? lines : ["-- nothing to upgrade"]);
+      }
+      const ran = runner.upgrade(config.migrations, appliedAt);
+      return ok(ran.length > 0 ? ran.map((r) => `applied ${r}`) : ["nothing to upgrade"]);
+    }
+    case "downgrade": {
+      const steps = rest[0] ? Number(rest[0]) : 1;
+      const reverted = runner.downgrade(config.migrations, steps);
+      return ok(
+        reverted.length > 0 ? reverted.map((r) => `reverted ${r}`) : ["nothing to downgrade"]
+      );
+    }
+    case "check": {
+      if (!config.models) return fail(["check requires models in the config"]);
+      const drift = config.dialect === "sqlite" ? checkDrift(config.driver, config.models) : [];
+      const undiffed = diffSchema(
+        replaySchema(config.migrations),
+        reflectSchema(config.models)
+      );
+      const issues = [
+        ...drift.map((d) => `drift: ${d}`),
+        ...undiffed.map((o) => `uncaptured: ${o.kind}`)
+      ];
+      return issues.length > 0 ? fail(issues) : ok(["no drift; models match migrations"]);
+    }
+    case "revision": {
+      if (!config.models)
+        return fail(["revision --autogenerate requires models in the config"]);
+      const msgIndex = rest.indexOf("-m");
+      const label = msgIndex >= 0 ? rest[msgIndex + 1] ?? "revision" : "revision";
+      const parents = heads(config.migrations);
+      const ops = rest.includes("--autogenerate") ? diffSchema(replaySchema(config.migrations), reflectSchema(config.models)) : [];
+      const source = generateMigration({
+        revision: makeRevisionId(label, parents),
+        downRevision: parents,
+        label,
+        operations: ops
+      });
+      return ok(source.split("\n"));
+    }
+    default:
+      return fail([
+        `unknown command ${JSON.stringify(command)}`,
+        "commands: current | history | heads | upgrade [--sql] | downgrade [N] | check | revision -m <msg> [--autogenerate]"
+      ]);
+  }
+}
+
+export { CyclicMigrationGraph, IrreversibleMigration, MigrationRunner, Op, UnknownRevision, applyOperation, checkDrift, checkDriftPostgres, diffSchema, emptySchema, generateMigration, heads, introspectPostgres, introspectSqlite, invert, invertAll, makeRevisionId, reflectSchema, reflectTable, renderColumnDef, renderColumnType, renderDefault, renderOperation, replaySchema, runMigrationCli, sqliteAffinity, topoOrder };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map