@vertz/db 0.2.12 → 0.2.13

package/dist/index.js

@@ -1,14 +1,10 @@
 import {
-  PostgresDialect,
-  SqliteDialect,
   buildDelete,
   buildInsert,
   buildSelect,
   buildUpdate,
-  buildWhere,
-  defaultPostgresDialect,
-  defaultSqliteDialect
-} from "./shared/chunk-0e1vy9qd.js";
+  buildWhere
+} from "./shared/chunk-pxjcpnpx.js";
 import {
   CheckConstraintError,
   ConnectionError,
@@ -18,23 +14,31 @@ import {
   NotFoundError,
   NotNullError,
   UniqueConstraintError,
+  computeChecksum,
+  computeDiff,
+  createMigrationRunner,
   executeQuery,
+  generateMigrationSql,
   getAutoUpdateColumns,
   getPrimaryKeyColumns,
   getReadOnlyColumns,
   getTimestampColumns,
   mapRow,
   mapRows,
+  parseMigrationName,
   parsePgError,
-  resolveSelectColumns
-} from "./shared/chunk-agyds4jw.js";
+  resolveSelectColumns,
+  validateIndexes
+} from "./shared/chunk-1x9z0p5e.js";
 import"./shared/chunk-kb4tnn2k.js";
 import {
-  camelToSnake
-} from "./shared/chunk-v2qm94qp.js";
-import {
-  sha256Hex
-} from "./shared/chunk-ssga2xea.js";
+  PostgresDialect,
+  SqliteDialect,
+  camelToSnake,
+  defaultPostgresDialect,
+  defaultSqliteDialect
+} from "./shared/chunk-8v70x3hq.js";
+import"./shared/chunk-ssga2xea.js";
 import {
   diagnoseError,
   explainError,
@@ -43,10 +47,10 @@ import {
 import {
   createD1Adapter,
   createD1Driver
-} from "./shared/chunk-pnk6yzjv.js";
+} from "./shared/chunk-ndxe1h28.js";
 import {
   generateId
-} from "./shared/chunk-sfmyxz6r.js";
+} from "./shared/chunk-pkv8w501.js";
 // src/adapters/database-bridge-adapter.ts
 function createDatabaseBridgeAdapter(db, tableName) {
   const delegate = db[tableName];
@@ -98,537 +102,6 @@ function createDatabaseBridgeAdapter(db, tableName) {
     }
   };
 }
-// src/migration/auto-migrate.ts
-import { isErr } from "@vertz/errors";
-
-// src/migration/differ.ts
-function columnSimilarity(a, b) {
-  let score = 0;
-  let total = 0;
-  total += 3;
-  if (a.type === b.type)
-    score += 3;
-  total += 1;
-  if (a.nullable === b.nullable)
-    score += 1;
-  total += 1;
-  if (a.primary === b.primary)
-    score += 1;
-  total += 1;
-  if (a.unique === b.unique)
-    score += 1;
-  return score / total;
-}
-function indexKey(columns) {
-  return columns.join(",");
-}
-function computeDiff(before, after) {
-  const changes = [];
-  for (const tableName of Object.keys(after.tables)) {
-    if (!(tableName in before.tables)) {
-      changes.push({ type: "table_added", table: tableName });
-    }
-  }
-  for (const tableName of Object.keys(before.tables)) {
-    if (!(tableName in after.tables)) {
-      changes.push({ type: "table_removed", table: tableName });
-    }
-  }
-  for (const tableName of Object.keys(after.tables)) {
-    if (!(tableName in before.tables))
-      continue;
-    const beforeTable = before.tables[tableName];
-    const afterTable = after.tables[tableName];
-    if (!beforeTable || !afterTable)
-      continue;
-    const removedCols = Object.keys(beforeTable.columns).filter((c) => !(c in afterTable.columns));
-    const addedCols = Object.keys(afterTable.columns).filter((c) => !(c in beforeTable.columns));
-    const renames = [];
-    const matchedRemoved = new Set;
-    const matchedAdded = new Set;
-    for (const removed of removedCols) {
-      const removedSnap = beforeTable.columns[removed];
-      if (!removedSnap)
-        continue;
-      let bestMatch = null;
-      let bestScore = 0;
-      for (const added of addedCols) {
-        if (matchedAdded.has(added))
-          continue;
-        const addedSnap = afterTable.columns[added];
-        if (!addedSnap)
-          continue;
-        const score = columnSimilarity(removedSnap, addedSnap);
-        if (score > bestScore) {
-          bestScore = score;
-          bestMatch = added;
-        }
-      }
-      if (bestMatch && bestScore >= 0.7) {
-        renames.push({ oldCol: removed, newCol: bestMatch, confidence: bestScore });
-        matchedRemoved.add(removed);
-        matchedAdded.add(bestMatch);
-      }
-    }
-    for (const rename of renames) {
-      changes.push({
-        type: "column_renamed",
-        table: tableName,
-        oldColumn: rename.oldCol,
-        newColumn: rename.newCol,
-        confidence: rename.confidence
-      });
-    }
-    for (const colName of addedCols) {
-      if (!matchedAdded.has(colName)) {
-        changes.push({ type: "column_added", table: tableName, column: colName });
-      }
-    }
-    for (const colName of removedCols) {
-      if (!matchedRemoved.has(colName)) {
-        changes.push({ type: "column_removed", table: tableName, column: colName });
-      }
-    }
-    for (const colName of Object.keys(afterTable.columns)) {
-      if (!(colName in beforeTable.columns))
-        continue;
-      const beforeCol = beforeTable.columns[colName];
-      const afterCol = afterTable.columns[colName];
-      if (!beforeCol || !afterCol)
-        continue;
-      if (beforeCol.type !== afterCol.type || beforeCol.nullable !== afterCol.nullable || beforeCol.default !== afterCol.default) {
-        const change = {
-          type: "column_altered",
-          table: tableName,
-          column: colName
-        };
-        if (beforeCol.type !== afterCol.type) {
-          change.oldType = beforeCol.type;
-          change.newType = afterCol.type;
-        }
-        if (beforeCol.nullable !== afterCol.nullable) {
-          change.oldNullable = beforeCol.nullable;
-          change.newNullable = afterCol.nullable;
-        }
-        if (beforeCol.default !== afterCol.default) {
-          change.oldDefault = beforeCol.default;
-          change.newDefault = afterCol.default;
-        }
-        changes.push(change);
-      }
-    }
-    const beforeIndexKeys = new Set(beforeTable.indexes.map((i) => indexKey(i.columns)));
-    const afterIndexKeys = new Set(afterTable.indexes.map((i) => indexKey(i.columns)));
-    for (const idx of afterTable.indexes) {
-      const key = indexKey(idx.columns);
-      if (!beforeIndexKeys.has(key)) {
-        changes.push({ type: "index_added", table: tableName, columns: [...idx.columns] });
-      }
-    }
-    for (const idx of beforeTable.indexes) {
-      const key = indexKey(idx.columns);
-      if (!afterIndexKeys.has(key)) {
-        changes.push({ type: "index_removed", table: tableName, columns: [...idx.columns] });
-      }
-    }
-  }
-  for (const enumName of Object.keys(after.enums)) {
-    if (!(enumName in before.enums)) {
-      changes.push({ type: "enum_added", enumName });
-    }
-  }
-  for (const enumName of Object.keys(before.enums)) {
-    if (!(enumName in after.enums)) {
-      changes.push({ type: "enum_removed", enumName });
-    }
-  }
-  for (const enumName of Object.keys(after.enums)) {
-    if (!(enumName in before.enums))
-      continue;
-    const beforeVals = before.enums[enumName];
-    const afterVals = after.enums[enumName];
-    if (!beforeVals || !afterVals)
-      continue;
-    const beforeSet = new Set(beforeVals);
-    const afterSet = new Set(afterVals);
-    const addedValues = afterVals.filter((v) => !beforeSet.has(v));
-    const removedValues = beforeVals.filter((v) => !afterSet.has(v));
-    if (addedValues.length > 0 || removedValues.length > 0) {
-      changes.push({ type: "enum_altered", enumName, addedValues, removedValues });
-    }
-  }
-  return { changes };
-}
-
-// src/migration/runner.ts
-import {
-  createMigrationQueryError,
-  err,
-  ok
-} from "@vertz/errors";
-var HISTORY_TABLE = "_vertz_migrations";
-function buildCreateHistorySql(dialect) {
-  if (dialect.name === "sqlite") {
-    return `
-CREATE TABLE IF NOT EXISTS "${HISTORY_TABLE}" (
-  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-  "name" TEXT NOT NULL UNIQUE,
-  "checksum" TEXT NOT NULL,
-  "applied_at" TEXT NOT NULL DEFAULT (datetime('now'))
-);
-`;
-  }
-  return `
-CREATE TABLE IF NOT EXISTS "${HISTORY_TABLE}" (
-  "id" serial PRIMARY KEY,
-  "name" text NOT NULL UNIQUE,
-  "checksum" text NOT NULL,
-  "applied_at" timestamp with time zone NOT NULL DEFAULT now()
-);
-`;
-}
-async function computeChecksum(sql) {
-  return sha256Hex(sql);
-}
-function parseMigrationName(filename) {
-  const match = filename.match(/^(\d+)_(.+)\.sql$/);
-  if (!match?.[1] || !match[2])
-    return null;
-  return {
-    timestamp: Number.parseInt(match[1], 10),
-    name: filename
-  };
-}
-function createMigrationRunner(options) {
-  const dialect = options?.dialect ?? defaultPostgresDialect;
-  const createHistorySql = buildCreateHistorySql(dialect);
-  return {
-    async createHistoryTable(queryFn) {
-      try {
-        await queryFn(createHistorySql, []);
-        return ok(undefined);
-      } catch (cause) {
-        return err(createMigrationQueryError("Failed to create migration history table", {
-          sql: createHistorySql,
-          cause
-        }));
-      }
-    },
-    async apply(queryFn, sql, name, options2) {
-      const checksum = await computeChecksum(sql);
-      const recordSql = `INSERT INTO "${HISTORY_TABLE}" ("name", "checksum") VALUES (${dialect.param(1)}, ${dialect.param(2)})`;
-      const statements = [sql, recordSql];
-      if (options2?.dryRun) {
-        return ok({
-          name,
-          sql,
-          checksum,
-          dryRun: true,
-          statements
-        });
-      }
-      try {
-        await queryFn(sql, []);
-        await queryFn(recordSql, [name, checksum]);
-        return ok({
-          name,
-          sql,
-          checksum,
-          dryRun: false,
-          statements
-        });
-      } catch (cause) {
-        return err(createMigrationQueryError(`Failed to apply migration: ${name}`, {
-          sql,
-          cause
-        }));
-      }
-    },
-    async getApplied(queryFn) {
-      try {
-        const result = await queryFn(`SELECT "name", "checksum", "applied_at" FROM "${HISTORY_TABLE}" ORDER BY "id" ASC`, []);
-        return ok(result.rows.map((row) => ({
-          name: row.name,
-          checksum: row.checksum,
-          appliedAt: new Date(row.applied_at)
-        })));
-      } catch (cause) {
-        return err(createMigrationQueryError("Failed to retrieve applied migrations", {
-          cause
-        }));
-      }
-    },
-    getPending(files, applied) {
-      const appliedNames = new Set(applied.map((a) => a.name));
-      return files.filter((f) => !appliedNames.has(f.name)).sort((a, b) => a.timestamp - b.timestamp);
-    },
-    async detectDrift(files, applied) {
-      const drifted = [];
-      const appliedMap = new Map(applied.map((a) => [a.name, a.checksum]));
-      for (const file of files) {
-        const appliedChecksum = appliedMap.get(file.name);
-        if (appliedChecksum && appliedChecksum !== await computeChecksum(file.sql)) {
-          drifted.push(file.name);
-        }
-      }
-      return drifted;
-    },
-    detectOutOfOrder(files, applied) {
-      if (applied.length === 0)
-        return [];
-      const appliedNames = new Set(applied.map((a) => a.name));
-      const lastApplied = applied[applied.length - 1];
-      if (!lastApplied)
-        return [];
-      const lastAppliedFile = files.find((f) => f.name === lastApplied.name);
-      if (!lastAppliedFile)
-        return [];
-      return files.filter((f) => !appliedNames.has(f.name) && f.timestamp < lastAppliedFile.timestamp).map((f) => f.name);
-    }
-  };
-}
-
-// src/migration/sql-generator.ts
-function escapeSqlString(value) {
-  return value.replace(/'/g, "''");
-}
-function isEnumType(col, enums) {
-  const typeLower = col.type.toLowerCase();
-  if (enums) {
-    for (const enumName of Object.keys(enums)) {
-      if (typeLower === enumName.toLowerCase() || typeLower === enumName) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function getEnumValues(col, enums) {
-  if (!enums)
-    return;
-  for (const [enumName, values] of Object.entries(enums)) {
-    if (col.type.toLowerCase() === enumName.toLowerCase() || col.type === enumName) {
-      return values;
-    }
-  }
-  return;
-}
-function columnDef(name, col, dialect, enums) {
-  const snakeName = camelToSnake(name);
-  const isEnum = isEnumType(col, enums);
-  let sqlType;
-  let checkConstraint;
-  if (isEnum && dialect.name === "sqlite") {
-    sqlType = dialect.mapColumnType("text");
-    const enumValues = getEnumValues(col, enums);
-    if (enumValues && enumValues.length > 0) {
-      const escapedValues = enumValues.map((v) => `'${escapeSqlString(v)}'`).join(", ");
-      checkConstraint = `CHECK("${snakeName}" IN (${escapedValues}))`;
-    }
-  } else {
-    if (dialect.name === "postgres" && col.type === col.type.toLowerCase()) {
-      sqlType = col.type;
-    } else {
-      const normalizedType = normalizeColumnType(col.type);
-      sqlType = dialect.mapColumnType(normalizedType);
-    }
-  }
-  const parts = [`"${snakeName}" ${sqlType}`];
-  if (checkConstraint) {
-    parts.push(checkConstraint);
-  }
-  if (!col.nullable) {
-    parts.push("NOT NULL");
-  }
-  if (col.unique) {
-    parts.push("UNIQUE");
-  }
-  if (col.default !== undefined) {
-    parts.push(`DEFAULT ${col.default}`);
-  }
-  return parts.join(" ");
-}
-function normalizeColumnType(type) {
-  const typeUpper = type.toUpperCase();
-  const typeMap = {
-    UUID: "uuid",
-    TEXT: "text",
-    INTEGER: "integer",
-    SERIAL: "serial",
-    BOOLEAN: "boolean",
-    TIMESTAMPTZ: "timestamp",
-    TIMESTAMP: "timestamp",
-    "DOUBLE PRECISION": "float",
-    JSONB: "json",
-    JSON: "json",
-    NUMERIC: "decimal",
-    REAL: "float",
-    VARCHAR: "varchar"
-  };
-  return typeMap[typeUpper] || type.toLowerCase();
-}
-function generateMigrationSql(changes, ctx, dialect = defaultPostgresDialect) {
-  const statements = [];
-  const tables = ctx?.tables;
-  const enums = ctx?.enums;
-  for (const change of changes) {
-    switch (change.type) {
-      case "enum_added": {
-        if (!change.enumName)
-          break;
-        if (dialect.name === "postgres") {
-          const values = enums?.[change.enumName];
-          if (!values || values.length === 0)
-            break;
-          const enumSnakeName = camelToSnake(change.enumName);
-          const valuesStr = values.map((v) => `'${escapeSqlString(v)}'`).join(", ");
-          statements.push(`CREATE TYPE "${enumSnakeName}" AS ENUM (${valuesStr});`);
-        }
-        break;
-      }
-      case "table_added": {
-        if (!change.table)
-          break;
-        const table = tables?.[change.table];
-        if (!table)
-          break;
-        const tableName = camelToSnake(change.table);
-        const cols = [];
-        const primaryKeys = [];
-        if (dialect.name === "postgres" && enums) {
-          for (const [, col] of Object.entries(table.columns)) {
-            if (isEnumType(col, enums)) {
-              const enumValues = getEnumValues(col, enums);
-              if (enumValues && enumValues.length > 0) {
-                const enumSnakeName = camelToSnake(col.type);
-                const alreadyEmitted = statements.some((s) => s.includes(`CREATE TYPE "${enumSnakeName}"`));
-                if (!alreadyEmitted) {
-                  const valuesStr = enumValues.map((v) => `'${escapeSqlString(v)}'`).join(", ");
-                  statements.push(`CREATE TYPE "${enumSnakeName}" AS ENUM (${valuesStr});`);
-                }
-              }
-            }
-          }
-        }
-        for (const [colName, col] of Object.entries(table.columns)) {
-          cols.push(`  ${columnDef(colName, col, dialect, enums)}`);
-          if (col.primary) {
-            primaryKeys.push(`"${camelToSnake(colName)}"`);
-          }
-        }
-        if (primaryKeys.length > 0) {
-          cols.push(`  PRIMARY KEY (${primaryKeys.join(", ")})`);
-        }
-        for (const fk of table.foreignKeys) {
-          const fkCol = camelToSnake(fk.column);
-          const fkTarget = camelToSnake(fk.targetTable);
-          const fkTargetCol = camelToSnake(fk.targetColumn);
-          cols.push(`  FOREIGN KEY ("${fkCol}") REFERENCES "${fkTarget}" ("${fkTargetCol}")`);
-        }
-        statements.push(`CREATE TABLE "${tableName}" (
-${cols.join(`,
-`)}
-);`);
-        for (const idx of table.indexes) {
-          const idxCols = idx.columns.map((c) => `"${camelToSnake(c)}"`).join(", ");
-          const idxName = `idx_${tableName}_${idx.columns.map((c) => camelToSnake(c)).join("_")}`;
-          statements.push(`CREATE INDEX "${idxName}" ON "${tableName}" (${idxCols});`);
-        }
-        break;
-      }
-      case "table_removed": {
-        if (!change.table)
-          break;
-        statements.push(`DROP TABLE "${camelToSnake(change.table)}";`);
-        break;
-      }
-      case "column_added": {
-        if (!change.table || !change.column)
-          break;
-        const col = tables?.[change.table]?.columns[change.column];
-        if (!col)
-          break;
-        statements.push(`ALTER TABLE "${camelToSnake(change.table)}" ADD COLUMN ${columnDef(change.column, col, dialect, enums)};`);
-        break;
-      }
-      case "column_removed": {
-        if (!change.table || !change.column)
-          break;
-        statements.push(`ALTER TABLE "${camelToSnake(change.table)}" DROP COLUMN "${camelToSnake(change.column)}";`);
-        break;
-      }
-      case "column_altered": {
-        if (!change.table || !change.column)
-          break;
-        const snakeTable = camelToSnake(change.table);
-        const snakeCol = camelToSnake(change.column);
-        if (change.newType !== undefined) {
-          statements.push(`ALTER TABLE "${snakeTable}" ALTER COLUMN "${snakeCol}" TYPE ${change.newType};`);
-        }
-        if (change.newNullable !== undefined) {
-          if (change.newNullable) {
-            statements.push(`ALTER TABLE "${snakeTable}" ALTER COLUMN "${snakeCol}" DROP NOT NULL;`);
-          } else {
-            statements.push(`ALTER TABLE "${snakeTable}" ALTER COLUMN "${snakeCol}" SET NOT NULL;`);
-          }
-        }
-        if (change.newDefault !== undefined) {
-          if (change.newDefault) {
-            statements.push(`ALTER TABLE "${snakeTable}" ALTER COLUMN "${snakeCol}" SET DEFAULT ${change.newDefault};`);
-          } else {
-            statements.push(`ALTER TABLE "${snakeTable}" ALTER COLUMN "${snakeCol}" DROP DEFAULT;`);
-          }
-        }
-        break;
-      }
-      case "column_renamed": {
-        if (!change.table || !change.oldColumn || !change.newColumn)
-          break;
-        statements.push(`ALTER TABLE "${camelToSnake(change.table)}" RENAME COLUMN "${camelToSnake(change.oldColumn)}" TO "${camelToSnake(change.newColumn)}";`);
-        break;
-      }
-      case "index_added": {
-        if (!change.table || !change.columns)
-          break;
-        const snakeTable = camelToSnake(change.table);
-        const idxCols = change.columns.map((c) => `"${camelToSnake(c)}"`).join(", ");
-        const idxName = `idx_${snakeTable}_${change.columns.map((c) => camelToSnake(c)).join("_")}`;
-        statements.push(`CREATE INDEX "${idxName}" ON "${snakeTable}" (${idxCols});`);
-        break;
-      }
-      case "index_removed": {
-        if (!change.table || !change.columns)
-          break;
-        const snakeTable = camelToSnake(change.table);
-        const idxName = `idx_${snakeTable}_${change.columns.map((c) => camelToSnake(c)).join("_")}`;
-        statements.push(`DROP INDEX "${idxName}";`);
-        break;
-      }
-      case "enum_removed": {
-        if (!change.enumName)
-          break;
-        if (dialect.name === "postgres") {
-          statements.push(`DROP TYPE "${camelToSnake(change.enumName)}";`);
-        }
-        break;
-      }
-      case "enum_altered": {
-        if (!change.enumName || !change.addedValues)
-          break;
-        if (dialect.name === "postgres") {
-          const enumSnakeName = camelToSnake(change.enumName);
-          for (const val of change.addedValues) {
-            statements.push(`ALTER TYPE "${enumSnakeName}" ADD VALUE '${escapeSqlString(val)}';`);
-          }
-        }
-        break;
-      }
-    }
-  }
-  return statements.join(`
-
-`);
-}
 // src/migration/files.ts
 function formatMigrationFilename(num, description) {
   return `${String(num).padStart(4, "0")}_${description}.sql`;
@@ -690,6 +163,13 @@ async function introspectSqlite(queryFn) {
       columns[colName] = colSnap;
     }
     const indexes = [];
+    const { rows: indexSqlRows } = await queryFn(`SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ?`, [tableName]);
+    const indexSqlMap = new Map;
+    for (const row2 of indexSqlRows) {
+      if (row2.name && row2.sql) {
+        indexSqlMap.set(row2.name, row2.sql);
+      }
+    }
     const { rows: indexRows } = await queryFn(`PRAGMA index_list("${validateIdentifier(tableName)}")`, []);
     for (const idx of indexRows) {
       const idxName = idx.name;
@@ -704,11 +184,19 @@ async function introspectSqlite(queryFn) {
         }
       }
       if (origin === "c") {
-        indexes.push({
+        const snap = {
           columns: idxColumns,
           name: idxName,
           unique: isUnique
-        });
+        };
+        const createSql = indexSqlMap.get(idxName);
+        if (createSql) {
+          const whereMatch = createSql.match(/\bWHERE\s+(.+)$/i);
+          if (whereMatch?.[1]) {
+            snap.where = whereMatch[1];
+          }
+        }
+        indexes.push(snap);
       }
     }
     const foreignKeys = [];
@@ -819,24 +307,36 @@ async function introspectPostgres(queryFn) {
     const indexes = [];
     const { rows: idxRows } = await queryFn(`SELECT i.relname AS index_name,
               array_agg(a.attname ORDER BY k.n) AS columns,
-              ix.indisunique AS is_unique
+              ix.indisunique AS is_unique,
+              am.amname AS access_method,
+              pg_get_expr(ix.indpred, ix.indrelid) AS predicate
        FROM pg_index ix
        JOIN pg_class i ON i.oid = ix.indexrelid
        JOIN pg_class t ON t.oid = ix.indrelid
        JOIN pg_namespace ns ON ns.oid = t.relnamespace
+       JOIN pg_am am ON am.oid = i.relam
        JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n) ON true
        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
        WHERE t.relname = $1
          AND ns.nspname = 'public'
          AND NOT ix.indisprimary
          AND NOT ix.indisunique
-       GROUP BY i.relname, ix.indisunique`, [tableName]);
+       GROUP BY i.relname, ix.indisunique, am.amname, ix.indpred, ix.indrelid`, [tableName]);
     for (const idx of idxRows) {
-      indexes.push({
+      const snap = {
         columns: idx.columns,
         name: idx.index_name,
         unique: idx.is_unique
-      });
+      };
+      const accessMethod = idx.access_method;
+      if (accessMethod && accessMethod !== "btree") {
+        snap.type = accessMethod;
+      }
+      const predicate = idx.predicate;
+      if (predicate) {
+        snap.where = predicate;
+      }
+      indexes.push(snap);
     }
     snapshot.tables[tableName] = {
       columns,
@@ -917,15 +417,57 @@ function detectCollisions(journal, existingFiles) {
   return collisions;
 }
 // src/migration/snapshot.ts
-function createSnapshot(tables) {
+function isModelDef(v) {
+  return v !== null && typeof v === "object" && "table" in v && "relations" in v && typeof v.table === "object";
+}
+function resolveTable(entry) {
+  return isModelDef(entry) ? entry.table : entry;
+}
+function resolveRelations(entry) {
+  return isModelDef(entry) ? entry.relations : {};
+}
+function findPkColumn(table) {
+  for (const [colName, col] of Object.entries(table._columns)) {
+    if (col._meta.primary)
+      return colName;
+  }
+  throw new Error(`Table "${table._name}" has no primary key column`);
+}
+function deriveForeignKeys(table, relations) {
+  const foreignKeys = [];
+  for (const [relName, rel] of Object.entries(relations)) {
+    if (rel._type !== "one")
+      continue;
+    if (!rel._foreignKey)
+      continue;
+    if (!(rel._foreignKey in table._columns)) {
+      throw new Error(`Relation "${relName}" on table "${table._name}" references column "${rel._foreignKey}" which does not exist`);
+    }
+    const targetTable = rel._target();
+    let targetColumn;
+    try {
+      targetColumn = findPkColumn(targetTable);
+    } catch {
+      throw new Error(`Target table "${targetTable._name}" referenced by relation "${relName}" on table "${table._name}" has no primary key column`);
+    }
+    foreignKeys.push({
+      column: rel._foreignKey,
+      targetTable: targetTable._name,
+      targetColumn
+    });
+  }
+  return foreignKeys;
+}
+function createSnapshot(entries) {
   const snapshot = {
     version: 1,
     tables: {},
     enums: {}
   };
-  for (const table of tables) {
+  for (const entry of entries) {
+    const table = resolveTable(entry);
+    const relations = resolveRelations(entry);
     const columns = {};
-    const foreignKeys = [];
     const indexes = [];
     for (const [colName, col] of Object.entries(table._columns)) {
       const meta = col._meta;
@@ -944,20 +486,23 @@ function createSnapshot(tables) {
         colSnap.annotations = annotationNames;
       }
       columns[colName] = colSnap;
-      if (meta.references) {
-        foreignKeys.push({
-          column: colName,
-          targetTable: meta.references.table,
-          targetColumn: meta.references.column
-        });
-      }
       if (meta.enumName && meta.enumValues) {
         snapshot.enums[meta.enumName] = [...meta.enumValues];
       }
     }
     for (const idx of table._indexes) {
-      indexes.push({ columns: [...idx.columns] });
-    }
+      const snap = { columns: [...idx.columns] };
+      if (idx.name)
+        snap.name = idx.name;
+      if (idx.unique)
+        snap.unique = idx.unique;
+      if (idx.type)
+        snap.type = idx.type;
+      if (idx.where)
+        snap.where = idx.where;
+      indexes.push(snap);
+    }
+    const foreignKeys = deriveForeignKeys(table, relations);
     snapshot.tables[table._name] = {
       columns,
       indexes,
@@ -1169,8 +714,8 @@ async function push(options) {
   return { sql, tablesAffected };
 }
 // src/cli/reset.ts
-import { createMigrationQueryError as createMigrationQueryError2, err as err2 } from "@vertz/errors";
-var HISTORY_TABLE2 = "_vertz_migrations";
+import { createMigrationQueryError, err } from "@vertz/errors";
+var HISTORY_TABLE = "_vertz_migrations";
 function getUserTablesQuery(dialect) {
   if (dialect.name === "sqlite") {
     return `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
@@ -1191,23 +736,23 @@ async function reset(options) {
     const tablesResult = await options.queryFn(getUserTablesQuery(dialect), []);
     tableNames = tablesResult.rows.map((row) => row.name);
   } catch (cause) {
-    return err2(createMigrationQueryError2("Failed to list user tables", { cause }));
+    return err(createMigrationQueryError("Failed to list user tables", { cause }));
   }
   const tablesDropped = [];
   for (const tableName of tableNames) {
     try {
       await options.queryFn(buildDropTableSql(tableName, dialect), []);
-      if (tableName !== HISTORY_TABLE2) {
+      if (tableName !== HISTORY_TABLE) {
         tablesDropped.push(tableName);
       }
     } catch (cause) {
-      return err2(createMigrationQueryError2(`Failed to drop table: ${tableName}`, { cause }));
+      return err(createMigrationQueryError(`Failed to drop table: ${tableName}`, { cause }));
     }
   }
   try {
-    await options.queryFn(buildDropTableSql(HISTORY_TABLE2, dialect), []);
+    await options.queryFn(buildDropTableSql(HISTORY_TABLE, dialect), []);
   } catch (cause) {
-    return err2(createMigrationQueryError2("Failed to drop history table", { cause }));
+    return err(createMigrationQueryError("Failed to drop history table", { cause }));
   }
   const createResult = await runner.createHistoryTable(options.queryFn);
   if (!createResult.ok) {
@@ -1405,7 +950,7 @@ async function migrateStatus(options) {
   };
 }
 // src/client/database.ts
-import { err as err3, ok as ok2 } from "@vertz/schema";
+import { err as err2, ok } from "@vertz/schema";
 // src/errors/error-codes.ts
 var DbErrorCode = {
   UNIQUE_VIOLATION: "23505",
@@ -2404,18 +1949,21 @@ function computeTenantGraph(registry) {
       shared.push(key);
       continue;
     }
-    const columns = entry.table._columns;
-    for (const colKey of Object.keys(columns)) {
-      const col = columns[colKey];
-      if (col._meta.isTenant && col._meta.references) {
-        if (!directlyScoped.includes(key)) {
-          directlyScoped.push(key);
-        }
-        const rootTableName = col._meta.references.table;
-        const rootKey = tableNameToKey.get(rootTableName);
-        if (rootKey && root === null) {
-          root = rootKey;
+    if (entry._tenant) {
+      const tenantRel = entry.relations[entry._tenant];
+      if (!tenantRel) {
+        throw new Error(`Model "${key}": tenant relation "${entry._tenant}" not found in relations`);
+      }
+      if (!directlyScoped.includes(key)) {
+        directlyScoped.push(key);
+      }
+      const rootTableName = tenantRel._target()._name;
+      const rootKey = tableNameToKey.get(rootTableName);
+      if (rootKey) {
+        if (root !== null && root !== rootKey) {
+          throw new Error(`Conflicting tenant roots: "${root}" and "${rootKey}". All tenant declarations must point to the same root table.`);
         }
+        root = rootKey;
       }
     }
   }
@@ -2441,18 +1989,14 @@ function computeTenantGraph(registry) {
       if (key === root || directlyScoped.includes(key) || shared.includes(key) || indirectlyScopedNames.has(entry.table._name)) {
         continue;
       }
-      const columns = entry.table._columns;
-      for (const colKey of Object.keys(columns)) {
-        const col = columns[colKey];
-        if (col._meta.references && !col._meta.isTenant) {
-          const refTable = col._meta.references.table;
-          if (scopedTableNames.has(refTable) || indirectlyScopedNames.has(refTable)) {
-            indirectlyScoped.push(key);
-            indirectlyScopedNames.add(entry.table._name);
-            scopedTableNames.add(entry.table._name);
-            changed = true;
-            break;
-          }
+      for (const rel of Object.values(entry.relations)) {
+        const targetTableName = rel._target()._name;
+        if (scopedTableNames.has(targetTableName) || indirectlyScopedNames.has(targetTableName)) {
+          indirectlyScoped.push(key);
+          indirectlyScopedNames.add(entry.table._name);
+          scopedTableNames.add(entry.table._name);
+          changed = true;
+          break;
         }
       }
     }
@@ -2591,8 +2135,8 @@ function createDb(options) {
           replicaIndex = (replicaIndex + 1) % replicaDrivers.length;
           try {
             return await targetReplica.queryFn(sqlStr, params);
-          } catch (err4) {
-            console.warn("[vertz/db] replica query failed, falling back to primary:", err4.message);
+          } catch (err3) {
+            console.warn("[vertz/db] replica query failed, falling back to primary:", err3.message);
           }
         }
         if (!driver) {
@@ -2612,11 +2156,11 @@ function createDb(options) {
         const result = await get(queryFn, entry.table, opts, dialectObj);
         if (result !== null && opts?.include) {
           const rows = await loadRelations(queryFn, [result], entry.relations, opts.include, 0, modelsRegistry, entry.table);
-          return ok2(rows[0] ?? null);
+          return ok(rows[0] ?? null);
         }
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2626,7 +2170,7 @@ function createDb(options) {
         const entry = resolveModel(models, name);
         const result = await get(queryFn, entry.table, opts, dialectObj);
         if (result === null) {
-          return err3({
+          return err2({
             code: "NotFound",
             message: `Record not found in table ${name}`,
             table: name
@@ -2634,11 +2178,11 @@ function createDb(options) {
         }
         if (opts?.include) {
           const rows = await loadRelations(queryFn, [result], entry.relations, opts.include, 0, modelsRegistry, entry.table);
-          return ok2(rows[0]);
+          return ok(rows[0]);
         }
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2649,11 +2193,11 @@ function createDb(options) {
         const results = await list(queryFn, entry.table, opts, dialectObj);
         if (opts?.include && results.length > 0) {
           const withRelations = await loadRelations(queryFn, results, entry.relations, opts.include, 0, modelsRegistry, entry.table);
-          return ok2(withRelations);
+          return ok(withRelations);
         }
-        return ok2(results);
+        return ok(results);
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2664,11 +2208,11 @@ function createDb(options) {
         const { data, total } = await listAndCount(queryFn, entry.table, opts, dialectObj);
         if (opts?.include && data.length > 0) {
           const withRelations = await loadRelations(queryFn, data, entry.relations, opts.include, 0, modelsRegistry, entry.table);
-          return ok2({ data: withRelations, total });
+          return ok({ data: withRelations, total });
         }
-        return ok2({ data, total });
+        return ok({ data, total });
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2677,9 +2221,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await create(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2688,9 +2232,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await createMany(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2699,9 +2243,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await createManyAndReturn(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2710,9 +2254,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await update(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2721,9 +2265,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await updateMany(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2732,9 +2276,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await upsert(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2743,9 +2287,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await deleteOne(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2754,9 +2298,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await deleteMany(queryFn, entry.table, opts, dialectObj);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toWriteError(e));
+        return err2(toWriteError(e));
       }
     })();
   }
@@ -2765,9 +2309,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await count(queryFn, entry.table, opts);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2776,9 +2320,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await aggregate(queryFn, entry.table, opts);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2787,9 +2331,9 @@ function createDb(options) {
       try {
         const entry = resolveModel(models, name);
         const result = await groupBy(queryFn, entry.table, opts);
-        return ok2(result);
+        return ok(result);
       } catch (e) {
-        return err3(toReadError(e));
+        return err2(toReadError(e));
       }
     })();
   }
@@ -2816,9 +2360,9 @@ function createDb(options) {
   client.query = async (fragment) => {
     try {
       const result = await executeQuery(queryFn, fragment.sql, fragment.params);
-      return ok2(result);
+      return ok(result);
     } catch (e) {
-      return err3(toReadError(e, fragment.sql));
+      return err2(toReadError(e, fragment.sql));
     }
   };
   client.close = async () => {
@@ -2883,11 +2427,6 @@ function createColumnWithMeta(meta) {
     },
     check(sql) {
       return cloneWith(this, { check: sql });
-    },
-    references(table, column) {
-      return cloneWith(this, {
-        references: { table, column: column ?? "id" }
-      });
     }
   };
   return col;
@@ -2902,8 +2441,6 @@ function defaultMeta(sqlType) {
     _annotations: {},
     isReadOnly: false,
     isAutoUpdate: false,
-    isTenant: false,
-    references: null,
     check: null
   };
 }
@@ -2923,23 +2460,6 @@ function createSerialColumn() {
     _annotations: {},
     isReadOnly: false,
     isAutoUpdate: false,
-    isTenant: false,
-    references: null,
-    check: null
-  });
-}
-function createTenantColumn(targetTableName) {
-  return createColumnWithMeta({
-    sqlType: "uuid",
-    primary: false,
-    unique: false,
-    nullable: false,
-    hasDefault: false,
-    _annotations: {},
-    isReadOnly: false,
-    isAutoUpdate: false,
-    isTenant: true,
-    references: { table: targetTableName, column: "id" },
     check: null
   });
 }
@@ -3022,11 +2542,12 @@ function getColumnNamesWithAnnotation(table, annotation) {
 }
 
 // src/schema/model.ts
-function createModel(table, relations) {
+function createModel(table, relations, options) {
   return {
     table,
     relations: relations ?? {},
-    schemas: deriveSchemas(table)
+    schemas: deriveSchemas(table),
+    _tenant: options?.tenant ?? null
   };
 }
 
@@ -3061,7 +2582,11 @@ function createManyRelation(target, foreignKey) {
 }
 
 // src/schema/table.ts
+var DANGEROUS_SQL_PATTERN = /;|--|\b(DROP|DELETE|INSERT|UPDATE|ALTER|CREATE|EXEC)\b/i;
 function createIndex(columns, options) {
+  if (options?.where && DANGEROUS_SQL_PATTERN.test(options.where)) {
+    throw new Error(`Unsafe WHERE clause expression in index: "${options.where}"`);
+  }
   return {
     columns: Array.isArray(columns) ? columns : [columns],
     ...options
@@ -3136,9 +2661,8 @@ var d = {
       enumValues: values
     });
   },
-  tenant: (targetTable) => createTenantColumn(targetTable._name),
   table: (name, columns, options) => createTable(name, columns, options),
-  index: (columns) => createIndex(columns),
+  index: (columns, options) => createIndex(columns, options),
   ref: {
     one: (target, foreignKey) => createOneRelation(target, foreignKey),
     many: (target, foreignKey) => createManyRelation(target, foreignKey)
@@ -3147,7 +2671,7 @@ var d = {
     table,
     relations
   }),
-  model: (table, relations = {}) => createModel(table, relations)
+  model: (table, relations = {}, options) => createModel(table, relations, options)
 };
 // src/schema/define-annotations.ts
 function defineAnnotations(...annotations) {
@@ -3192,6 +2716,7 @@ function createRegistry(tables, relationsCallback) {
   return result;
 }
 export {
+  validateIndexes,
   toWriteError,
   toReadError,
   resolveErrorCode,