tempest-db-js 0.1.0 → 0.3.0

package/dist/bin.cjs

@@ -0,0 +1,1191 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var promises = require('readline/promises');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// 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/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/ddl.ts
+function quoteId(name, dialect) {
+  return dialect === "mysql" ? `\`${name.replace(/`/g, "``")}\`` : `"${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";
+    }
+  }
+  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";
+    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 === "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))))";
+    }
+  }
+  const value = def.value;
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") {
+    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 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)}`;
+  return sql;
+}
+function enumTypeName(table, column) {
+  return `${table}_${column}`;
+}
+function isAutoIncrementPk(table, col) {
+  return table.primaryKey.length === 1 && table.primaryKey[0] === col.name && col.default === null && (col.type.kind === "smallint" || col.type.kind === "integer" || col.type.kind === "bigint");
+}
+function postgresSerialType(kind) {
+  if (kind === "bigint") return "BIGSERIAL";
+  if (kind === "smallint") return "SMALLSERIAL";
+  return "SERIAL";
+}
+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, 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 (dialect === "postgresql" && isAutoIncrementPk(table, c)) {
+      return `${quoteId(c.name, dialect)} ${postgresSerialType(c.type.kind)}`;
+    }
+    if (dialect === "mysql" && isAutoIncrementPk(table, c)) {
+      return `${quoteId(c.name, dialect)} ${renderColumnType(c.type, dialect)} NOT NULL AUTO_INCREMENT`;
+    }
+    return renderColumnDef(c, dialect);
+  });
+  if (table.primaryKey.length > 0) {
+    cols.push(
+      `PRIMARY KEY (${table.primaryKey.map((c) => quoteId(c, dialect)).join(", ")})`
+    );
+  }
+  return [
+    ...typeStmts,
+    `CREATE TABLE ${quoteId(table.name, dialect)} (
+  ${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, dialect)}`];
+    case "rename_table":
+      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, dialect)} ADD COLUMN ${renderColumnDef(op.column, dialect)}`
+      ];
+    case "drop_column":
+      return [
+        `ALTER TABLE ${quoteId(op.table, dialect)} DROP COLUMN ${quoteId(op.column.name, dialect)}`
+      ];
+    case "rename_column":
+      return [
+        `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) : renderTableDiff(op.from, op.to, dialect);
+    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((c) => quoteId(c, "sqlite")).join(", ")})`
+    );
+  }
+  const commonSql = common.map((c) => quoteId(c, "sqlite")).join(", ");
+  return [
+    "PRAGMA foreign_keys=off",
+    `CREATE TABLE ${quoteId(tmp, "sqlite")} (
+  ${cols.join(",\n  ")}
+)`,
+    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 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, dialect)} ADD COLUMN ${renderColumnDef(col, dialect)}`
+      );
+    } else {
+      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, dialect)} DROP COLUMN ${quoteId(name, dialect)}`
+      );
+    }
+  }
+  return stmts;
+}
+function renderAlterColumn(table, to, dialect) {
+  if (dialect === "sqlite") {
+    throw new Error(
+      `alter_column on SQLite needs a table-rebuild (recreate_table); column ${table}.${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)}`
+  ];
+  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/index.ts
+function isDefaultValue(value) {
+  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
+}
+var Column = class _Column {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null) {
+    this.type = type;
+    this.flags = flags;
+    this.defaultValue = defaultValue;
+    this.onUpdateValue = onUpdateValue;
+  }
+  type;
+  flags;
+  defaultValue;
+  onUpdateValue;
+  primaryKey() {
+    return new _Column(
+      this.type,
+      { ...this.flags, primaryKey: true, hasDefault: true },
+      this.defaultValue,
+      this.onUpdateValue
+    );
+  }
+  notNull() {
+    return new _Column(
+      this.type,
+      { ...this.flags, notNull: true },
+      this.defaultValue,
+      this.onUpdateValue
+    );
+  }
+  /**
+   * 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()`).
+   */
+  default(value) {
+    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
+    return new _Column(
+      this.type,
+      { ...this.flags, hasDefault: true },
+      resolved,
+      this.onUpdateValue
+    );
+  }
+  /**
+   * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
+   * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
+   */
+  onUpdate(value) {
+    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
+    return new _Column(this.type, this.flags, this.defaultValue, resolved);
+  }
+};
+var columnsCache = /* @__PURE__ */ new WeakMap();
+function columnsOf(model) {
+  const cached = columnsCache.get(model);
+  if (cached) return cached;
+  const instance = new model();
+  const out = {};
+  for (const [key, value] of Object.entries(instance)) {
+    if (value instanceof Column) {
+      out[key] = value;
+    }
+  }
+  columnsCache.set(model, out);
+  return out;
+}
+
+// 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/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;
+}
+
+// src/migrations/renames.ts
+function columnShape(col) {
+  return JSON.stringify({
+    type: col.type,
+    notNull: col.notNull,
+    primaryKey: col.primaryKey,
+    default: col.default
+  });
+}
+function tableShape(columns) {
+  return Object.entries(columns).map(([name, col]) => `${name}:${columnShape(col)}`).sort().join("|");
+}
+function detectRenames(ops) {
+  const candidates = [];
+  const creates = ops.filter((o) => o.kind === "create_table");
+  const tableDrops = ops.filter((o) => o.kind === "drop_table");
+  const takenCreate = /* @__PURE__ */ new Set();
+  const takenDrop = /* @__PURE__ */ new Set();
+  for (const create of creates) {
+    const createShape = tableShape(create.table.columns);
+    const matches = tableDrops.filter(
+      (d) => !takenDrop.has(d.table.name) && tableShape(d.table.columns) === createShape
+    );
+    const uniqueCreate = creates.filter(
+      (c) => !takenCreate.has(c.table.name) && tableShape(c.table.columns) === createShape
+    ).length === 1;
+    if (matches.length === 1 && uniqueCreate) {
+      const drop = matches[0];
+      if (drop.table.name !== create.table.name) {
+        candidates.push({ kind: "table", from: drop.table.name, to: create.table.name });
+        takenCreate.add(create.table.name);
+        takenDrop.add(drop.table.name);
+      }
+    }
+  }
+  const adds = ops.filter((o) => o.kind === "add_column");
+  const colDrops = ops.filter((o) => o.kind === "drop_column");
+  const tables = /* @__PURE__ */ new Set([...adds.map((o) => o.table), ...colDrops.map((o) => o.table)]);
+  for (const table of tables) {
+    const tableAdds = adds.filter((o) => o.table === table);
+    const tableColDrops = colDrops.filter((o) => o.table === table);
+    const takenAdd = /* @__PURE__ */ new Set();
+    const takenColDrop = /* @__PURE__ */ new Set();
+    for (const add of tableAdds) {
+      const shape = columnShape(add.column);
+      const dropMatches = tableColDrops.filter(
+        (d) => !takenColDrop.has(d.column.name) && columnShape(d.column) === shape
+      );
+      const addMatches = tableAdds.filter(
+        (a) => !takenAdd.has(a.column.name) && columnShape(a.column) === shape
+      );
+      if (dropMatches.length === 1 && addMatches.length === 1) {
+        const drop = dropMatches[0];
+        candidates.push({
+          kind: "column",
+          table,
+          from: drop.column.name,
+          to: add.column.name
+        });
+        takenAdd.add(add.column.name);
+        takenColDrop.add(drop.column.name);
+      }
+    }
+  }
+  return candidates;
+}
+function isTableRename(op, r) {
+  return op.kind === "create_table" && op.table.name === r.to || op.kind === "drop_table" && op.table.name === r.from;
+}
+function isColumnRename(op, r) {
+  return op.kind === "add_column" && op.table === r.table && op.column.name === r.to || op.kind === "drop_column" && op.table === r.table && op.column.name === r.from;
+}
+function applyRenames(ops, confirmed) {
+  const out = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const op of ops) {
+    const match = confirmed.find(
+      (r) => r.kind === "table" ? isTableRename(op, r) : isColumnRename(op, r)
+    );
+    if (!match) {
+      out.push(op);
+      continue;
+    }
+    if (!emitted.has(match)) {
+      emitted.add(match);
+      out.push(
+        match.kind === "table" ? { kind: "rename_table", from: match.from, to: match.to } : { kind: "rename_column", table: match.table, from: match.from, to: match.to }
+      );
+    }
+  }
+  return out;
+}
+
+// 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/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 parseRenameFlags(rest) {
+  const out = [];
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === "--rename-table") {
+      const [from, to] = (rest[i + 1] ?? "").split(":");
+      i += 1;
+      if (from && to) out.push({ kind: "table", from, to });
+    } else if (arg === "--rename-column") {
+      const [left, to] = (rest[i + 1] ?? "").split(":");
+      i += 1;
+      const dot = left?.lastIndexOf(".") ?? -1;
+      if (left && to && dot > 0) {
+        out.push({
+          kind: "column",
+          table: left.slice(0, dot),
+          from: left.slice(dot + 1),
+          to
+        });
+      }
+    }
+  }
+  return out;
+}
+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);
+      let ops = rest.includes("--autogenerate") ? diffSchema(replaySchema(config.migrations), reflectSchema(config.models)) : [];
+      if (rest.includes("--autogenerate")) {
+        const confirmed = rest.includes("--autorename") ? detectRenames(ops) : parseRenameFlags(rest);
+        if (confirmed.length > 0) ops = applyRenames(ops, confirmed);
+      }
+      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]"
+      ]);
+  }
+}
+
+// src/bin.ts
+var DEFAULT_CONFIG_NAMES = [
+  "tempest-db.config.mjs",
+  "tempest-db.config.js",
+  "tempest-db.config.cjs"
+];
+function extractConfigFlag(argv) {
+  const rest = [];
+  let configPath = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--config" || arg === "-c") {
+      configPath = argv[i + 1] ?? null;
+      i += 1;
+    } else if (arg?.startsWith("--config=")) {
+      configPath = arg.slice("--config=".length);
+    } else if (arg !== void 0) {
+      rest.push(arg);
+    }
+  }
+  return { configPath, rest };
+}
+function resolveConfigPath(explicit) {
+  if (explicit) return path.resolve(process.cwd(), explicit);
+  for (const name of DEFAULT_CONFIG_NAMES) {
+    const candidate = path.resolve(process.cwd(), name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+async function loadConfig(path) {
+  const mod = await import(url.pathToFileURL(path).href);
+  const config = mod.default ?? mod.config;
+  if (!config) {
+    throw new Error(
+      `config at ${path} must default-export (or export \`config\`) a CliConfig`
+    );
+  }
+  return config;
+}
+function renameToFlags(r) {
+  return r.kind === "table" ? ["--rename-table", `${r.from}:${r.to}`] : ["--rename-column", `${r.table}.${r.from}:${r.to}`];
+}
+async function promptRenames(config, rest) {
+  const decided = rest.includes("--autorename") || rest.includes("--rename-table") || rest.includes("--rename-column");
+  if (rest[0] !== "revision" || !rest.includes("--autogenerate") || decided || !config.models || !process.stdin.isTTY) {
+    return [];
+  }
+  const ops = diffSchema(replaySchema(config.migrations), reflectSchema(config.models));
+  const candidates = detectRenames(ops);
+  if (candidates.length === 0) return [];
+  const rl = promises.createInterface({ input: process.stdin, output: process.stdout });
+  const flags = [];
+  try {
+    for (const c of candidates) {
+      const what = c.kind === "table" ? `table "${c.from}" \u2192 "${c.to}"` : `column "${c.table}.${c.from}" \u2192 "${c.table}.${c.to}"`;
+      const answer = (await rl.question(`Rename ${what}? [y/N] `)).trim().toLowerCase();
+      if (answer === "y" || answer === "yes") flags.push(...renameToFlags(c));
+    }
+  } finally {
+    rl.close();
+  }
+  return flags;
+}
+async function main(argv) {
+  const { configPath, rest } = extractConfigFlag(argv);
+  const resolved = resolveConfigPath(configPath);
+  if (!resolved) {
+    process.stderr.write(
+      `tempest-db: no config found. Create one of ${DEFAULT_CONFIG_NAMES.join(
+        ", "
+      )} or pass --config <path>.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let config;
+  try {
+    config = await loadConfig(resolved);
+  } catch (error) {
+    process.stderr.write(`tempest-db: ${error.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const withClock = {
+    ...config,
+    appliedAt: config.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const renameFlags = await promptRenames(withClock, rest);
+  const result = runMigrationCli([...rest, ...renameFlags], withClock);
+  const sink = result.code === 0 ? process.stdout : process.stderr;
+  for (const line of result.lines) sink.write(`${line}
+`);
+  process.exitCode = result.code;
+}
+if ((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)) === url.pathToFileURL(process.argv[1] ?? "").href) {
+  void main(process.argv.slice(2));
+}
+
+exports.main = main;
+//# sourceMappingURL=bin.cjs.map
+//# sourceMappingURL=bin.cjs.map