tempest-db-js 0.1.0 → 0.3.0

package/dist/migrations/index.cjs

@@ -1,28 +1,5 @@
 'use strict';
 
-var module$1 = require('module');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// src/query.ts
-var OPERATORS = [
-  "eq",
-  "ne",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "like",
-  "ilike",
-  "in",
-  "notIn",
-  "between",
-  "isNull"
-];
-
-// src/dialect.ts
-new Set(OPERATORS);
-module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-
 // src/index.ts
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
@@ -76,7 +53,10 @@ var Column = class _Column {
     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)) {
@@ -84,6 +64,7 @@ function columnsOf(model) {
       out[key] = value;
     }
   }
+  columnsCache.set(model, out);
   return out;
 }
 
@@ -159,8 +140,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, "''")}'`;
@@ -185,6 +166,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";
@@ -229,19 +249,21 @@ 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());
@@ -249,7 +271,7 @@ function renderDefault(def, dialect) {
   return quoteLiteral(String(value));
 }
 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)}`;
   return sql;
@@ -257,26 +279,42 @@ function renderColumnDef(col, dialect) {
 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)} 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;
     }
+    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(quoteId).join(", ")})`);
+    cols.push(
+      `PRIMARY KEY (${table.primaryKey.map((c) => quoteId(c, dialect)).join(", ")})`
+    );
   }
   return [
     ...typeStmts,
-    `CREATE TABLE ${quoteId(table.name)} (
+    `CREATE TABLE ${quoteId(table.name, dialect)} (
   ${cols.join(",\n  ")}
 )`
   ];
@@ -286,23 +324,27 @@ 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 "execute":
       return [op.up];
   }
@@ -312,34 +354,38 @@ function renderSqliteRebuild(from, to) {
   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(", ");
+  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;
@@ -347,11 +393,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)}`
   ];
@@ -642,6 +693,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) {
@@ -917,13 +1074,133 @@ function replaySchema(migrations) {
   return schema;
 }
 
+// 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/cli.ts
+function defineMigrationConfig(config) {
+  return config;
+}
 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));
@@ -990,7 +1267,11 @@ function runMigrationCli(argv, 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)) : [];
+      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,
@@ -1007,14 +1288,18 @@ function runMigrationCli(argv, config) {
   }
 }
 
+exports.AsyncMigrationRunner = AsyncMigrationRunner;
 exports.CyclicMigrationGraph = CyclicMigrationGraph;
 exports.IrreversibleMigration = IrreversibleMigration;
 exports.MigrationRunner = MigrationRunner;
 exports.Op = Op;
 exports.UnknownRevision = UnknownRevision;
 exports.applyOperation = applyOperation;
+exports.applyRenames = applyRenames;
 exports.checkDrift = checkDrift;
 exports.checkDriftPostgres = checkDriftPostgres;
+exports.defineMigrationConfig = defineMigrationConfig;
+exports.detectRenames = detectRenames;
 exports.diffSchema = diffSchema;
 exports.emptySchema = emptySchema;
 exports.generateMigration = generateMigration;