tempest-db-js 0.3.0 → 0.4.0

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { runMigrationCli, diffSchema, replaySchema, reflectSchema, detectRenames } from './chunk-OP7FRDI5.js';
-import './chunk-Q32CBI2A.js';
+import { runMigrationCli, diffSchema, replaySchema, reflectSchema, detectRenames } from './chunk-43XL66JG.js';
+import './chunk-JR4MLFQN.js';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
 import { createInterface } from 'readline/promises';

package/dist/{chunk-OP7FRDI5.js → chunk-43XL66JG.js}

@@ -1,4 +1,4 @@
-import { columnsOf } from './chunk-Q32CBI2A.js';
+import { columnsOf } from './chunk-JR4MLFQN.js';
 
 // src/migrations/operations.ts
 var IrreversibleMigration = class extends Error {
@@ -31,6 +31,10 @@ function invert(op) {
       return { kind: "rename_column", table: op.table, from: op.to, to: op.from };
     case "recreate_table":
       return { kind: "recreate_table", from: op.to, to: op.from };
+    case "add_constraint":
+      return { kind: "drop_constraint", table: op.table, constraint: op.constraint };
+    case "drop_constraint":
+      return { kind: "add_constraint", table: op.table, constraint: op.constraint };
     case "execute":
       if (op.down === null) {
         throw new IrreversibleMigration("execute() operation has no down SQL");
@@ -220,10 +224,45 @@ function renderDefault(def, dialect) {
   if (typeof value === "object") return quoteLiteral(JSON.stringify(value));
   return quoteLiteral(String(value));
 }
+function renderFkAction(action) {
+  return action.toUpperCase();
+}
+function renderFkActions(fk) {
+  let sql = "";
+  if (fk.onDelete) sql += ` ON DELETE ${renderFkAction(fk.onDelete)}`;
+  if (fk.onUpdate) sql += ` ON UPDATE ${renderFkAction(fk.onUpdate)}`;
+  return sql;
+}
+function columnConstraintSuffix(col, dialect) {
+  let sql = "";
+  if (col.unique) sql += " UNIQUE";
+  if (col.references) {
+    const ref = col.references;
+    sql += ` REFERENCES ${quoteId(ref.table, dialect)} (${quoteId(ref.column, dialect)})`;
+    sql += renderFkActions(ref);
+  }
+  return sql;
+}
+function renderUniqueConstraint(uc, dialect) {
+  const cols = uc.columns.map((c) => quoteId(c, dialect)).join(", ");
+  return `CONSTRAINT ${quoteId(uc.name, dialect)} UNIQUE (${cols})`;
+}
+function renderForeignKeyConstraint(fk, dialect) {
+  const cols = fk.columns.map((c) => quoteId(c, dialect)).join(", ");
+  const refCols = fk.refColumns.map((c) => quoteId(c, dialect)).join(", ");
+  return `CONSTRAINT ${quoteId(fk.name, dialect)} FOREIGN KEY (${cols}) REFERENCES ${quoteId(fk.refTable, dialect)} (${refCols})${renderFkActions(fk)}`;
+}
+function tableConstraintClauses(table, dialect) {
+  return [
+    ...table.uniqueConstraints.map((uc) => renderUniqueConstraint(uc, dialect)),
+    ...table.foreignKeys.map((fk) => renderForeignKeyConstraint(fk, dialect))
+  ];
+}
 function renderColumnDef(col, dialect) {
   let sql = `${quoteId(col.name, dialect)} ${renderColumnType(col.type, dialect)}`;
   if (col.notNull) sql += " NOT NULL";
   if (col.default !== null) sql += ` DEFAULT ${renderDefault(col.default, dialect)}`;
+  sql += columnConstraintSuffix(col, dialect);
   return sql;
 }
 function enumTypeName(table, column) {
@@ -247,13 +286,13 @@ function renderCreateTable(table, dialect) {
       let def = `${quoteId(c.name, dialect)} ${quoteId(typeName, dialect)}`;
       if (c.notNull) def += " NOT NULL";
       if (c.default !== null) def += ` DEFAULT ${renderDefault(c.default, dialect)}`;
-      return def;
+      return def + columnConstraintSuffix(c, dialect);
     }
     if (dialect === "postgresql" && isAutoIncrementPk(table, c)) {
-      return `${quoteId(c.name, dialect)} ${postgresSerialType(c.type.kind)}`;
+      return `${quoteId(c.name, dialect)} ${postgresSerialType(c.type.kind)}${columnConstraintSuffix(c, dialect)}`;
     }
     if (dialect === "mysql" && isAutoIncrementPk(table, c)) {
-      return `${quoteId(c.name, dialect)} ${renderColumnType(c.type, dialect)} NOT NULL AUTO_INCREMENT`;
+      return `${quoteId(c.name, dialect)} ${renderColumnType(c.type, dialect)} NOT NULL AUTO_INCREMENT${columnConstraintSuffix(c, dialect)}`;
     }
     return renderColumnDef(c, dialect);
   });
@@ -262,6 +301,7 @@ function renderCreateTable(table, dialect) {
       `PRIMARY KEY (${table.primaryKey.map((c) => quoteId(c, dialect)).join(", ")})`
     );
   }
+  cols.push(...tableConstraintClauses(table, dialect));
   return [
     ...typeStmts,
     `CREATE TABLE ${quoteId(table.name, dialect)} (
@@ -295,10 +335,38 @@ function renderOperation(op, dialect) {
       return renderAlterColumn(op.table, op.to, dialect);
     case "recreate_table":
       return dialect === "sqlite" ? renderSqliteRebuild(op.from, op.to) : renderTableDiff(op.from, op.to, dialect);
+    case "add_constraint":
+      return renderAddConstraint(op.table, op.constraint, dialect);
+    case "drop_constraint":
+      return renderDropConstraint(op.table, op.constraint, dialect);
     case "execute":
       return [op.up];
   }
 }
+function renderAddConstraint(table, constraint, dialect) {
+  if (dialect === "sqlite") {
+    throw new Error(
+      `add_constraint on SQLite needs a table-rebuild (recreate_table); constraint ${constraint.constraint.name} on ${table}`
+    );
+  }
+  const clause = constraint.type === "unique" ? renderUniqueConstraint(constraint.constraint, dialect) : renderForeignKeyConstraint(constraint.constraint, dialect);
+  return [`ALTER TABLE ${quoteId(table, dialect)} ADD ${clause}`];
+}
+function renderDropConstraint(table, constraint, dialect) {
+  if (dialect === "sqlite") {
+    throw new Error(
+      `drop_constraint on SQLite needs a table-rebuild (recreate_table); constraint ${constraint.constraint.name} on ${table}`
+    );
+  }
+  const t = quoteId(table, dialect);
+  const name = quoteId(constraint.constraint.name, dialect);
+  if (dialect === "mysql") {
+    return [
+      constraint.type === "unique" ? `ALTER TABLE ${t} DROP INDEX ${name}` : `ALTER TABLE ${t} DROP FOREIGN KEY ${name}`
+    ];
+  }
+  return [`ALTER TABLE ${t} DROP CONSTRAINT ${name}`];
+}
 function renderSqliteRebuild(from, to) {
   const tmp = `__new_${to.name}`;
   const common = Object.keys(to.columns).filter((c) => c in from.columns);
@@ -308,6 +376,7 @@ function renderSqliteRebuild(from, to) {
       `PRIMARY KEY (${to.primaryKey.map((c) => quoteId(c, "sqlite")).join(", ")})`
     );
   }
+  cols.push(...tableConstraintClauses(to, "sqlite"));
   const commonSql = common.map((c) => quoteId(c, "sqlite")).join(", ");
   return [
     "PRAGMA foreign_keys=off",
@@ -371,9 +440,74 @@ function columnSignature(col) {
     type: col.type,
     notNull: col.notNull,
     primaryKey: col.primaryKey,
-    default: col.default
+    default: col.default,
+    unique: col.unique,
+    references: col.references
   });
 }
+function uniqueSignature(uc) {
+  return JSON.stringify({ columns: uc.columns });
+}
+function foreignKeySignature(fk) {
+  return JSON.stringify({
+    columns: fk.columns,
+    refTable: fk.refTable,
+    refColumns: fk.refColumns,
+    onDelete: fk.onDelete ?? null,
+    onUpdate: fk.onUpdate ?? null
+  });
+}
+function diffConstraints(current, target) {
+  const ops = [];
+  const table = target.name;
+  const currentUq = new Map(current.uniqueConstraints.map((u) => [u.name, u]));
+  const targetUq = new Map(target.uniqueConstraints.map((u) => [u.name, u]));
+  for (const [name, cur] of currentUq) {
+    const tgt = targetUq.get(name);
+    if (!tgt || uniqueSignature(cur) !== uniqueSignature(tgt)) {
+      ops.push(dropUnique(table, cur));
+    }
+  }
+  for (const [name, tgt] of targetUq) {
+    const cur = currentUq.get(name);
+    if (!cur || uniqueSignature(cur) !== uniqueSignature(tgt)) {
+      ops.push(addUnique(table, tgt));
+    }
+  }
+  const currentFk = new Map(current.foreignKeys.map((f) => [f.name, f]));
+  const targetFk = new Map(target.foreignKeys.map((f) => [f.name, f]));
+  for (const [name, cur] of currentFk) {
+    const tgt = targetFk.get(name);
+    if (!tgt || foreignKeySignature(cur) !== foreignKeySignature(tgt)) {
+      ops.push(dropForeignKey(table, cur));
+    }
+  }
+  for (const [name, tgt] of targetFk) {
+    const cur = currentFk.get(name);
+    if (!cur || foreignKeySignature(cur) !== foreignKeySignature(tgt)) {
+      ops.push(addForeignKey(table, tgt));
+    }
+  }
+  return ops;
+}
+function uniqueNamed(uc) {
+  return { type: "unique", constraint: uc };
+}
+function foreignKeyNamed(fk) {
+  return { type: "foreignKey", constraint: fk };
+}
+function addUnique(table, uc) {
+  return { kind: "add_constraint", table, constraint: uniqueNamed(uc) };
+}
+function dropUnique(table, uc) {
+  return { kind: "drop_constraint", table, constraint: uniqueNamed(uc) };
+}
+function addForeignKey(table, fk) {
+  return { kind: "add_constraint", table, constraint: foreignKeyNamed(fk) };
+}
+function dropForeignKey(table, fk) {
+  return { kind: "drop_constraint", table, constraint: foreignKeyNamed(fk) };
+}
 function diffSchema(current, target) {
   const ops = [];
   const drops = [];
@@ -402,6 +536,7 @@ function diffSchema(current, target) {
         ops.push({ kind: "drop_column", table: name, column: currentCol });
       }
     }
+    ops.push(...diffConstraints(currentTable, targetTable));
   }
   for (const [name, currentTable] of Object.entries(current.tables)) {
     if (!target.tables[name]) {
@@ -466,6 +601,9 @@ function heads(migrations) {
 }
 
 // src/migrations/ir.ts
+function constraintName(prefix, table, columns) {
+  return `${prefix}_${table}_${columns.join("_")}`;
+}
 function reflectTable(model) {
   const columns = {};
   const primaryKey = [];
@@ -476,11 +614,32 @@ function reflectTable(model) {
       type: col.type,
       notNull: col.flags.notNull || isPk,
       primaryKey: isPk,
-      default: col.defaultValue
+      default: col.defaultValue,
+      unique: col.flags.unique,
+      references: col.reference
     };
     if (isPk) primaryKey.push(name);
   }
-  return { name: model.tablename, columns, primaryKey };
+  const uniqueConstraints = [];
+  const foreignKeys = [];
+  for (const c of model.tableArgs?.() ?? []) {
+    if (c.kind === "unique") {
+      uniqueConstraints.push({
+        name: c.name ?? constraintName("uq", model.tablename, c.columns),
+        columns: c.columns
+      });
+    } else {
+      foreignKeys.push({
+        name: c.name ?? constraintName("fk", model.tablename, c.columns),
+        columns: c.columns,
+        refTable: c.refTable,
+        refColumns: c.refColumns,
+        onDelete: c.onDelete,
+        onUpdate: c.onUpdate
+      });
+    }
+  }
+  return { name: model.tablename, columns, primaryKey, uniqueConstraints, foreignKeys };
 }
 function reflectSchema(models) {
   const tables = {};
@@ -517,6 +676,39 @@ function affinityToKind(affinity) {
       return "text";
   }
 }
+function sqliteForeignKeys(driver, table) {
+  const rows = driver.execute(`PRAGMA foreign_key_list(${JSON.stringify(table)})`, []).rows;
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const list = byId.get(r.id) ?? [];
+    list.push(r);
+    byId.set(r.id, list);
+  }
+  const fks = [];
+  for (const group of byId.values()) {
+    const ordered = [...group].sort((a, b) => a.seq - b.seq);
+    const columns = ordered.map((r) => r.from);
+    fks.push({
+      name: `fk_${table}_${columns.join("_")}`,
+      columns,
+      refTable: ordered[0]?.table ?? "",
+      refColumns: ordered.map((r) => r.to)
+    });
+  }
+  return fks;
+}
+function sqliteUniques(driver, table) {
+  const indexes = driver.execute(`PRAGMA index_list(${JSON.stringify(table)})`, []).rows;
+  const uniques = [];
+  for (const idx of indexes) {
+    if (Number(idx.unique) !== 1 || idx.origin === "pk") continue;
+    const cols = driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, []).rows.sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+    if (cols.length > 0) {
+      uniques.push({ name: `uq_${table}_${cols.join("_")}`, columns: cols });
+    }
+  }
+  return uniques;
+}
 function introspectSqlite(driver) {
   const tablesRows = driver.execute(
     "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name != 'tempest_db_js_migrations'",
@@ -536,14 +728,39 @@ function introspectSqlite(driver) {
         type: { kind: affinityToKind(affinity), meta: {} },
         notNull: Number(col.notnull) === 1 || isPk,
         primaryKey: isPk,
-        default: null
+        default: null,
+        unique: false,
+        references: null
       };
       if (isPk) primaryKey.push(col.name);
     }
-    tables[tableName] = { name: tableName, columns, primaryKey };
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      primaryKey,
+      uniqueConstraints: sqliteUniques(driver, tableName),
+      foreignKeys: sqliteForeignKeys(driver, tableName)
+    };
   }
   return { tables };
 }
+function constraintKeys(table) {
+  const fks = /* @__PURE__ */ new Set();
+  const uniques = /* @__PURE__ */ new Set();
+  for (const col of Object.values(table.columns)) {
+    if (col.unique) uniques.add(col.name);
+    if (col.references) {
+      fks.add(`${col.name}=>${col.references.table}(${col.references.column})`);
+    }
+  }
+  for (const uc of table.uniqueConstraints) {
+    uniques.add([...uc.columns].sort().join(","));
+  }
+  for (const fk of table.foreignKeys) {
+    fks.add(`${fk.columns.join(",")}=>${fk.refTable}(${fk.refColumns.join(",")})`);
+  }
+  return { fks, uniques };
+}
 function checkDrift(driver, models) {
   const actual = introspectSqlite(driver);
   const expected = reflectSchema(models);
@@ -581,6 +798,34 @@ function checkDrift(driver, models) {
         );
       }
     }
+    const expectedKeys = constraintKeys(expectedTable);
+    const actualKeys = constraintKeys(actualTable);
+    for (const fk of expectedKeys.fks) {
+      if (!actualKeys.fks.has(fk)) {
+        issues.push(`foreign key "${tableName}: ${fk}" is missing from the database`);
+      }
+    }
+    for (const fk of actualKeys.fks) {
+      if (!expectedKeys.fks.has(fk)) {
+        issues.push(
+          `foreign key "${tableName}: ${fk}" exists in the database but not in the model`
+        );
+      }
+    }
+    for (const uq of expectedKeys.uniques) {
+      if (!actualKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" is missing from the database`
+        );
+      }
+    }
+    for (const uq of actualKeys.uniques) {
+      if (!expectedKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" exists in the database but not in the model`
+        );
+      }
+    }
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -642,14 +887,59 @@ async function introspectPostgres(driver) {
         },
         notNull: col.is_nullable === "NO" || isPk,
         primaryKey: isPk,
-        default: null
+        default: null,
+        unique: false,
+        references: null
       };
       if (isPk) primaryKey.push(name);
     }
-    tables[tableName] = { name: tableName, columns, primaryKey };
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      primaryKey,
+      uniqueConstraints: await postgresUniques(driver, tableName),
+      foreignKeys: await postgresForeignKeys(driver, tableName)
+    };
   }
   return { tables };
 }
+async function postgresForeignKeys(driver, table) {
+  const result = await driver.execute(
+    `SELECT c.conname AS name,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols,
+            cf.relname AS ref_table,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.confkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.confrelid AND a.attnum = k.attnum) AS ref_cols
+       FROM pg_constraint c
+       JOIN pg_class cf ON cf.oid = c.confrelid
+      WHERE c.contype = 'f' AND c.conrelid = $1::regclass`,
+    [table]
+  );
+  return result.rows.map((r) => ({
+    name: String(r.name),
+    columns: r.cols ?? [],
+    refTable: String(r.ref_table),
+    refColumns: r.ref_cols ?? []
+  }));
+}
+async function postgresUniques(driver, table) {
+  const result = await driver.execute(
+    `SELECT c.conname AS name,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols
+       FROM pg_constraint c
+      WHERE c.contype = 'u' AND c.conrelid = $1::regclass`,
+    [table]
+  );
+  return result.rows.map((r) => ({
+    name: String(r.name),
+    columns: r.cols ?? []
+  }));
+}
 async function checkDriftPostgres(driver, models) {
   const actual = await introspectPostgres(driver);
   const expected = reflectSchema(models);
@@ -682,6 +972,20 @@ async function checkDriftPostgres(driver, models) {
         );
       }
     }
+    const expectedKeys = constraintKeys(expectedTable);
+    const actualKeys = constraintKeys(actualTable);
+    for (const fk of expectedKeys.fks) {
+      if (!actualKeys.fks.has(fk)) {
+        issues.push(`foreign key "${tableName}: ${fk}" is missing from the database`);
+      }
+    }
+    for (const uq of expectedKeys.uniques) {
+      if (!actualKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" is missing from the database`
+        );
+      }
+    }
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -697,7 +1001,9 @@ function columnShape(col) {
     type: col.type,
     notNull: col.notNull,
     primaryKey: col.primaryKey,
-    default: col.default
+    default: col.default,
+    unique: col.unique,
+    references: col.references
   });
 }
 function tableShape(columns) {
@@ -816,6 +1122,14 @@ var Op = class {
   recreateTable(from, to) {
     this.run({ kind: "recreate_table", from, to });
   }
+  /** Add a table-level unique / foreign-key constraint. */
+  addConstraint(table, constraint) {
+    this.run({ kind: "add_constraint", table, constraint });
+  }
+  /** Drop a table-level unique / foreign-key constraint. */
+  dropConstraint(table, constraint) {
+    this.run({ kind: "drop_constraint", table, constraint });
+  }
   /** Raw SQL escape hatch (e.g. a data migration). `down` may be `null`. */
   execute(up, down = null) {
     this.run({ kind: "execute", up, down });
@@ -1084,6 +1398,30 @@ function applyOperation(schema, op) {
       }
       break;
     }
+    case "add_constraint": {
+      const t = tables[op.table];
+      if (t) {
+        tables[op.table] = op.constraint.type === "unique" ? {
+          ...t,
+          uniqueConstraints: [...t.uniqueConstraints, op.constraint.constraint]
+        } : { ...t, foreignKeys: [...t.foreignKeys, op.constraint.constraint] };
+      }
+      break;
+    }
+    case "drop_constraint": {
+      const t = tables[op.table];
+      if (t) {
+        const dropName = op.constraint.constraint.name;
+        tables[op.table] = op.constraint.type === "unique" ? {
+          ...t,
+          uniqueConstraints: t.uniqueConstraints.filter((u) => u.name !== dropName)
+        } : {
+          ...t,
+          foreignKeys: t.foreignKeys.filter((f) => f.name !== dropName)
+        };
+      }
+      break;
+    }
   }
   return { tables };
 }
@@ -1221,5 +1559,5 @@ function runMigrationCli(argv, config) {
 }
 
 export { AsyncMigrationRunner, CyclicMigrationGraph, IrreversibleMigration, MigrationRunner, Op, UnknownRevision, applyOperation, applyRenames, checkDrift, checkDriftPostgres, defineMigrationConfig, detectRenames, diffSchema, emptySchema, generateMigration, heads, introspectPostgres, introspectSqlite, invert, invertAll, makeRevisionId, reflectSchema, reflectTable, renderColumnDef, renderColumnType, renderDefault, renderOperation, replaySchema, runMigrationCli, sqliteAffinity, topoOrder };
-//# sourceMappingURL=chunk-OP7FRDI5.js.map
-//# sourceMappingURL=chunk-OP7FRDI5.js.map
+//# sourceMappingURL=chunk-43XL66JG.js.map
+//# sourceMappingURL=chunk-43XL66JG.js.map