@b9g/zen 0.1.0

package/src/bun.js

@@ -0,0 +1,906 @@
+/// <reference types="./bun.d.ts" />
+import {
+  placeholder,
+  quoteIdent,
+  renderDDL
+} from "../chunk-2IEEEMRN.js";
+import {
+  generateDDL
+} from "../chunk-QXGEP5PB.js";
+import {
+  resolveSQLBuiltin
+} from "../chunk-56M5Z3A6.js";
+
+// src/bun.ts
+import { SQL } from "bun";
+import {
+  ConstraintViolationError,
+  EnsureError,
+  SchemaDriftError,
+  ConstraintPreflightError,
+  isSQLBuiltin,
+  isSQLIdentifier
+} from "./zen.js";
+function detectDialect(url) {
+  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
+    return "postgresql";
+  }
+  if (url.startsWith("mysql://") || url.startsWith("mysql2://") || url.startsWith("mariadb://")) {
+    return "mysql";
+  }
+  return "sqlite";
+}
+function buildSQL(strings, values, dialect) {
+  let sql = strings[0];
+  const params = [];
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    if (isSQLBuiltin(value)) {
+      sql += resolveSQLBuiltin(value) + strings[i + 1];
+    } else if (isSQLIdentifier(value)) {
+      sql += quoteIdent(value.name, dialect) + strings[i + 1];
+    } else {
+      sql += placeholder(params.length + 1, dialect) + strings[i + 1];
+      params.push(value);
+    }
+  }
+  return { sql, params };
+}
+var BunDriver = class {
+  supportsReturning;
+  #dialect;
+  #sql;
+  #sqliteInitialized = false;
+  constructor(url, options) {
+    this.#dialect = detectDialect(url);
+    this.#sql = new SQL(url, options);
+    this.supportsReturning = this.#dialect !== "mysql";
+  }
+  /**
+   * Ensure SQLite connection has foreign keys enabled.
+   * Called lazily on first query to avoid async constructor.
+   */
+  async #ensureSqliteInit() {
+    if (this.#dialect !== "sqlite" || this.#sqliteInitialized) {
+      return;
+    }
+    this.#sqliteInitialized = true;
+    await this.#sql.unsafe("PRAGMA foreign_keys = ON", []);
+  }
+  /**
+   * Convert database errors to Zealot errors.
+   */
+  #handleError(error) {
+    if (error && typeof error === "object" && "code" in error) {
+      const code = error.code;
+      const errno = error.errno;
+      const message = error.message || String(error);
+      if (this.#dialect === "sqlite") {
+        if (code === "SQLITE_CONSTRAINT" || code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_FOREIGNKEY") {
+          const match = message.match(/constraint failed: (\w+)\.(\w+)/i);
+          const table = match ? match[1] : void 0;
+          const column = match ? match[2] : void 0;
+          const constraint = match ? `${table}.${column}` : void 0;
+          let kind = "unknown";
+          if (code === "SQLITE_CONSTRAINT_UNIQUE")
+            kind = "unique";
+          else if (code === "SQLITE_CONSTRAINT_FOREIGNKEY")
+            kind = "foreign_key";
+          else if (message.includes("UNIQUE"))
+            kind = "unique";
+          else if (message.includes("FOREIGN KEY"))
+            kind = "foreign_key";
+          else if (message.includes("NOT NULL"))
+            kind = "not_null";
+          else if (message.includes("CHECK"))
+            kind = "check";
+          throw new ConstraintViolationError(
+            message,
+            {
+              kind,
+              constraint,
+              table,
+              column
+            },
+            {
+              cause: error
+            }
+          );
+        }
+      } else if (this.#dialect === "postgresql") {
+        const pgCode = errno || code;
+        if (pgCode === "23505" || pgCode === "23503" || pgCode === "23514" || pgCode === "23502") {
+          const constraint = error.constraint_name || error.constraint;
+          const table = error.table_name || error.table;
+          const column = error.column_name || error.column;
+          let kind = "unknown";
+          if (pgCode === "23505")
+            kind = "unique";
+          else if (pgCode === "23503")
+            kind = "foreign_key";
+          else if (pgCode === "23514")
+            kind = "check";
+          else if (pgCode === "23502")
+            kind = "not_null";
+          throw new ConstraintViolationError(
+            message,
+            {
+              kind,
+              constraint,
+              table,
+              column
+            },
+            {
+              cause: error
+            }
+          );
+        }
+      } else if (this.#dialect === "mysql") {
+        if (code === "ER_DUP_ENTRY" || code === "ER_NO_REFERENCED_ROW_2" || code === "ER_ROW_IS_REFERENCED_2" || errno === 1062 || errno === 1452 || errno === 1451) {
+          let kind = "unknown";
+          let constraint;
+          let table;
+          let column;
+          if (code === "ER_DUP_ENTRY" || errno === 1062) {
+            kind = "unique";
+            const keyMatch = message.match(/for key '([^']+)'/i);
+            constraint = keyMatch ? keyMatch[1] : void 0;
+            if (constraint) {
+              const parts = constraint.split(".");
+              if (parts.length > 1) {
+                table = parts[0];
+              }
+            }
+          } else if (code === "ER_NO_REFERENCED_ROW_2" || code === "ER_ROW_IS_REFERENCED_2" || errno === 1452 || errno === 1451) {
+            kind = "foreign_key";
+            const constraintMatch = message.match(/CONSTRAINT `([^`]+)`/i);
+            constraint = constraintMatch ? constraintMatch[1] : void 0;
+            const tableMatch = message.match(/`([^`]+)`\.`([^`]+)`/);
+            if (tableMatch) {
+              table = tableMatch[2];
+            }
+          }
+          throw new ConstraintViolationError(
+            message,
+            {
+              kind,
+              constraint,
+              table,
+              column
+            },
+            {
+              cause: error
+            }
+          );
+        }
+      }
+    }
+    throw error;
+  }
+  async all(strings, values) {
+    await this.#ensureSqliteInit();
+    try {
+      const { sql, params } = buildSQL(strings, values, this.#dialect);
+      const result = await this.#sql.unsafe(sql, params);
+      return result;
+    } catch (error) {
+      this.#handleError(error);
+    }
+  }
+  async get(strings, values) {
+    await this.#ensureSqliteInit();
+    try {
+      const { sql, params } = buildSQL(strings, values, this.#dialect);
+      const result = await this.#sql.unsafe(sql, params);
+      return result[0] ?? null;
+    } catch (error) {
+      this.#handleError(error);
+    }
+  }
+  async run(strings, values) {
+    await this.#ensureSqliteInit();
+    try {
+      const { sql, params } = buildSQL(strings, values, this.#dialect);
+      const result = await this.#sql.unsafe(sql, params);
+      if (this.#dialect === "mysql") {
+        return result.affectedRows ?? result.length;
+      }
+      return result.count ?? result.length;
+    } catch (error) {
+      this.#handleError(error);
+    }
+  }
+  async val(strings, values) {
+    await this.#ensureSqliteInit();
+    try {
+      const { sql, params } = buildSQL(strings, values, this.#dialect);
+      const result = await this.#sql.unsafe(sql, params);
+      if (result.length === 0)
+        return null;
+      const row = result[0];
+      const firstKey = Object.keys(row)[0];
+      return row[firstKey];
+    } catch (error) {
+      this.#handleError(error);
+    }
+  }
+  async close() {
+    await this.#sql.close();
+  }
+  async transaction(fn) {
+    const dialect = this.#dialect;
+    const handleError = this.#handleError.bind(this);
+    const supportsReturning = this.supportsReturning;
+    return await this.#sql.transaction(async (txSql) => {
+      const txDriver = {
+        supportsReturning,
+        all: async (strings, values) => {
+          try {
+            const { sql, params } = buildSQL(strings, values, dialect);
+            const result = await txSql.unsafe(sql, params);
+            return result;
+          } catch (error) {
+            return handleError(error);
+          }
+        },
+        get: async (strings, values) => {
+          try {
+            const { sql, params } = buildSQL(strings, values, dialect);
+            const result = await txSql.unsafe(sql, params);
+            return result[0] ?? null;
+          } catch (error) {
+            return handleError(error);
+          }
+        },
+        run: async (strings, values) => {
+          try {
+            const { sql, params } = buildSQL(strings, values, dialect);
+            const result = await txSql.unsafe(sql, params);
+            return result.count ?? result.affectedRows ?? result.length;
+          } catch (error) {
+            return handleError(error);
+          }
+        },
+        val: async (strings, values) => {
+          try {
+            const { sql, params } = buildSQL(strings, values, dialect);
+            const result = await txSql.unsafe(sql, params);
+            if (result.length === 0)
+              return null;
+            const row = result[0];
+            const firstKey = Object.keys(row)[0];
+            return row[firstKey];
+          } catch (error) {
+            return handleError(error);
+          }
+        },
+        close: async () => {
+        },
+        transaction: async () => {
+          throw new Error("Nested transactions are not supported");
+        }
+      };
+      return await fn(txDriver);
+    });
+  }
+  async withMigrationLock(fn) {
+    await this.#ensureSqliteInit();
+    if (this.#dialect === "postgresql") {
+      const MIGRATION_LOCK_ID = 1952393421;
+      await this.#sql.unsafe(`SELECT pg_advisory_lock($1)`, [
+        MIGRATION_LOCK_ID
+      ]);
+      try {
+        return await fn();
+      } finally {
+        await this.#sql.unsafe(`SELECT pg_advisory_unlock($1)`, [
+          MIGRATION_LOCK_ID
+        ]);
+      }
+    } else if (this.#dialect === "mysql") {
+      const LOCK_NAME = "zen_migration";
+      const LOCK_TIMEOUT = 10;
+      const result = await this.#sql.unsafe(`SELECT GET_LOCK(?, ?)`, [
+        LOCK_NAME,
+        LOCK_TIMEOUT
+      ]);
+      const acquired = result[0]?.["GET_LOCK(?, ?)"] === 1;
+      if (!acquired) {
+        throw new Error(
+          `Failed to acquire migration lock after ${LOCK_TIMEOUT}s. Another migration may be in progress.`
+        );
+      }
+      try {
+        return await fn();
+      } finally {
+        await this.#sql.unsafe(`SELECT RELEASE_LOCK(?)`, [LOCK_NAME]);
+      }
+    } else {
+      await this.#sql.unsafe("BEGIN EXCLUSIVE", []);
+      try {
+        const result = await fn();
+        await this.#sql.unsafe("COMMIT", []);
+        return result;
+      } catch (error) {
+        await this.#sql.unsafe("ROLLBACK", []);
+        throw error;
+      }
+    }
+  }
+  // ==========================================================================
+  // Schema Ensure Methods
+  // ==========================================================================
+  async ensureTable(table) {
+    await this.#ensureSqliteInit();
+    const tableName = table.name;
+    let step = 0;
+    let applied = false;
+    try {
+      const exists = await this.#tableExists(tableName);
+      if (!exists) {
+        step = 1;
+        const ddlTemplate = generateDDL(table, { dialect: this.#dialect });
+        const ddlSQL = renderDDL(
+          ddlTemplate[0],
+          ddlTemplate.slice(1),
+          this.#dialect
+        );
+        for (const stmt of ddlSQL.split(";").filter((s) => s.trim())) {
+          await this.#sql.unsafe(stmt.trim(), []);
+        }
+        applied = true;
+      } else {
+        step = 2;
+        const columnsApplied = await this.#ensureMissingColumns(table);
+        applied = applied || columnsApplied;
+        step = 3;
+        const indexesApplied = await this.#ensureMissingIndexes(table);
+        applied = applied || indexesApplied;
+        step = 4;
+        await this.#checkMissingConstraints(table);
+      }
+      return { applied };
+    } catch (error) {
+      if (error instanceof SchemaDriftError || error instanceof EnsureError) {
+        throw error;
+      }
+      throw new EnsureError(
+        `ensureTable failed at step ${step}: ${error instanceof Error ? error.message : String(error)}`,
+        { operation: "ensureTable", table: tableName, step },
+        { cause: error }
+      );
+    }
+  }
+  async ensureConstraints(table) {
+    await this.#ensureSqliteInit();
+    const tableName = table.name;
+    let step = 0;
+    let applied = false;
+    try {
+      const exists = await this.#tableExists(tableName);
+      if (!exists) {
+        throw new Error(
+          `Table "${tableName}" does not exist. Run ensureTable() first.`
+        );
+      }
+      step = 1;
+      const existingConstraints = await this.#getConstraints(tableName);
+      step = 2;
+      const uniquesApplied = await this.#ensureUniqueConstraints(
+        table,
+        existingConstraints
+      );
+      applied = applied || uniquesApplied;
+      step = 3;
+      const fksApplied = await this.#ensureForeignKeys(
+        table,
+        existingConstraints
+      );
+      applied = applied || fksApplied;
+      return { applied };
+    } catch (error) {
+      if (error instanceof ConstraintPreflightError || error instanceof EnsureError) {
+        throw error;
+      }
+      throw new EnsureError(
+        `ensureConstraints failed at step ${step}: ${error instanceof Error ? error.message : String(error)}`,
+        { operation: "ensureConstraints", table: tableName, step },
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Optional introspection: list columns for a table.
+   * Exposed for Database-level helpers that need column existence checks.
+   */
+  async getColumns(tableName) {
+    return await this.#getColumns(tableName);
+  }
+  // ==========================================================================
+  // Introspection Helpers (private)
+  // ==========================================================================
+  async #tableExists(tableName) {
+    await this.#ensureSqliteInit();
+    if (this.#dialect === "sqlite") {
+      const result = await this.#sql.unsafe(
+        `SELECT 1 FROM sqlite_master WHERE type='table' AND name=?`,
+        [tableName]
+      );
+      return result.length > 0;
+    } else if (this.#dialect === "postgresql") {
+      const result = await this.#sql.unsafe(
+        `SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = 'public'`,
+        [tableName]
+      );
+      return result.length > 0;
+    } else {
+      const result = await this.#sql.unsafe(
+        `SELECT 1 FROM information_schema.tables WHERE table_name = ? AND table_schema = DATABASE()`,
+        [tableName]
+      );
+      return result.length > 0;
+    }
+  }
+  async #getColumns(tableName) {
+    await this.#ensureSqliteInit();
+    if (this.#dialect === "sqlite") {
+      const result = await this.#sql.unsafe(
+        `PRAGMA table_info(${quoteIdent(tableName, "sqlite")})`,
+        []
+      );
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type,
+        notnull: row.notnull === 1
+      }));
+    } else if (this.#dialect === "postgresql") {
+      const result = await this.#sql.unsafe(
+        `SELECT column_name as name, data_type as type, is_nullable = 'NO' as notnull
+				 FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public'`,
+        [tableName]
+      );
+      return result;
+    } else {
+      const result = await this.#sql.unsafe(
+        `SELECT column_name as name, data_type as type, is_nullable = 'NO' as notnull
+				 FROM information_schema.columns WHERE table_name = ? AND table_schema = DATABASE()`,
+        [tableName]
+      );
+      return result;
+    }
+  }
+  async #getIndexes(tableName) {
+    await this.#ensureSqliteInit();
+    if (this.#dialect === "sqlite") {
+      const indexList = await this.#sql.unsafe(
+        `PRAGMA index_list(${quoteIdent(tableName, "sqlite")})`,
+        []
+      );
+      const indexes = [];
+      for (const idx of indexList) {
+        if (idx.origin === "pk")
+          continue;
+        const indexInfo = await this.#sql.unsafe(
+          `PRAGMA index_info(${quoteIdent(idx.name, "sqlite")})`,
+          []
+        );
+        indexes.push({
+          name: idx.name,
+          columns: indexInfo.map((col) => col.name),
+          unique: idx.unique === 1
+        });
+      }
+      return indexes;
+    } else if (this.#dialect === "postgresql") {
+      const result = await this.#sql.unsafe(
+        `SELECT i.relname as name,
+				        array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) as columns,
+				        ix.indisunique as unique
+				 FROM pg_index ix
+				 JOIN pg_class i ON i.oid = ix.indexrelid
+				 JOIN pg_class t ON t.oid = ix.indrelid
+				 JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+				 WHERE t.relname = $1 AND NOT ix.indisprimary
+				 GROUP BY i.relname, ix.indisunique`,
+        [tableName]
+      );
+      return result;
+    } else {
+      const result = await this.#sql.unsafe(
+        `SELECT index_name as name,
+				        GROUP_CONCAT(column_name ORDER BY seq_in_index) as columns,
+				        NOT non_unique as \`unique\`
+				 FROM information_schema.statistics
+				 WHERE table_name = ? AND table_schema = DATABASE() AND index_name != 'PRIMARY'
+				 GROUP BY index_name, non_unique`,
+        [tableName]
+      );
+      return result.map((row) => ({
+        ...row,
+        columns: row.columns.split(",")
+      }));
+    }
+  }
+  async #getConstraints(tableName) {
+    await this.#ensureSqliteInit();
+    if (this.#dialect === "sqlite") {
+      const constraints = [];
+      const indexes = await this.#getIndexes(tableName);
+      for (const idx of indexes) {
+        if (idx.unique) {
+          constraints.push({
+            name: idx.name,
+            type: "unique",
+            columns: idx.columns
+          });
+        }
+      }
+      const fks = await this.#sql.unsafe(
+        `PRAGMA foreign_key_list(${quoteIdent(tableName, "sqlite")})`,
+        []
+      );
+      const fkMap = /* @__PURE__ */ new Map();
+      for (const fk of fks) {
+        if (!fkMap.has(fk.id)) {
+          fkMap.set(fk.id, { table: fk.table, from: [], to: [] });
+        }
+        const entry = fkMap.get(fk.id);
+        entry.from.push(fk.from);
+        entry.to.push(fk.to);
+      }
+      for (const [id, fk] of fkMap) {
+        constraints.push({
+          name: `fk_${tableName}_${id}`,
+          type: "foreign_key",
+          columns: fk.from,
+          referencedTable: fk.table,
+          referencedColumns: fk.to
+        });
+      }
+      return constraints;
+    } else if (this.#dialect === "postgresql") {
+      const result = await this.#sql.unsafe(
+        `SELECT
+				   tc.constraint_name as name,
+				   tc.constraint_type as type,
+				   array_agg(kcu.column_name ORDER BY kcu.ordinal_position) as columns,
+				   ccu.table_name as referenced_table,
+				   array_agg(ccu.column_name ORDER BY kcu.ordinal_position) as referenced_columns
+				 FROM information_schema.table_constraints tc
+				 JOIN information_schema.key_column_usage kcu
+				   ON tc.constraint_name = kcu.constraint_name
+				   AND tc.table_schema = kcu.table_schema
+				   AND tc.table_name = kcu.table_name
+				 LEFT JOIN information_schema.constraint_column_usage ccu
+				   ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
+				 WHERE tc.table_name = $1 AND tc.table_schema = 'public'
+				   AND tc.constraint_type IN ('UNIQUE', 'FOREIGN KEY')
+				 GROUP BY tc.constraint_name, tc.constraint_type, ccu.table_name`,
+        [tableName]
+      );
+      const parseArray = (s) => {
+        if (!s)
+          return [];
+        return s.replace(/^\{|\}$/g, "").split(",").filter(Boolean);
+      };
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type === "UNIQUE" ? "unique" : "foreign_key",
+        columns: parseArray(row.columns),
+        referencedTable: row.referenced_table,
+        referencedColumns: parseArray(row.referenced_columns)
+      }));
+    } else {
+      const result = await this.#sql.unsafe(
+        `SELECT
+				   tc.constraint_name as name,
+				   tc.constraint_type as type,
+				   GROUP_CONCAT(DISTINCT kcu.column_name ORDER BY kcu.ordinal_position) as columns,
+				   kcu.referenced_table_name as referenced_table,
+				   GROUP_CONCAT(DISTINCT kcu.referenced_column_name ORDER BY kcu.ordinal_position) as referenced_columns
+				 FROM information_schema.table_constraints tc
+				 JOIN information_schema.key_column_usage kcu
+				   ON tc.constraint_name = kcu.constraint_name
+				   AND tc.table_schema = kcu.table_schema
+				   AND tc.table_name = kcu.table_name
+				 WHERE tc.table_name = ? AND tc.table_schema = DATABASE()
+				   AND tc.constraint_type IN ('UNIQUE', 'FOREIGN KEY')
+				 GROUP BY tc.constraint_name, tc.constraint_type, kcu.referenced_table_name`,
+        [tableName]
+      );
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type === "UNIQUE" ? "unique" : "foreign_key",
+        columns: row.columns.split(","),
+        referencedTable: row.referenced_table,
+        referencedColumns: row.referenced_columns?.split(",")
+      }));
+    }
+  }
+  // ==========================================================================
+  // Schema Ensure Helpers (private)
+  // ==========================================================================
+  async #ensureMissingColumns(table) {
+    const existingCols = await this.#getColumns(table.name);
+    const existingColNames = new Set(existingCols.map((c) => c.name));
+    const schemaFields = Object.keys(table.schema.shape);
+    let applied = false;
+    for (const fieldName of schemaFields) {
+      if (!existingColNames.has(fieldName)) {
+        await this.#addColumn(table, fieldName);
+        applied = true;
+      }
+    }
+    return applied;
+  }
+  async #addColumn(table, fieldName) {
+    const { generateColumnDDL } = await import("../ddl-NAJM37GQ.js");
+    const zodType = table.schema.shape[fieldName];
+    const fieldMeta = table.meta.fields[fieldName] || {};
+    const colTemplate = generateColumnDDL(
+      fieldName,
+      zodType,
+      fieldMeta,
+      this.#dialect
+    );
+    const colSQL = renderDDL(
+      colTemplate[0],
+      colTemplate.slice(1),
+      this.#dialect
+    );
+    const ifNotExists = this.#dialect === "postgresql" ? "IF NOT EXISTS " : "";
+    const sql = `ALTER TABLE ${quoteIdent(table.name, this.#dialect)} ADD COLUMN ${ifNotExists}${colSQL}`;
+    await this.#sql.unsafe(sql, []);
+  }
+  async #ensureMissingIndexes(table) {
+    const existingIndexes = await this.#getIndexes(table.name);
+    const existingIndexNames = new Set(existingIndexes.map((i) => i.name));
+    const meta = table.meta;
+    let applied = false;
+    for (const fieldName of meta.indexed) {
+      const indexName = `idx_${table.name}_${fieldName}`;
+      if (!existingIndexNames.has(indexName)) {
+        await this.#createIndex(table.name, indexName, [fieldName], false);
+        applied = true;
+      }
+    }
+    for (const indexCols of table.indexes) {
+      const indexName = `idx_${table.name}_${indexCols.join("_")}`;
+      if (!existingIndexNames.has(indexName)) {
+        await this.#createIndex(table.name, indexName, indexCols, false);
+        applied = true;
+      }
+    }
+    return applied;
+  }
+  async #createIndex(tableName, indexName, columns, unique) {
+    const uniqueKw = unique ? "UNIQUE " : "";
+    const colList = columns.map((c) => quoteIdent(c, this.#dialect)).join(", ");
+    const ifNotExists = this.#dialect === "mysql" ? "" : "IF NOT EXISTS ";
+    const sql = `CREATE ${uniqueKw}INDEX ${ifNotExists}${quoteIdent(indexName, this.#dialect)} ON ${quoteIdent(tableName, this.#dialect)} (${colList})`;
+    await this.#sql.unsafe(sql, []);
+  }
+  async #checkMissingConstraints(table) {
+    const existingConstraints = await this.#getConstraints(table.name);
+    const meta = table.meta;
+    const fields = Object.keys(meta.fields);
+    for (const fieldName of fields) {
+      const fieldMeta = meta.fields[fieldName];
+      if (fieldMeta.unique) {
+        const hasUnique = existingConstraints.some(
+          (c) => c.type === "unique" && c.columns.length === 1 && c.columns[0] === fieldName
+        );
+        if (!hasUnique) {
+          throw new SchemaDriftError(
+            `Table "${table.name}" is missing UNIQUE constraint on column "${fieldName}"`,
+            {
+              table: table.name,
+              drift: `missing unique:${fieldName}`,
+              suggestion: `Run db.ensureConstraints(${table.name}) to apply constraints`
+            }
+          );
+        }
+      }
+    }
+    for (const ref of meta.references) {
+      const hasFk = existingConstraints.some(
+        (c) => c.type === "foreign_key" && c.columns.length === 1 && c.columns[0] === ref.fieldName && c.referencedTable === ref.table.name && c.referencedColumns?.[0] === ref.referencedField
+      );
+      if (!hasFk) {
+        throw new SchemaDriftError(
+          `Table "${table.name}" is missing FOREIGN KEY on column "${ref.fieldName}" referencing "${ref.table.name}"`,
+          {
+            table: table.name,
+            drift: `missing fk:${ref.fieldName}->${ref.table.name}`,
+            suggestion: `Run db.ensureConstraints(${table.name}) to apply constraints`
+          }
+        );
+      }
+    }
+    for (const ref of table.compoundReferences) {
+      const refFields = ref.referencedFields ?? ref.fields;
+      const hasFk = existingConstraints.some((c) => {
+        if (c.type !== "foreign_key")
+          return false;
+        if (c.columns.length !== ref.fields.length)
+          return false;
+        if (c.referencedTable !== ref.table.name)
+          return false;
+        if (!ref.fields.every((field, i) => c.columns[i] === field))
+          return false;
+        return refFields.every(
+          (field, i) => c.referencedColumns?.[i] === field
+        );
+      });
+      if (!hasFk) {
+        throw new SchemaDriftError(
+          `Table "${table.name}" is missing compound FOREIGN KEY on columns (${ref.fields.join(", ")}) referencing "${ref.table.name}"`,
+          {
+            table: table.name,
+            drift: `missing fk:(${ref.fields.join(",")}) ->${ref.table.name}`,
+            suggestion: `Run db.ensureConstraints(${table.name}) to apply constraints`
+          }
+        );
+      }
+    }
+  }
+  async #ensureUniqueConstraints(table, existingConstraints) {
+    const meta = table.meta;
+    const fields = Object.keys(meta.fields);
+    let applied = false;
+    for (const fieldName of fields) {
+      const fieldMeta = meta.fields[fieldName];
+      if (fieldMeta.unique) {
+        const hasUnique = existingConstraints.some(
+          (c) => c.type === "unique" && c.columns.length === 1 && c.columns[0] === fieldName
+        );
+        if (!hasUnique) {
+          await this.#preflightUnique(table.name, [fieldName]);
+          const indexName = `uniq_${table.name}_${fieldName}`;
+          await this.#createIndex(table.name, indexName, [fieldName], true);
+          applied = true;
+        }
+      }
+    }
+    return applied;
+  }
+  async #ensureForeignKeys(table, existingConstraints) {
+    const meta = table.meta;
+    let applied = false;
+    for (const ref of meta.references) {
+      const hasFk = existingConstraints.some(
+        (c) => c.type === "foreign_key" && c.columns.length === 1 && c.columns[0] === ref.fieldName && c.referencedTable === ref.table.name && c.referencedColumns?.[0] === ref.referencedField
+      );
+      if (!hasFk) {
+        await this.#preflightForeignKey(
+          table.name,
+          ref.fieldName,
+          ref.table.name,
+          ref.referencedField
+        );
+        if (this.#dialect === "sqlite") {
+          throw new Error(
+            `Adding foreign key constraints to existing SQLite tables requires table rebuild. Table "${table.name}" column "${ref.fieldName}" -> "${ref.table.name}"."${ref.referencedField}". Please use a manual migration.`
+          );
+        }
+        const constraintName = `${table.name}_${ref.fieldName}_fkey`;
+        const onDelete = ref.onDelete ? ` ON DELETE ${ref.onDelete.toUpperCase().replace(" ", " ")}` : "";
+        const sql = `ALTER TABLE ${quoteIdent(table.name, this.#dialect)} ADD CONSTRAINT ${quoteIdent(constraintName, this.#dialect)} FOREIGN KEY (${quoteIdent(ref.fieldName, this.#dialect)}) REFERENCES ${quoteIdent(ref.table.name, this.#dialect)}(${quoteIdent(ref.referencedField, this.#dialect)})${onDelete}`;
+        await this.#sql.unsafe(sql, []);
+        applied = true;
+      }
+    }
+    for (const ref of table.compoundReferences) {
+      const refFields = ref.referencedFields ?? ref.fields;
+      const hasFk = existingConstraints.some((c) => {
+        if (c.type !== "foreign_key")
+          return false;
+        if (c.columns.length !== ref.fields.length)
+          return false;
+        if (c.referencedTable !== ref.table.name)
+          return false;
+        if (!ref.fields.every((field, i) => c.columns[i] === field))
+          return false;
+        return refFields.every(
+          (field, i) => c.referencedColumns?.[i] === field
+        );
+      });
+      if (!hasFk) {
+        await this.#preflightCompoundForeignKey(
+          table.name,
+          ref.fields,
+          ref.table.name,
+          refFields
+        );
+        if (this.#dialect === "sqlite") {
+          throw new Error(
+            `Adding foreign key constraints to existing SQLite tables requires table rebuild. Table "${table.name}" columns (${ref.fields.join(", ")}) -> "${ref.table.name}".(${refFields.join(", ")}). Please use a manual migration.`
+          );
+        }
+        const constraintName = `${table.name}_${ref.fields.join("_")}_fkey`;
+        const onDelete = ref.onDelete ? ` ON DELETE ${ref.onDelete.toUpperCase().replace(" ", " ")}` : "";
+        const localCols = ref.fields.map((f) => quoteIdent(f, this.#dialect)).join(", ");
+        const refCols = refFields.map((f) => quoteIdent(f, this.#dialect)).join(", ");
+        const sql = `ALTER TABLE ${quoteIdent(table.name, this.#dialect)} ADD CONSTRAINT ${quoteIdent(constraintName, this.#dialect)} FOREIGN KEY (${localCols}) REFERENCES ${quoteIdent(ref.table.name, this.#dialect)}(${refCols})${onDelete}`;
+        await this.#sql.unsafe(sql, []);
+        applied = true;
+      }
+    }
+    return applied;
+  }
+  async #preflightUnique(tableName, columns) {
+    const colList = columns.map((c) => quoteIdent(c, this.#dialect)).join(", ");
+    const sql = `SELECT ${colList}, COUNT(*) as cnt FROM ${quoteIdent(tableName, this.#dialect)} GROUP BY ${colList} HAVING COUNT(*) > 1 LIMIT 1`;
+    const result = await this.#sql.unsafe(sql, []);
+    if (result.length > 0) {
+      const diagQuery = `SELECT ${columns.join(", ")}, COUNT(*) as cnt FROM ${tableName} GROUP BY ${columns.join(", ")} HAVING COUNT(*) > 1`;
+      const countSql = `SELECT COUNT(*) as total FROM (${sql.replace(" LIMIT 1", "")}) t`;
+      const countResult = await this.#sql.unsafe(countSql, []);
+      const violationCount = countResult[0]?.total ?? 1;
+      throw new ConstraintPreflightError(
+        `Cannot add UNIQUE constraint on "${tableName}"(${columns.join(", ")}): duplicate values exist`,
+        {
+          table: tableName,
+          constraint: `unique:${columns.join(",")}`,
+          violationCount,
+          query: diagQuery
+        }
+      );
+    }
+  }
+  async #preflightForeignKey(tableName, column, refTable, refColumn) {
+    const sql = `SELECT 1 FROM ${quoteIdent(tableName, this.#dialect)} t
+			WHERE t.${quoteIdent(column, this.#dialect)} IS NOT NULL
+			AND NOT EXISTS (
+				SELECT 1 FROM ${quoteIdent(refTable, this.#dialect)} r
+				WHERE r.${quoteIdent(refColumn, this.#dialect)} = t.${quoteIdent(column, this.#dialect)}
+			) LIMIT 1`;
+    const result = await this.#sql.unsafe(sql, []);
+    if (result.length > 0) {
+      const diagQuery = `SELECT t.* FROM ${quoteIdent(tableName, this.#dialect)} t WHERE t.${quoteIdent(column, this.#dialect)} IS NOT NULL AND NOT EXISTS (SELECT 1 FROM ${quoteIdent(refTable, this.#dialect)} r WHERE r.${quoteIdent(refColumn, this.#dialect)} = t.${quoteIdent(column, this.#dialect)})`;
+      const countSql = sql.replace("SELECT 1", "SELECT COUNT(*)").replace(" LIMIT 1", "");
+      const countResult = await this.#sql.unsafe(countSql, []);
+      const violationCount = countResult[0]?.["COUNT(*)"] ?? countResult[0]?.count ?? 1;
+      throw new ConstraintPreflightError(
+        `Cannot add FOREIGN KEY on "${tableName}"."${column}" -> "${refTable}"."${refColumn}": orphan records exist`,
+        {
+          table: tableName,
+          constraint: `fk:${column}->${refTable}.${refColumn}`,
+          violationCount,
+          query: diagQuery
+        }
+      );
+    }
+  }
+  async #preflightCompoundForeignKey(tableName, columns, refTable, refColumns) {
+    const joinConditions = columns.map(
+      (col, i) => `r.${quoteIdent(refColumns[i], this.#dialect)} = t.${quoteIdent(col, this.#dialect)}`
+    ).join(" AND ");
+    const nullChecks = columns.map((col) => `t.${quoteIdent(col, this.#dialect)} IS NOT NULL`).join(" AND ");
+    const sql = `SELECT 1 FROM ${quoteIdent(tableName, this.#dialect)} t
+			WHERE ${nullChecks}
+			AND NOT EXISTS (
+				SELECT 1 FROM ${quoteIdent(refTable, this.#dialect)} r
+				WHERE ${joinConditions}
+			) LIMIT 1`;
+    const result = await this.#sql.unsafe(sql, []);
+    if (result.length > 0) {
+      const diagQuery = `SELECT t.* FROM ${quoteIdent(tableName, this.#dialect)} t WHERE ${nullChecks} AND NOT EXISTS (SELECT 1 FROM ${quoteIdent(refTable, this.#dialect)} r WHERE ${joinConditions})`;
+      const countSql = sql.replace("SELECT 1", "SELECT COUNT(*)").replace(" LIMIT 1", "");
+      const countResult = await this.#sql.unsafe(countSql, []);
+      const violationCount = countResult[0]?.["COUNT(*)"] ?? countResult[0]?.count ?? 1;
+      throw new ConstraintPreflightError(
+        `Cannot add compound FOREIGN KEY on "${tableName}".(${columns.join(", ")}) -> "${refTable}".(${refColumns.join(", ")}): orphan records exist`,
+        {
+          table: tableName,
+          constraint: `fk:(${columns.join(",")}) ->${refTable}.(${refColumns.join(",")})`,
+          violationCount,
+          query: diagQuery
+        }
+      );
+    }
+  }
+};
+export {
+  BunDriver as default
+};