tempest-db-js 0.7.0 → 0.9.0

package/dist/{chunk-SI4CLSF7.js → chunk-ZBIHRVUS.js}

@@ -1,4 +1,4 @@
-import { renderPortableToken, columnNamesOf, columnsOf, toAsyncDriver } from './chunk-4AWUP7BM.js';
+import { renderPortableToken, columnNamesOf, columnsOf, toAsyncDriver, LiteralParams, getDialect } from './chunk-HXK6WIBP.js';
 
 // src/migrations/operations.ts
 var IrreversibleMigration = class extends Error {
@@ -33,6 +33,10 @@ function invert(op) {
       return { kind: "recreate_table", from: op.to, to: op.from };
     case "add_constraint":
       return { kind: "drop_constraint", table: op.table, constraint: op.constraint };
+    case "create_index":
+      return { kind: "drop_index", table: op.table, index: op.index };
+    case "drop_index":
+      return { kind: "create_index", table: op.table, index: op.index };
     case "drop_constraint":
       return { kind: "add_constraint", table: op.table, constraint: op.constraint };
     case "execute":
@@ -223,7 +227,8 @@ function renderDefault(def, dialect, type) {
         "sql.expr`...` binds parameters and cannot be rendered as a DEFAULT \u2014 use sql.raw()."
       );
     }
-    return renderPortableToken(expr, dialect);
+    const rendered = renderPortableToken(expr, dialect);
+    return dialect === "sqlite" && rendered.includes("(") ? `(${rendered})` : rendered;
   }
   const value = def.value;
   if (value === null) return "NULL";
@@ -271,9 +276,31 @@ function renderForeignKeyConstraint(fk, dialect) {
 function tableConstraintClauses(table, dialect) {
   return [
     ...table.uniqueConstraints.map((uc) => renderUniqueConstraint(uc, dialect)),
-    ...table.foreignKeys.map((fk) => renderForeignKeyConstraint(fk, dialect))
+    ...table.foreignKeys.map((fk) => renderForeignKeyConstraint(fk, dialect)),
+    ...table.checks.map((ck) => renderCheckConstraint(ck, dialect))
   ];
 }
+function renderPredicate(node, dialect) {
+  const literals = new LiteralParams();
+  return getDialect(dialect).renderConditionLiteral(node, literals);
+}
+function renderCheckConstraint(ck, dialect) {
+  return `CONSTRAINT ${quoteId(ck.name, dialect)} CHECK (${renderPredicate(ck.expression, dialect)})`;
+}
+function renderCreateIndex(table, ix, dialect) {
+  if (ix.where && dialect === "mysql") {
+    throw new Error(
+      `MySQL has no partial index; ${ix.name} on ${table} declares a WHERE predicate.`
+    );
+  }
+  const unique = ix.unique ? "UNIQUE " : "";
+  const cols = ix.columns.map((c) => quoteId(c, dialect)).join(", ");
+  const where = ix.where ? ` WHERE ${renderPredicate(ix.where, dialect)}` : "";
+  return `CREATE ${unique}INDEX ${quoteId(ix.name, dialect)} ON ${quoteId(table, dialect)} (${cols})${where}`;
+}
+function renderDropIndex(table, ix, dialect) {
+  return dialect === "mysql" ? `DROP INDEX ${quoteId(ix.name, dialect)} ON ${quoteId(table, dialect)}` : `DROP INDEX ${quoteId(ix.name, dialect)}`;
+}
 function renderColumnDef(col, dialect) {
   let sql = `${quoteId(col.name, dialect)} ${renderColumnType(col.type, dialect)}`;
   if (col.notNull) sql += " NOT NULL";
@@ -326,7 +353,10 @@ function renderCreateTable(table, dialect) {
     ...typeStmts,
     `CREATE TABLE ${quoteId(table.name, dialect)} (
   ${cols.join(",\n  ")}
-)`
+)`,
+    // Indexes are separate statements, not table clauses — which is also why a
+    // SQLite table rebuild has to recreate them.
+    ...table.indexes.map((ix) => renderCreateIndex(table.name, ix, dialect))
   ];
 }
 function renderOperation(op, dialect) {
@@ -359,6 +389,10 @@ function renderOperation(op, dialect) {
       return renderAddConstraint(op.table, op.constraint, dialect);
     case "drop_constraint":
       return renderDropConstraint(op.table, op.constraint, dialect);
+    case "create_index":
+      return [renderCreateIndex(op.table, op.index, dialect)];
+    case "drop_index":
+      return [renderDropIndex(op.table, op.index, dialect)];
     case "execute":
       return [op.up];
   }
@@ -369,7 +403,7 @@ function renderAddConstraint(table, constraint, dialect) {
       `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);
+  const clause = constraint.type === "unique" ? renderUniqueConstraint(constraint.constraint, dialect) : constraint.type === "check" ? renderCheckConstraint(constraint.constraint, dialect) : renderForeignKeyConstraint(constraint.constraint, dialect);
   return [`ALTER TABLE ${quoteId(table, dialect)} ADD ${clause}`];
 }
 function renderDropConstraint(table, constraint, dialect) {
@@ -406,6 +440,10 @@ function renderSqliteRebuild(from, to) {
     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")}`,
+    // The rebuild dropped the old table, and its indexes with it: SQLite ties an
+    // index to the table it was created on. Recreating them is part of the
+    // rebuild, not a follow-up somebody has to remember.
+    ...to.indexes.map((ix) => renderCreateIndex(to.name, ix, "sqlite")),
     "PRAGMA foreign_keys=on"
   ];
 }
@@ -508,8 +546,49 @@ function diffConstraints(current, target) {
       ops.push(addForeignKey(table, tgt));
     }
   }
+  const currentCk = new Map(current.checks.map((c) => [c.name, c]));
+  const targetCk = new Map(target.checks.map((c) => [c.name, c]));
+  for (const [name, cur] of currentCk) {
+    const tgt = targetCk.get(name);
+    if (!tgt || checkSignature(cur) !== checkSignature(tgt)) {
+      ops.push({ kind: "drop_constraint", table, constraint: checkNamed(cur) });
+    }
+  }
+  for (const [name, tgt] of targetCk) {
+    const cur = currentCk.get(name);
+    if (!cur || checkSignature(cur) !== checkSignature(tgt)) {
+      ops.push({ kind: "add_constraint", table, constraint: checkNamed(tgt) });
+    }
+  }
+  const currentIx = new Map(current.indexes.map((i) => [i.name, i]));
+  const targetIx = new Map(target.indexes.map((i) => [i.name, i]));
+  for (const [name, cur] of currentIx) {
+    const tgt = targetIx.get(name);
+    if (!tgt || indexSignature(cur) !== indexSignature(tgt)) {
+      ops.push({ kind: "drop_index", table, index: cur });
+    }
+  }
+  for (const [name, tgt] of targetIx) {
+    const cur = currentIx.get(name);
+    if (!cur || indexSignature(cur) !== indexSignature(tgt)) {
+      ops.push({ kind: "create_index", table, index: tgt });
+    }
+  }
   return ops;
 }
+function checkSignature(ck) {
+  return JSON.stringify(ck.expression);
+}
+function indexSignature(ix) {
+  return JSON.stringify({
+    columns: ix.columns,
+    unique: ix.unique,
+    where: ix.where
+  });
+}
+function checkNamed(ck) {
+  return { type: "check", constraint: ck };
+}
 function uniqueNamed(uc) {
   return { type: "unique", constraint: uc };
 }
@@ -624,6 +703,41 @@ function heads(migrations) {
 function constraintName(prefix, table, columns) {
   return `${prefix}_${table}_${columns.join("_")}`;
 }
+function renameConditionColumns(node, toColumn) {
+  const expr = (current) => {
+    switch (current.kind) {
+      case "column":
+        return { kind: "column", name: toColumn(current.name) };
+      case "fn":
+        return { ...current, args: current.args.map(expr) };
+      case "cast":
+        return { ...current, operand: expr(current.operand) };
+      default:
+        return current;
+    }
+  };
+  switch (node.kind) {
+    case "fields": {
+      const fields = {};
+      for (const [key, value] of Object.entries(node.fields)) {
+        fields[toColumn(key)] = value;
+      }
+      return { kind: "fields", fields };
+    }
+    case "and":
+    case "or":
+      return {
+        ...node,
+        parts: node.parts.map((part) => renameConditionColumns(part, toColumn))
+      };
+    case "not":
+      return { kind: "not", part: renameConditionColumns(node.part, toColumn) };
+    case "compare":
+      return { ...node, left: expr(node.left), right: expr(node.right) };
+    default:
+      return node;
+  }
+}
 function reflectTable(model) {
   const names = columnNamesOf(model);
   const toColumn = (prop) => names?.[prop] ?? prop;
@@ -645,6 +759,8 @@ function reflectTable(model) {
   }
   const uniqueConstraints = [];
   const foreignKeys = [];
+  const checks = [];
+  const indexes = [];
   for (const c of model.tableArgs?.() ?? []) {
     const cols = c.columns.map(toColumn);
     if (c.kind === "unique") {
@@ -652,6 +768,18 @@ function reflectTable(model) {
         name: c.name ?? constraintName("uq", model.tablename, cols),
         columns: cols
       });
+    } else if (c.kind === "check") {
+      checks.push({
+        name: c.name ?? constraintName("ck", model.tablename, cols),
+        expression: renameConditionColumns(c.expression, toColumn)
+      });
+    } else if (c.kind === "index") {
+      indexes.push({
+        name: c.name ?? constraintName("ix", model.tablename, cols),
+        columns: cols,
+        unique: c.unique === true,
+        where: c.where ? renameConditionColumns(c.where, toColumn) : null
+      });
     } else {
       foreignKeys.push({
         name: c.name ?? constraintName("fk", model.tablename, cols),
@@ -663,7 +791,15 @@ function reflectTable(model) {
       });
     }
   }
-  return { name: model.tablename, columns, primaryKey, uniqueConstraints, foreignKeys };
+  return {
+    name: model.tablename,
+    columns,
+    primaryKey,
+    uniqueConstraints,
+    foreignKeys,
+    checks,
+    indexes
+  };
 }
 function reflectSchema(models) {
   const tables = {};
@@ -727,6 +863,8 @@ function introspectSqlite(driver) {
       columns,
       primaryKey,
       uniqueConstraints: sqliteUniques(driver, tableName),
+      checks: [],
+      indexes: sqliteIndexes(driver, tableName),
       foreignKeys: sqliteForeignKeys(driver, tableName)
     };
   }
@@ -815,6 +953,7 @@ function compareSqliteSchemas(actual, expected) {
         );
       }
     }
+    issues.push(...indexDrift(tableName, actualTable, expectedTable));
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -865,9 +1004,58 @@ function sqliteUniqueFromPragma(table, rows) {
   if (cols.length === 0) return null;
   return { name: `uq_${table}_${cols.join("_")}`, columns: cols };
 }
+function indexesFromPragma(rows, columnsOfIndex) {
+  const indexes = [];
+  for (const idx of rows) {
+    if (idx.origin !== "c") continue;
+    if (idx.partial === 1) continue;
+    const cols = [...columnsOfIndex(idx.name)].sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+    if (cols.length === 0) continue;
+    indexes.push({
+      name: idx.name,
+      columns: cols,
+      unique: Number(idx.unique) === 1,
+      where: null
+    });
+  }
+  return indexes;
+}
+function sqliteIndexes(driver, table) {
+  const rows = driver.execute(`PRAGMA index_list(${JSON.stringify(table)})`, []).rows;
+  return indexesFromPragma(
+    rows,
+    (name) => driver.execute(`PRAGMA index_info(${JSON.stringify(name)})`, []).rows
+  );
+}
 function isUniqueIndex(idx) {
   return Number(idx.unique) === 1 && idx.origin !== "pk";
 }
+function indexDrift(tableName, actual, expected) {
+  const issues = [];
+  const signature = (ix) => `${ix.columns.join(",")}${ix.unique ? " unique" : ""}`;
+  const actualByName = new Map(actual.indexes.map((ix) => [ix.name, ix]));
+  const expectedByName = new Map(expected.indexes.map((ix) => [ix.name, ix]));
+  for (const [name, exp] of expectedByName) {
+    const act = actualByName.get(name);
+    if (!act) {
+      issues.push(`index "${tableName}.${name}" is missing from the database`);
+      continue;
+    }
+    if (signature(act) !== signature(exp)) {
+      issues.push(
+        `index "${tableName}.${name}" differs: model (${signature(exp)}), db (${signature(act)})`
+      );
+    }
+  }
+  for (const name of actualByName.keys()) {
+    if (!expectedByName.has(name)) {
+      issues.push(
+        `index "${tableName}.${name}" exists in the database but not in the model`
+      );
+    }
+  }
+  return issues;
+}
 var SQLITE_TABLES_SQL = "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name != 'tempest_db_js_migrations'";
 async function introspectSqliteAsync(driver) {
   const tablesRows = (await driver.execute(SQLITE_TABLES_SQL, [])).rows;
@@ -885,12 +1073,27 @@ async function introspectSqliteAsync(driver) {
       const unique = sqliteUniqueFromPragma(tableName, cols);
       if (unique) uniqueConstraints.push(unique);
     }
+    const explicitIndexes = [];
+    for (const idx of indexes) {
+      if (idx.origin !== "c" || idx.partial === 1) continue;
+      const cols = (await driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, [])).rows;
+      const sorted = [...cols].sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+      if (sorted.length === 0) continue;
+      explicitIndexes.push({
+        name: idx.name,
+        columns: sorted,
+        unique: Number(idx.unique) === 1,
+        where: null
+      });
+    }
     tables[tableName] = {
       name: tableName,
       columns,
       primaryKey,
       uniqueConstraints,
-      foreignKeys: sqliteForeignKeysFromPragma(tableName, fkRows)
+      foreignKeys: sqliteForeignKeysFromPragma(tableName, fkRows),
+      checks: [],
+      indexes: explicitIndexes
     };
   }
   return { tables };
@@ -1016,6 +1219,8 @@ async function introspectPostgres(driver) {
       columns,
       primaryKey,
       uniqueConstraints: await postgresUniques(driver, tableName),
+      checks: [],
+      indexes: await postgresIndexes(driver, tableName),
       foreignKeys: await postgresForeignKeys(driver, tableName)
     };
   }
@@ -1058,6 +1263,29 @@ async function postgresUniques(driver, table) {
     columns: r.cols ?? []
   }));
 }
+async function postgresIndexes(driver, table) {
+  const { rows } = await driver.execute(
+    `SELECT i.relname AS name,
+            ix.indisunique AS is_unique,
+            ix.indpred IS NOT NULL AS is_partial,
+            array_to_string(array_agg(a.attname ORDER BY k.ord), ',') AS columns
+       FROM pg_index ix
+       JOIN pg_class i ON i.oid = ix.indexrelid
+       JOIN pg_class t ON t.oid = ix.indrelid
+       JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
+       JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+      WHERE t.relname = $1
+        AND NOT EXISTS (SELECT 1 FROM pg_constraint c WHERE c.conindid = ix.indexrelid)
+      GROUP BY i.relname, ix.indisunique, ix.indpred`,
+    [table]
+  );
+  return rows.filter((row) => !row.is_partial).map((row) => ({
+    name: row.name,
+    columns: row.columns.split(","),
+    unique: row.is_unique === true,
+    where: null
+  }));
+}
 function describeKind(type) {
   if (type.kind !== "array") return type.kind;
   return `${type.meta.element ? describeKind(type.meta.element) : "unknown"}[]`;
@@ -1108,6 +1336,7 @@ async function checkDriftPostgres(driver, models) {
         );
       }
     }
+    issues.push(...indexDrift(tableName, actualTable, expectedTable));
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -1526,7 +1755,22 @@ function applyOperation(schema, op) {
         tables[op.table] = op.constraint.type === "unique" ? {
           ...t,
           uniqueConstraints: [...t.uniqueConstraints, op.constraint.constraint]
-        } : { ...t, foreignKeys: [...t.foreignKeys, op.constraint.constraint] };
+        } : op.constraint.type === "check" ? { ...t, checks: [...t.checks, op.constraint.constraint] } : { ...t, foreignKeys: [...t.foreignKeys, op.constraint.constraint] };
+      }
+      break;
+    }
+    case "create_index": {
+      const t = tables[op.table];
+      if (t) tables[op.table] = { ...t, indexes: [...t.indexes, op.index] };
+      break;
+    }
+    case "drop_index": {
+      const t = tables[op.table];
+      if (t) {
+        tables[op.table] = {
+          ...t,
+          indexes: t.indexes.filter((i) => i.name !== op.index.name)
+        };
       }
       break;
     }
@@ -1537,7 +1781,7 @@ function applyOperation(schema, op) {
         tables[op.table] = op.constraint.type === "unique" ? {
           ...t,
           uniqueConstraints: t.uniqueConstraints.filter((u) => u.name !== dropName)
-        } : {
+        } : op.constraint.type === "check" ? { ...t, checks: t.checks.filter((c) => c.name !== dropName) } : {
           ...t,
           foreignKeys: t.foreignKeys.filter((f) => f.name !== dropName)
         };
@@ -1682,5 +1926,5 @@ async function runMigrationCli(argv, config) {
 }
 
 export { AsyncMigrationRunner, CyclicMigrationGraph, IrreversibleMigration, MigrationRunner, Op, UnknownRevision, applyOperation, applyRenames, checkDrift, checkDriftAsync, checkDriftPostgres, compareSqliteSchemas, defineMigrationConfig, detectRenames, diffSchema, emptySchema, generateMigration, heads, introspectPostgres, introspectSqlite, introspectSqliteAsync, invert, invertAll, makeRevisionId, reflectSchema, reflectTable, renderColumnDef, renderColumnType, renderDefault, renderOperation, replaySchema, runMigrationCli, sqliteAffinity, topoOrder };
-//# sourceMappingURL=chunk-SI4CLSF7.js.map
-//# sourceMappingURL=chunk-SI4CLSF7.js.map
+//# sourceMappingURL=chunk-ZBIHRVUS.js.map
+//# sourceMappingURL=chunk-ZBIHRVUS.js.map