@gl-life/gl-life-database 1.0.0

package/dist/index.js

@@ -0,0 +1,4701 @@
+import { Result, Option } from '@gl-life/gl-life-core';
+export { Config, EventBus, Logger, Option, Result } from '@gl-life/gl-life-core';
+import crypto, { randomBytes } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
+import * as fs from 'fs';
+import * as path from 'path';
+import { gzipSync, gunzipSync } from 'zlib';
+
+// src/index.ts
+var InternalConnection = class {
+  id;
+  config;
+  connected = false;
+  lastPing = null;
+  constructor(id, config) {
+    this.id = id;
+    this.config = config;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  async connect() {
+    try {
+      this.connected = true;
+      this.lastPing = /* @__PURE__ */ new Date();
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "CONNECTION_FAILED",
+        message: `Failed to connect: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async disconnect() {
+    try {
+      this.connected = false;
+      this.lastPing = null;
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "CONNECTION_FAILED",
+        message: `Failed to disconnect: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async execute(sql, params) {
+    if (!this.connected) {
+      return Result.err({
+        type: "CONNECTION_CLOSED",
+        message: "Connection is not active"
+      });
+    }
+    try {
+      return Result.ok({});
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Query execution failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async ping() {
+    if (!this.connected) {
+      return Result.ok(false);
+    }
+    try {
+      this.lastPing = /* @__PURE__ */ new Date();
+      return Result.ok(true);
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Ping failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+};
+var DatabaseConnectionManager = class {
+  config;
+  logger;
+  pool = [];
+  available = [];
+  active = /* @__PURE__ */ new Set();
+  initialized = false;
+  destroyed = false;
+  connectionIdCounter = 0;
+  constructor(config, logger) {
+    if (!config.name || config.name.trim() === "") {
+      throw new Error("Database name is required");
+    }
+    if (config.maxConnections !== void 0 && config.maxConnections < 0) {
+      throw new Error("maxConnections must be >= 0");
+    }
+    this.config = {
+      maxConnections: 10,
+      timeout: 3e4,
+      autoReconnect: false,
+      maxRetries: 3,
+      retryDelay: 1e3,
+      ...config
+    };
+    this.logger = logger;
+  }
+  /**
+   * Get manager configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get number of active connections
+   */
+  getActiveCount() {
+    return this.active.size;
+  }
+  /**
+   * Initialize the connection manager
+   */
+  async initialize() {
+    if (this.initialized) {
+      return Result.ok(void 0);
+    }
+    if (this.destroyed) {
+      return Result.err({
+        type: "CONNECTION_CLOSED",
+        message: "Manager has been destroyed"
+      });
+    }
+    this.logger.info("Initializing DatabaseConnectionManager", {
+      name: this.config.name,
+      maxConnections: this.config.maxConnections
+    });
+    try {
+      this.initialized = true;
+      this.logger.info("DatabaseConnectionManager initialized successfully");
+      return Result.ok(void 0);
+    } catch (error) {
+      this.initialized = false;
+      return Result.err({
+        type: "CONNECTION_FAILED",
+        message: `Initialization failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Acquire a connection from the pool
+   */
+  async acquire() {
+    if (this.destroyed) {
+      this.logger.error("Cannot acquire connection: manager destroyed");
+      return Result.err({
+        type: "CONNECTION_CLOSED",
+        message: "Manager has been destroyed"
+      });
+    }
+    if (!this.initialized) {
+      return Result.err({
+        type: "CONNECTION_CLOSED",
+        message: "Manager not initialized"
+      });
+    }
+    this.logger.debug("Acquiring connection from pool", {
+      available: this.available.length,
+      active: this.active.size,
+      total: this.pool.length
+    });
+    if (this.available.length > 0) {
+      const conn2 = this.available.pop();
+      this.active.add(conn2);
+      const pingResult = await conn2.ping();
+      if (pingResult.isOk() && pingResult.unwrap()) {
+        this.logger.debug("Reusing existing connection", { id: conn2.id });
+        return Result.ok(conn2);
+      } else {
+        if (this.config.autoReconnect) {
+          const reconnectResult = await conn2.connect();
+          if (reconnectResult.isOk()) {
+            this.logger.debug("Reconnected unhealthy connection", { id: conn2.id });
+            return Result.ok(conn2);
+          }
+        }
+        this.active.delete(conn2);
+        this.pool = this.pool.filter((c) => c.id !== conn2.id);
+      }
+    }
+    const maxConnections = this.config.maxConnections;
+    if (this.pool.length >= maxConnections) {
+      this.logger.error("Connection pool limit reached", {
+        max: maxConnections,
+        current: this.pool.length
+      });
+      return Result.err({
+        type: "CONNECTION_FAILED",
+        message: `Connection pool limit reached (${maxConnections})`
+      });
+    }
+    const connId = `conn-${++this.connectionIdCounter}`;
+    const conn = new InternalConnection(connId, this.config);
+    const connectResult = await conn.connect();
+    if (connectResult.isErr()) {
+      return connectResult;
+    }
+    this.pool.push(conn);
+    this.active.add(conn);
+    this.logger.debug("Created new connection", {
+      id: conn.id,
+      poolSize: this.pool.length
+    });
+    return Result.ok(conn);
+  }
+  /**
+   * Release a connection back to the pool
+   */
+  async release(connection) {
+    if (!connection || !connection.id) {
+      return Result.err({
+        type: "DATABASE_NOT_FOUND",
+        message: "Invalid connection provided"
+      });
+    }
+    const conn = this.pool.find((c) => c.id === connection.id);
+    if (!conn) {
+      return Result.err({
+        type: "DATABASE_NOT_FOUND",
+        message: "Connection not found in pool"
+      });
+    }
+    this.active.delete(conn);
+    this.available.push(conn);
+    this.logger.debug("Released connection back to pool", {
+      id: connection.id,
+      available: this.available.length
+    });
+    return Result.ok(void 0);
+  }
+  /**
+   * Perform health check on all connections
+   */
+  async healthCheck() {
+    if (this.destroyed) {
+      return Result.ok(false);
+    }
+    if (!this.initialized) {
+      return Result.ok(false);
+    }
+    try {
+      if (this.pool.length === 0) {
+        const testConn = await this.acquire();
+        if (testConn.isErr()) {
+          return Result.ok(false);
+        }
+        await this.release(testConn.unwrap());
+        return Result.ok(true);
+      }
+      const checks = this.pool.map((conn) => conn.ping());
+      const results = await Promise.all(checks);
+      const allHealthy = results.every((r) => r.isOk() && r.unwrap() === true);
+      if (!allHealthy && this.config.autoReconnect) {
+        for (let i = 0; i < this.pool.length; i++) {
+          const result = results[i];
+          if (result.isErr() || !result.unwrap()) {
+            await this.pool[i].connect();
+          }
+        }
+      }
+      return Result.ok(allHealthy);
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Health check failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Destroy the connection manager and close all connections
+   */
+  async destroy() {
+    if (this.destroyed) {
+      return Result.ok(void 0);
+    }
+    this.logger.info("Destroying DatabaseConnectionManager", {
+      totalConnections: this.pool.length,
+      activeConnections: this.active.size
+    });
+    try {
+      const closePromises = this.pool.map((conn) => conn.disconnect());
+      await Promise.all(closePromises);
+      this.pool = [];
+      this.available = [];
+      this.active.clear();
+      this.initialized = false;
+      this.destroyed = true;
+      this.logger.info("DatabaseConnectionManager destroyed successfully");
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Destroy failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+};
+var TypeSafeQueryBuilder = class _TypeSafeQueryBuilder {
+  tableName;
+  metaDataService;
+  logger;
+  selectedColumns = [];
+  whereConditions = [];
+  joinClauses = [];
+  orderByClauses = [];
+  groupByFields = [];
+  havingCondition = null;
+  limitValue = null;
+  offsetValue = null;
+  constructor(tableName, metaDataService, logger) {
+    if (!tableName || tableName.trim() === "") {
+      throw new Error("Table name is required");
+    }
+    this.tableName = tableName;
+    this.metaDataService = metaDataService;
+    this.logger = logger;
+  }
+  table(table) {
+    this.tableName = table;
+    return this;
+  }
+  select(...columns) {
+    this.selectedColumns.push(...columns);
+    return this;
+  }
+  where(field, operator, value) {
+    this.whereConditions.push({ field, operator, value, isOr: false });
+    return this;
+  }
+  orWhere(field, operator, value) {
+    this.whereConditions.push({ field, operator, value, isOr: true });
+    return this;
+  }
+  whereIn(field, values) {
+    this.whereConditions.push({ field, operator: "IN", value: values, isOr: false });
+    return this;
+  }
+  join(table, leftField, rightField, type = "INNER") {
+    this.joinClauses.push({ type, table, left: leftField, right: rightField });
+    return this;
+  }
+  orderBy(field, direction = "ASC") {
+    this.orderByClauses.push({ field, direction });
+    return this;
+  }
+  groupBy(...fields) {
+    this.groupByFields.push(...fields);
+    return this;
+  }
+  having(condition) {
+    this.havingCondition = condition;
+    return this;
+  }
+  limit(limit) {
+    this.limitValue = limit;
+    return this;
+  }
+  offset(offset) {
+    this.offsetValue = offset;
+    return this;
+  }
+  async insert(data) {
+    try {
+      this.logger.debug("Insert operation", { table: this.tableName, data });
+      return Result.ok(data);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Insert failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async insertMany(data) {
+    try {
+      this.logger.debug("Insert many operation", { table: this.tableName, count: data.length });
+      return Result.ok(data);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Insert many failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async update(data) {
+    try {
+      this.logger.debug("Update operation", { table: this.tableName, data });
+      return Result.ok(1);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Update failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async delete() {
+    try {
+      this.logger.debug("Delete operation", { table: this.tableName });
+      return Result.ok(1);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Delete failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async first() {
+    try {
+      this.logger.debug("First operation", { table: this.tableName });
+      return Result.ok(null);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `First failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async get() {
+    try {
+      this.logger.debug("Get operation", { table: this.tableName });
+      return Result.ok([]);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Get failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async count(field = "*") {
+    try {
+      this.logger.debug("Count operation", { table: this.tableName, field });
+      return Result.ok(0);
+    } catch (error) {
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Count failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  toSQL() {
+    const columns = this.selectedColumns.length > 0 ? this.selectedColumns.join(", ") : "*";
+    let sql = `SELECT ${columns} FROM ${this.tableName}`;
+    if (this.joinClauses.length > 0) {
+      sql += " " + this.joinClauses.map((j) => `${j.type} JOIN ${j.table} ON ${j.left} = ${j.right}`).join(" ");
+    }
+    if (this.whereConditions.length > 0) {
+      const whereParts = this.whereConditions.map((w, i) => {
+        const prefix = i === 0 ? "WHERE" : w.isOr ? "OR" : "AND";
+        return `${prefix} ${w.field} ${w.operator} ?`;
+      });
+      sql += " " + whereParts.join(" ");
+    }
+    if (this.groupByFields.length > 0) {
+      sql += ` GROUP BY ${this.groupByFields.join(", ")}`;
+    }
+    if (this.havingCondition) {
+      sql += ` HAVING ${this.havingCondition}`;
+    }
+    if (this.orderByClauses.length > 0) {
+      sql += " ORDER BY " + this.orderByClauses.map((o) => `${o.field} ${o.direction}`).join(", ");
+    }
+    if (this.limitValue !== null) {
+      sql += ` LIMIT ${this.limitValue}`;
+    }
+    if (this.offsetValue !== null) {
+      sql += ` OFFSET ${this.offsetValue}`;
+    }
+    return sql;
+  }
+  getBindings() {
+    return this.whereConditions.map((w) => w.value).filter((v) => v !== void 0);
+  }
+  clone() {
+    const cloned = new _TypeSafeQueryBuilder(this.tableName, this.metaDataService, this.logger);
+    cloned.selectedColumns = [...this.selectedColumns];
+    cloned.whereConditions = [...this.whereConditions];
+    cloned.joinClauses = [...this.joinClauses];
+    cloned.orderByClauses = [...this.orderByClauses];
+    cloned.groupByFields = [...this.groupByFields];
+    cloned.havingCondition = this.havingCondition;
+    cloned.limitValue = this.limitValue;
+    cloned.offsetValue = this.offsetValue;
+    return cloned;
+  }
+};
+var RawSQLExecutor = class {
+  connection;
+  logger;
+  constructor(connection, logger) {
+    this.connection = connection;
+    this.logger = logger;
+  }
+  /**
+   * Execute a raw SQL query with parameters
+   *
+   * Uses parameterized queries to prevent SQL injection.
+   * All parameter values are properly escaped by the database driver.
+   *
+   * @param sql - SQL query string with ? placeholders
+   * @param params - Parameter values to bind to placeholders
+   * @param options - Execution options
+   * @returns Result containing array of rows or error
+   */
+  async execute(sql, params = [], options) {
+    const validationResult = this.validateSQL(sql, params);
+    if (validationResult.isErr()) {
+      return validationResult;
+    }
+    try {
+      this.logger.debug("Executing raw SQL", {
+        sql: sql.substring(0, 100),
+        paramCount: params.length
+      });
+      const result = await this.connection.execute(sql, params);
+      if (result.isErr()) {
+        return Result.err({
+          type: "EXECUTION_FAILED",
+          message: "Query execution failed",
+          cause: result
+        });
+      }
+      const data = result.unwrap();
+      let rows;
+      if (data && typeof data === "object" && "rows" in data) {
+        rows = data.rows;
+      } else if (Array.isArray(data)) {
+        rows = data;
+      } else {
+        rows = [];
+      }
+      this.logger.debug("Query executed successfully", {
+        rowCount: rows.length
+      });
+      return Result.ok(rows);
+    } catch (error) {
+      this.logger.error("Raw SQL execution failed", {
+        error,
+        sql: sql.substring(0, 100)
+      });
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Query execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Execute a query and return the first row or null
+   *
+   * @param sql - SQL query string
+   * @param params - Parameter values
+   * @param options - Execution options
+   * @returns Result containing single row or null
+   */
+  async executeOne(sql, params = [], options) {
+    const result = await this.execute(sql, params, options);
+    if (result.isErr()) {
+      return result;
+    }
+    const rows = result.unwrap();
+    return Result.ok(rows.length > 0 ? rows[0] : null);
+  }
+  /**
+   * Execute multiple queries in batch
+   *
+   * All queries execute sequentially. If any query fails, execution stops
+   * and an error is returned.
+   *
+   * @param queries - Array of SQL queries with parameters
+   * @returns Result containing array of results or error
+   */
+  async executeBatch(queries) {
+    const results = [];
+    try {
+      this.logger.debug("Executing batch queries", { count: queries.length });
+      for (const query of queries) {
+        const result = await this.execute(query.sql, query.params || []);
+        if (result.isErr()) {
+          return Result.err({
+            type: "EXECUTION_FAILED",
+            message: "Batch execution failed",
+            cause: result
+          });
+        }
+        results.push(result.unwrap());
+      }
+      this.logger.debug("Batch execution completed", {
+        queryCount: queries.length,
+        totalRows: results.reduce((sum, rows) => sum + rows.length, 0)
+      });
+      return Result.ok(results);
+    } catch (error) {
+      this.logger.error("Batch execution failed", { error });
+      return Result.err({
+        type: "EXECUTION_FAILED",
+        message: `Batch execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Validate SQL query and parameters
+   *
+   * Checks for:
+   * - Empty/whitespace-only queries
+   * - Parameter count matching placeholder count
+   *
+   * @param sql - SQL query string
+   * @param params - Parameter values
+   * @returns Result indicating validation success or error
+   */
+  validateSQL(sql, params) {
+    if (!sql || sql.trim().length === 0) {
+      return Result.err({
+        type: "INVALID_SQL",
+        message: "SQL query cannot be empty"
+      });
+    }
+    const placeholderCount = (sql.match(/\?/g) || []).length;
+    if (placeholderCount !== params.length) {
+      return Result.err({
+        type: "PARAMETER_MISMATCH",
+        message: `Parameter count mismatch: expected ${placeholderCount} but got ${params.length}`
+      });
+    }
+    return Result.ok(void 0);
+  }
+};
+var DatabaseTransaction = class {
+  _id;
+  db;
+  _logger;
+  _config;
+  _state = "PENDING";
+  startTime = null;
+  timeoutHandle = null;
+  constructor(db, logger, config = {}) {
+    this._id = this.generateTransactionId();
+    this.db = db;
+    this._logger = logger;
+    this._config = {
+      isolationLevel: config.isolationLevel || "READ COMMITTED",
+      timeout: config.timeout || 3e4,
+      autoRollback: config.autoRollback !== void 0 ? config.autoRollback : true
+    };
+  }
+  generateTransactionId() {
+    return `tx_${randomBytes(16).toString("hex")}`;
+  }
+  get id() {
+    return this._id;
+  }
+  get state() {
+    return this._state;
+  }
+  get config() {
+    return this._config;
+  }
+  get isActive() {
+    return this._state === "ACTIVE";
+  }
+  async begin() {
+    if (this._state !== "PENDING") {
+      return Result.err({
+        type: "ALREADY_STARTED",
+        message: `Transaction ${this._id} is already ${this._state}`
+      });
+    }
+    try {
+      this._logger.debug("Beginning transaction", {
+        id: this._id,
+        isolationLevel: this._config.isolationLevel
+      });
+      await this.db.execute("BEGIN", []);
+      this._state = "ACTIVE";
+      this.startTime = Date.now();
+      if (this._config.timeout && this._config.timeout > 0) {
+        this.timeoutHandle = setTimeout(() => {
+          this.handleTimeout();
+        }, this._config.timeout);
+      }
+      return Result.ok(void 0);
+    } catch (error) {
+      this._logger.error("Failed to begin transaction", { error, id: this._id });
+      return Result.err({
+        type: "BEGIN_FAILED",
+        message: `Failed to begin transaction: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  async commit() {
+    if (this._state === "PENDING") {
+      return Result.err({
+        type: "NOT_STARTED",
+        message: `Transaction ${this._id} has not been started`
+      });
+    }
+    if (this._state === "COMMITTED" || this._state === "ROLLED_BACK") {
+      return Result.err({
+        type: "ALREADY_COMPLETED",
+        message: `Transaction ${this._id} is already ${this._state}`
+      });
+    }
+    try {
+      this._logger.debug("Committing transaction", { id: this._id });
+      await this.db.execute("COMMIT", []);
+      this._state = "COMMITTED";
+      this.clearTimeout();
+      const duration = this.startTime ? Date.now() - this.startTime : 0;
+      this._logger.info("Transaction committed", { id: this._id, duration });
+      return Result.ok(void 0);
+    } catch (error) {
+      this._logger.error("Failed to commit transaction", { error, id: this._id });
+      return Result.err({
+        type: "COMMIT_FAILED",
+        message: `Failed to commit transaction: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  async rollback() {
+    if (this._state === "PENDING") {
+      return Result.err({
+        type: "NOT_STARTED",
+        message: `Transaction ${this._id} has not been started`
+      });
+    }
+    if (this._state === "COMMITTED" || this._state === "ROLLED_BACK") {
+      return Result.err({
+        type: "ALREADY_COMPLETED",
+        message: `Transaction ${this._id} is already ${this._state}`
+      });
+    }
+    try {
+      this._logger.debug("Rolling back transaction", { id: this._id });
+      await this.db.execute("ROLLBACK", []);
+      this._state = "ROLLED_BACK";
+      this.clearTimeout();
+      const duration = this.startTime ? Date.now() - this.startTime : 0;
+      this._logger.info("Transaction rolled back", { id: this._id, duration });
+      return Result.ok(void 0);
+    } catch (error) {
+      this._logger.error("Failed to rollback transaction", { error, id: this._id });
+      return Result.err({
+        type: "ROLLBACK_FAILED",
+        message: `Failed to rollback transaction: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  async savepoint(name) {
+    if (!this.isActive) {
+      return Result.err({
+        type: "NOT_STARTED",
+        message: `Cannot create savepoint: transaction ${this._id} is not active`
+      });
+    }
+    try {
+      this._logger.debug("Creating savepoint", { id: this._id, savepoint: name });
+      await this.db.execute(`SAVEPOINT ${name}`, []);
+      return Result.ok(name);
+    } catch (error) {
+      this._logger.error("Failed to create savepoint", { error, id: this._id, savepoint: name });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to create savepoint: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  async rollbackToSavepoint(name) {
+    if (!this.isActive) {
+      return Result.err({
+        type: "NOT_STARTED",
+        message: `Cannot rollback to savepoint: transaction ${this._id} is not active`
+      });
+    }
+    try {
+      this._logger.debug("Rolling back to savepoint", { id: this._id, savepoint: name });
+      await this.db.execute(`ROLLBACK TO SAVEPOINT ${name}`, []);
+      return Result.ok(void 0);
+    } catch (error) {
+      this._logger.error("Failed to rollback to savepoint", { error, id: this._id, savepoint: name });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to rollback to savepoint: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  async releaseSavepoint(name) {
+    if (!this.isActive) {
+      return Result.err({
+        type: "NOT_STARTED",
+        message: `Cannot release savepoint: transaction ${this._id} is not active`
+      });
+    }
+    try {
+      this._logger.debug("Releasing savepoint", { id: this._id, savepoint: name });
+      await this.db.execute(`RELEASE SAVEPOINT ${name}`, []);
+      return Result.ok(void 0);
+    } catch (error) {
+      this._logger.error("Failed to release savepoint", { error, id: this._id, savepoint: name });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to release savepoint: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  async execute(sql, params = []) {
+    if (!this.isActive) {
+      return Result.err({
+        type: "NOT_STARTED",
+        message: `Cannot execute query: transaction ${this._id} is not active`
+      });
+    }
+    try {
+      this._logger.debug("Executing query in transaction", {
+        id: this._id,
+        sql: sql.substring(0, 100)
+      });
+      const result = await this.db.execute(sql, params);
+      return Result.ok(result);
+    } catch (error) {
+      this._logger.error("Query execution failed in transaction", {
+        error,
+        id: this._id,
+        sql: sql.substring(0, 100)
+      });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Query execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  queryBuilder(table) {
+    const mockMetaDataService = {
+      getAllMappings: async () => [],
+      getMapping: async () => null
+    };
+    return new TypeSafeQueryBuilder(table, mockMetaDataService, this._logger);
+  }
+  async run(callback) {
+    if (this._state === "PENDING") {
+      const beginResult = await this.begin();
+      if (beginResult.isErr()) {
+        return beginResult;
+      }
+    }
+    try {
+      const result = await callback(this);
+      if (result.isErr()) {
+        if (this._config.autoRollback) {
+          await this.rollback();
+        }
+        return Result.err({
+          type: "UNKNOWN",
+          message: "Transaction callback returned error",
+          cause: result
+        });
+      }
+      const commitResult = await this.commit();
+      if (commitResult.isErr()) {
+        return commitResult;
+      }
+      return Result.ok(result.unwrap());
+    } catch (error) {
+      if (this._config.autoRollback) {
+        await this.rollback();
+      }
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Transaction failed: ${error instanceof Error ? error.message : String(error)}`,
+        cause: error
+      });
+    }
+  }
+  handleTimeout() {
+    if (this.isActive) {
+      this._logger.warn("Transaction timeout", {
+        id: this._id,
+        timeout: this._config.timeout
+      });
+      this.rollback().then((result) => {
+        if (result.isErr()) {
+          this._logger.error("Failed to rollback timed out transaction", {
+            id: this._id,
+            error: "Transaction rollback failed"
+          });
+        }
+      });
+    }
+  }
+  clearTimeout() {
+    if (this.timeoutHandle) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = null;
+    }
+  }
+};
+var TenantContextManager = class _TenantContextManager {
+  storage;
+  _config;
+  logger;
+  currentTenant = null;
+  constructor(config, logger) {
+    this._config = config;
+    this.logger = logger;
+    this.storage = new AsyncLocalStorage();
+  }
+  get tenant() {
+    return this.getTenant();
+  }
+  get config() {
+    return this._config;
+  }
+  get hasTenant() {
+    return this.currentTenant !== null;
+  }
+  async setTenant(tenantId) {
+    this.validateTenantId(tenantId);
+    this.logger.debug("Setting tenant", { tenantId });
+    const metadata = {
+      id: tenantId,
+      name: tenantId,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      isActive: true
+    };
+    this.currentTenant = metadata;
+  }
+  async setTenantWithMetadata(metadata) {
+    this.validateTenantId(metadata.id);
+    this.logger.debug("Setting tenant with metadata", {
+      tenantId: metadata.id,
+      name: metadata.name
+    });
+    this.currentTenant = metadata;
+  }
+  async clearTenant() {
+    this.logger.debug("Clearing tenant context");
+    this.currentTenant = null;
+  }
+  getTenantId() {
+    if (this.currentTenant) {
+      return Option.some(this.currentTenant.id);
+    }
+    return Option.none();
+  }
+  getTenant() {
+    if (this.currentTenant) {
+      return Option.some(this.currentTenant);
+    }
+    return Option.none();
+  }
+  shouldIsolateTable(table) {
+    if (!this._config.enforceIsolation) {
+      return false;
+    }
+    if (this._config.excludedTables?.includes(table)) {
+      return false;
+    }
+    return true;
+  }
+  applyTenantIsolation(sql, params = []) {
+    const tenantId = this.getTenantId();
+    if (tenantId.isNone()) {
+      throw new Error("No tenant context set. Cannot apply tenant isolation.");
+    }
+    const tenant = tenantId.unwrap();
+    const tableMatch = sql.match(/(?:FROM|INTO|UPDATE)\s+([a-zA-Z_][a-zA-Z0-9_]*)/i);
+    if (tableMatch) {
+      const tableName = tableMatch[1];
+      if (!this.shouldIsolateTable(tableName)) {
+        return { sql, params };
+      }
+    }
+    switch (this._config.isolationStrategy) {
+      case "ROW":
+        return this.applyRowLevelIsolation(sql, params, tenant);
+      case "SCHEMA":
+        return this.applySchemaIsolation(sql, params, tenant);
+      case "DATABASE":
+        return { sql, params };
+      case "HYBRID":
+        const schemaResult = this.applySchemaIsolation(sql, params, tenant);
+        return this.applyRowLevelIsolation(schemaResult.sql, schemaResult.params, tenant);
+      default:
+        return { sql, params };
+    }
+  }
+  getTenantDatabase() {
+    const tenantId = this.getTenantId();
+    if (tenantId.isNone()) {
+      return Option.none();
+    }
+    if (this._config.isolationStrategy !== "DATABASE" && this._config.isolationStrategy !== "HYBRID") {
+      return Option.none();
+    }
+    const tenant = tenantId.unwrap();
+    const baseName = this._config.databaseName || "app";
+    const dbName = `${baseName}_${tenant}`;
+    return Option.some(dbName);
+  }
+  getTenantSchema() {
+    const tenantId = this.getTenantId();
+    if (tenantId.isNone()) {
+      return Option.none();
+    }
+    if (this._config.isolationStrategy !== "SCHEMA" && this._config.isolationStrategy !== "HYBRID") {
+      return Option.none();
+    }
+    const tenant = tenantId.unwrap();
+    const baseName = this._config.schemaName || "app";
+    const schemaName = `${baseName}_${tenant}`;
+    return Option.some(schemaName);
+  }
+  async withTenant(tenantId, callback) {
+    const previousTenant = this.currentTenant;
+    try {
+      await this.setTenant(tenantId);
+      const result = await callback();
+      return result;
+    } finally {
+      if (previousTenant) {
+        this.currentTenant = previousTenant;
+      } else {
+        this.currentTenant = null;
+      }
+    }
+  }
+  clone() {
+    return new _TenantContextManager(this._config, this.logger);
+  }
+  /**
+   * Validate tenant ID format
+   */
+  validateTenantId(tenantId) {
+    if (!tenantId || typeof tenantId !== "string") {
+      throw new Error("Tenant ID must be a non-empty string");
+    }
+    if (tenantId.trim().length === 0) {
+      throw new Error("Tenant ID cannot be whitespace only");
+    }
+    if (/[;'"`\\]/.test(tenantId)) {
+      throw new Error("Tenant ID contains invalid characters");
+    }
+  }
+  /**
+   * Apply ROW-level tenant isolation to SQL query
+   */
+  applyRowLevelIsolation(sql, params, tenantId) {
+    const tenantColumn = this._config.tenantIdColumn || "tenant_id";
+    const newParams = [...params];
+    const sqlUpper = sql.trim().toUpperCase();
+    if (sqlUpper.startsWith("SELECT")) {
+      if (sql.toUpperCase().includes("WHERE")) {
+        sql = sql.replace(/WHERE/i, `WHERE ${tenantColumn} = ? AND`);
+        newParams.unshift(tenantId);
+      } else {
+        const clauseMatch = sql.match(/(ORDER BY|LIMIT|OFFSET|GROUP BY)/i);
+        if (clauseMatch) {
+          const pos = sql.indexOf(clauseMatch[0]);
+          sql = sql.slice(0, pos) + ` WHERE ${tenantColumn} = ? ` + sql.slice(pos);
+        } else {
+          sql = `${sql} WHERE ${tenantColumn} = ?`;
+        }
+        newParams.push(tenantId);
+      }
+    } else if (sqlUpper.startsWith("INSERT")) {
+      const valuesMatch = sql.match(/\(([^)]+)\)\s+VALUES\s+\(([^)]+)\)/i);
+      if (valuesMatch) {
+        const columns = valuesMatch[1];
+        const placeholders = valuesMatch[2];
+        const newColumns = `${columns}, ${tenantColumn}`;
+        const newPlaceholders = `${placeholders}, ?`;
+        sql = sql.replace(
+          /\(([^)]+)\)\s+VALUES\s+\(([^)]+)\)/i,
+          `(${newColumns}) VALUES (${newPlaceholders})`
+        );
+        newParams.push(tenantId);
+      }
+    } else if (sqlUpper.startsWith("UPDATE")) {
+      if (sql.toUpperCase().includes("WHERE")) {
+        sql = sql.replace(/WHERE/i, `WHERE ${tenantColumn} = ? AND`);
+        newParams.unshift(tenantId);
+      } else {
+        sql = `${sql} WHERE ${tenantColumn} = ?`;
+        newParams.push(tenantId);
+      }
+    } else if (sqlUpper.startsWith("DELETE")) {
+      if (sql.toUpperCase().includes("WHERE")) {
+        sql = sql.replace(/WHERE/i, `WHERE ${tenantColumn} = ? AND`);
+        newParams.unshift(tenantId);
+      } else {
+        sql = `${sql} WHERE ${tenantColumn} = ?`;
+        newParams.push(tenantId);
+      }
+    }
+    return { sql, params: newParams };
+  }
+  /**
+   * Apply SCHEMA-level tenant isolation to SQL query
+   */
+  applySchemaIsolation(sql, params, tenantId) {
+    const schemaName = this.getTenantSchema();
+    if (schemaName.isNone()) {
+      return { sql, params };
+    }
+    const schema = schemaName.unwrap();
+    sql = sql.replace(
+      /(?:FROM|INTO|UPDATE|JOIN)\s+([a-zA-Z_][a-zA-Z0-9_]*)/gi,
+      (match, tableName) => {
+        if (tableName.includes(".") || this._config.excludedTables?.includes(tableName)) {
+          return match;
+        }
+        return match.replace(tableName, `${schema}.${tableName}`);
+      }
+    );
+    return { sql, params };
+  }
+};
+
+// src/tenant/query-wrapper.ts
+var TenantAwareQueryBuilder = class _TenantAwareQueryBuilder {
+  baseBuilder;
+  tenantContext;
+  logger;
+  isAdminMode = false;
+  constructor(baseBuilder, tenantContext, logger) {
+    this.baseBuilder = baseBuilder;
+    this.tenantContext = tenantContext;
+    this.logger = logger;
+  }
+  /**
+   * Switch to admin mode - bypasses tenant filtering
+   *
+   * Use with caution! Only for administrative queries that need
+   * to access data across all tenants.
+   *
+   * @returns QueryBuilder in admin mode
+   */
+  asAdmin() {
+    const adminBuilder = new _TenantAwareQueryBuilder(
+      this.baseBuilder,
+      this.tenantContext,
+      this.logger
+    );
+    adminBuilder.isAdminMode = true;
+    return adminBuilder;
+  }
+  /**
+   * Switch back to tenant mode from admin mode
+   *
+   * Re-enables automatic tenant filtering
+   *
+   * @returns QueryBuilder in tenant mode
+   */
+  asTenant() {
+    const tenantBuilder = new _TenantAwareQueryBuilder(
+      this.baseBuilder,
+      this.tenantContext,
+      this.logger
+    );
+    tenantBuilder.isAdminMode = false;
+    return tenantBuilder;
+  }
+  /**
+   * Validate that tenant context is set (unless admin mode or excluded table)
+   */
+  validateTenantContext() {
+    if (this.isAdminMode) {
+      return;
+    }
+    const tableName = this.getTableName();
+    if (!this.tenantContext.shouldIsolateTable(tableName)) {
+      return;
+    }
+    if (!this.tenantContext.hasTenant) {
+      throw new Error(
+        "No tenant context set. Cannot execute query without tenant context. Use asAdmin() for admin queries or set tenant via tenantContext.setTenant()"
+      );
+    }
+  }
+  /**
+   * Get table name from base builder
+   */
+  getTableName() {
+    const sql = this.baseBuilder.toSQL();
+    const match = sql.match(/FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/i);
+    return match ? match[1] : "";
+  }
+  /**
+   * Inject tenant filter into query builder
+   *
+   * This method ensures the correct tenant filter is present.
+   * If a manual tenant_id filter exists, it will be overridden.
+   */
+  injectTenantFilter() {
+    if (this.isAdminMode) {
+      return;
+    }
+    const tableName = this.getTableName();
+    if (!this.tenantContext.shouldIsolateTable(tableName)) {
+      return;
+    }
+    const tenantId = this.tenantContext.getTenantId();
+    if (tenantId.isNone()) {
+      throw new Error("No tenant context set. Cannot inject tenant filter.");
+    }
+    const tenant = tenantId.unwrap();
+    const tenantColumn = this.tenantContext.config.tenantIdColumn || "tenant_id";
+    this.baseBuilder.where(tenantColumn, "=", tenant);
+  }
+  /**
+   * Override tenant_id in data object for INSERT operations
+   */
+  enforceTenantInData(data) {
+    if (this.isAdminMode) {
+      return data;
+    }
+    const tableName = this.getTableName();
+    if (!this.tenantContext.shouldIsolateTable(tableName)) {
+      return data;
+    }
+    const tenantId = this.tenantContext.getTenantId();
+    if (tenantId.isNone()) {
+      throw new Error("No tenant context set. Cannot enforce tenant in INSERT.");
+    }
+    const tenant = tenantId.unwrap();
+    const tenantColumn = this.tenantContext.config.tenantIdColumn || "tenant_id";
+    return {
+      ...data,
+      [tenantColumn]: tenant
+    };
+  }
+  // QueryBuilder interface implementation
+  table(table) {
+    this.baseBuilder.table(table);
+    return this;
+  }
+  select(...columns) {
+    this.baseBuilder.select(...columns);
+    return this;
+  }
+  where(field, operator, value) {
+    this.baseBuilder.where(field, operator, value);
+    return this;
+  }
+  orWhere(field, operator, value) {
+    this.baseBuilder.orWhere(field, operator, value);
+    return this;
+  }
+  whereIn(field, values) {
+    this.baseBuilder.whereIn(field, values);
+    return this;
+  }
+  join(table, leftField, rightField, type = "INNER") {
+    this.baseBuilder.join(table, leftField, rightField, type);
+    return this;
+  }
+  orderBy(field, direction = "ASC") {
+    this.baseBuilder.orderBy(field, direction);
+    return this;
+  }
+  groupBy(...fields) {
+    this.baseBuilder.groupBy(...fields);
+    return this;
+  }
+  having(condition) {
+    this.baseBuilder.having(condition);
+    return this;
+  }
+  limit(limit) {
+    this.baseBuilder.limit(limit);
+    return this;
+  }
+  offset(offset) {
+    this.baseBuilder.offset(offset);
+    return this;
+  }
+  async insert(data) {
+    this.validateTenantContext();
+    const dataWithTenant = this.enforceTenantInData(data);
+    this.logger.debug("Tenant-aware INSERT", {
+      table: this.getTableName(),
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.insert(dataWithTenant);
+  }
+  async insertMany(data) {
+    this.validateTenantContext();
+    const dataWithTenant = data.map((item) => this.enforceTenantInData(item));
+    this.logger.debug("Tenant-aware INSERT MANY", {
+      table: this.getTableName(),
+      count: data.length,
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.insertMany(dataWithTenant);
+  }
+  async update(data) {
+    this.validateTenantContext();
+    this.injectTenantFilter();
+    this.logger.debug("Tenant-aware UPDATE", {
+      table: this.getTableName(),
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.update(data);
+  }
+  async delete() {
+    this.validateTenantContext();
+    this.injectTenantFilter();
+    this.logger.debug("Tenant-aware DELETE", {
+      table: this.getTableName(),
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.delete();
+  }
+  async first() {
+    this.validateTenantContext();
+    this.injectTenantFilter();
+    this.logger.debug("Tenant-aware FIRST", {
+      table: this.getTableName(),
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.first();
+  }
+  async get() {
+    this.validateTenantContext();
+    this.injectTenantFilter();
+    this.logger.debug("Tenant-aware GET", {
+      table: this.getTableName(),
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.get();
+  }
+  async count(field = "*") {
+    this.validateTenantContext();
+    this.injectTenantFilter();
+    this.logger.debug("Tenant-aware COUNT", {
+      table: this.getTableName(),
+      field,
+      isAdmin: this.isAdminMode
+    });
+    return this.baseBuilder.count(field);
+  }
+  toSQL() {
+    this.validateTenantContext();
+    this.injectTenantFilter();
+    return this.baseBuilder.toSQL();
+  }
+  getBindings() {
+    return this.baseBuilder.getBindings();
+  }
+  clone() {
+    const clonedBase = this.baseBuilder.clone();
+    const clonedTenantAware = new _TenantAwareQueryBuilder(
+      clonedBase,
+      this.tenantContext,
+      this.logger
+    );
+    clonedTenantAware.isAdminMode = this.isAdminMode;
+    return clonedTenantAware;
+  }
+};
+var TenantSchemaManager = class {
+  connection;
+  logger;
+  config;
+  constructor(connection, logger, config) {
+    this.connection = connection;
+    this.logger = logger;
+    this.config = {
+      schemaVersionTable: "schema_versions",
+      ...config
+    };
+  }
+  /**
+   * Create a new tenant schema
+   *
+   * @param tenantId - Tenant identifier
+   * @param options - Schema creation options
+   * @returns Result with void on success or SchemaManagerError
+   */
+  async createTenantSchema(tenantId, options = {}) {
+    const validationResult = this.validateTenantId(tenantId);
+    if (validationResult.isErr()) {
+      return validationResult;
+    }
+    const schemaName = this.getSchemaName(tenantId);
+    try {
+      this.logger.debug("Creating tenant schema", { tenantId, schemaName });
+      if (options.useTransaction) {
+        await this.connection.execute("BEGIN");
+      }
+      const createResult = await this.connection.execute(
+        `CREATE SCHEMA ${schemaName}`,
+        []
+      );
+      if (createResult.isErr()) {
+        if (options.useTransaction) {
+          await this.connection.execute("ROLLBACK");
+        }
+        const error = createResult.variant.error;
+        if (error.message.includes("already exists")) {
+          return Result.err({
+            type: "SCHEMA_EXISTS",
+            message: `Schema for tenant ${tenantId} already exists`
+          });
+        }
+        return Result.err({
+          type: "DATABASE_ERROR",
+          message: `Failed to create schema for tenant ${tenantId}`,
+          cause: error
+        });
+      }
+      if (options.version) {
+        const versionResult = await this.initializeVersionTracking(
+          tenantId,
+          options.version
+        );
+        if (versionResult.isErr()) {
+          if (options.useTransaction) {
+            await this.connection.execute("ROLLBACK");
+          }
+          return versionResult;
+        }
+      }
+      if (options.useTransaction) {
+        await this.connection.execute("COMMIT");
+      }
+      this.logger.info("Tenant schema created", { tenantId, schemaName });
+      return Result.ok(void 0);
+    } catch (error) {
+      if (options.useTransaction) {
+        await this.connection.execute("ROLLBACK");
+      }
+      this.logger.error("Schema creation failed", { error, tenantId });
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: `Schema creation failed for tenant ${tenantId}: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Drop a tenant schema
+   *
+   * @param tenantId - Tenant identifier
+   * @param options - Drop schema options
+   * @returns Result with void on success or SchemaManagerError
+   */
+  async dropTenantSchema(tenantId, options = {}) {
+    const validationResult = this.validateTenantId(tenantId);
+    if (validationResult.isErr()) {
+      return validationResult;
+    }
+    const schemaName = this.getSchemaName(tenantId);
+    try {
+      this.logger.debug("Dropping tenant schema", { tenantId, schemaName });
+      let sql = `DROP SCHEMA ${options.ifExists ? "IF EXISTS " : ""}${schemaName}`;
+      if (options.cascade) {
+        sql += " CASCADE";
+      }
+      const dropResult = await this.connection.execute(sql, []);
+      if (dropResult.isErr()) {
+        const error = dropResult.variant.error;
+        return Result.err({
+          type: "DATABASE_ERROR",
+          message: `Failed to drop schema for tenant ${tenantId}`,
+          cause: error
+        });
+      }
+      if (options.cleanupVersions) {
+        await this.connection.execute(
+          `DELETE FROM ${this.config.schemaVersionTable} WHERE tenant_id = ?`,
+          [tenantId]
+        );
+      }
+      this.logger.info("Tenant schema dropped", { tenantId, schemaName });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Schema drop failed", { error, tenantId });
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: `Schema drop failed for tenant ${tenantId}: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Check if tenant schema exists
+   *
+   * @param tenantId - Tenant identifier
+   * @returns Result with boolean indicating existence
+   */
+  async schemaExists(tenantId) {
+    const schemaName = this.getSchemaName(tenantId);
+    try {
+      const result = await this.connection.execute(
+        `SELECT schema_name FROM information_schema.schemata WHERE schema_name = ?`,
+        [schemaName]
+      );
+      if (result.isErr()) {
+        return Result.err({
+          type: "DATABASE_ERROR",
+          message: "Failed to check schema existence",
+          cause: result.variant.error
+        });
+      }
+      const data = result.unwrap();
+      const rows = data.rows || data || [];
+      return Result.ok(rows.length > 0);
+    } catch (error) {
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: `Failed to check schema existence: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get current schema version for tenant
+   *
+   * @param tenantId - Tenant identifier
+   * @returns Result with version string or null
+   */
+  async getSchemaVersion(tenantId) {
+    try {
+      const result = await this.connection.execute(
+        `SELECT version FROM ${this.config.schemaVersionTable} WHERE tenant_id = ? ORDER BY applied_at DESC LIMIT 1`,
+        [tenantId]
+      );
+      if (result.isErr()) {
+        return Result.err({
+          type: "DATABASE_ERROR",
+          message: "Failed to get schema version",
+          cause: result.variant.error
+        });
+      }
+      const data = result.unwrap();
+      const rows = data.rows || data || [];
+      if (rows.length === 0) {
+        return Result.ok(null);
+      }
+      return Result.ok(rows[0].version);
+    } catch (error) {
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: `Failed to get schema version: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Update schema version for tenant
+   *
+   * @param tenantId - Tenant identifier
+   * @param version - New version string
+   * @returns Result with void on success
+   */
+  async updateSchemaVersion(tenantId, version2) {
+    if (!this.isValidVersion(version2)) {
+      return Result.err({
+        type: "INVALID_VERSION",
+        message: `Invalid version format: ${version2}. Expected semver format (e.g., 1.0.0)`
+      });
+    }
+    try {
+      const result = await this.connection.execute(
+        `INSERT INTO ${this.config.schemaVersionTable} (tenant_id, version, applied_at) VALUES (?, ?, ?)`,
+        [tenantId, version2, /* @__PURE__ */ new Date()]
+      );
+      if (result.isErr()) {
+        return Result.err({
+          type: "DATABASE_ERROR",
+          message: "Failed to update schema version",
+          cause: result.variant.error
+        });
+      }
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: `Failed to update schema version: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get version history for tenant
+   *
+   * @param tenantId - Tenant identifier
+   * @returns Result with array of schema versions
+   */
+  async getVersionHistory(tenantId) {
+    try {
+      const result = await this.connection.execute(
+        `SELECT version, applied_at, description FROM ${this.config.schemaVersionTable} WHERE tenant_id = ? ORDER BY applied_at ASC`,
+        [tenantId]
+      );
+      if (result.isErr()) {
+        return Result.err({
+          type: "DATABASE_ERROR",
+          message: "Failed to get version history",
+          cause: result.variant.error
+        });
+      }
+      const data = result.unwrap();
+      const rows = data.rows || data || [];
+      return Result.ok(rows);
+    } catch (error) {
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: `Failed to get version history: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Apply a migration to tenant schema
+   *
+   * @param tenantId - Tenant identifier
+   * @param migration - Migration definition
+   * @returns Result with void on success
+   */
+  async applyMigration(tenantId, migration) {
+    const schemaName = this.getSchemaName(tenantId);
+    try {
+      this.logger.debug("Applying migration", {
+        tenantId,
+        version: migration.version
+      });
+      const currentVersion = await this.getSchemaVersion(tenantId);
+      if (currentVersion.isOk() && currentVersion.unwrap() === migration.version) {
+        this.logger.info("Migration already applied", {
+          tenantId,
+          version: migration.version
+        });
+        return Result.ok(void 0);
+      }
+      await this.connection.execute(`SET search_path TO ${schemaName}`, []);
+      const migrationResult = await this.connection.execute(migration.sql, []);
+      if (migrationResult.isErr()) {
+        return Result.err({
+          type: "MIGRATION_FAILED",
+          message: `Migration ${migration.version} failed for tenant ${tenantId}`,
+          cause: migrationResult.variant.error
+        });
+      }
+      await this.connection.execute(
+        `INSERT INTO ${this.config.schemaVersionTable} (tenant_id, version, applied_at, description) VALUES (?, ?, ?, ?)`,
+        [tenantId, migration.version, /* @__PURE__ */ new Date(), migration.description || ""]
+      );
+      this.logger.info("Migration applied", {
+        tenantId,
+        version: migration.version
+      });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Migration failed", {
+        error,
+        tenantId,
+        version: migration.version
+      });
+      return Result.err({
+        type: "MIGRATION_FAILED",
+        message: `Migration failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get the schema name for a tenant
+   *
+   * @param tenantId - Tenant identifier
+   * @returns Schema name
+   */
+  getSchemaName(tenantId) {
+    if (/[;'"`\\]/.test(tenantId)) {
+      throw new Error(`Invalid tenant ID: contains dangerous characters`);
+    }
+    return `${this.config.baseSchemaName}_tenant_${tenantId.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+  }
+  /**
+   * Validate tenant ID format
+   */
+  validateTenantId(tenantId) {
+    if (!tenantId || typeof tenantId !== "string") {
+      return Result.err({
+        type: "INVALID_TENANT_ID",
+        message: "Tenant ID must be a non-empty string"
+      });
+    }
+    if (tenantId.trim().length === 0) {
+      return Result.err({
+        type: "INVALID_TENANT_ID",
+        message: "Tenant ID cannot be whitespace only"
+      });
+    }
+    if (/[;'"`\\]/.test(tenantId)) {
+      return Result.err({
+        type: "INVALID_TENANT_ID",
+        message: "Tenant ID contains invalid characters"
+      });
+    }
+    return Result.ok(void 0);
+  }
+  /**
+   * Validate version format (simple semver check)
+   */
+  isValidVersion(version2) {
+    return /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/.test(version2);
+  }
+  /**
+   * Initialize version tracking for new tenant
+   */
+  async initializeVersionTracking(tenantId, version2) {
+    if (!this.isValidVersion(version2)) {
+      return Result.err({
+        type: "INVALID_VERSION",
+        message: `Invalid version format: ${version2}`
+      });
+    }
+    const result = await this.connection.execute(
+      `INSERT INTO ${this.config.schemaVersionTable} (tenant_id, version, applied_at) VALUES (?, ?, ?)`,
+      [tenantId, version2, /* @__PURE__ */ new Date()]
+    );
+    if (result.isErr()) {
+      return Result.err({
+        type: "DATABASE_ERROR",
+        message: "Failed to initialize version tracking",
+        cause: result.variant.error
+      });
+    }
+    return Result.ok(void 0);
+  }
+};
+var MemoryCache = class {
+  config;
+  logger;
+  store;
+  lruList = [];
+  // Most recent at end
+  stats = {
+    hits: 0,
+    misses: 0,
+    evictions: 0
+  };
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async get(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const entry = this.store.get(fullKey);
+      if (!entry) {
+        this.stats.misses++;
+        return Result.ok(Option.none());
+      }
+      if (this.isExpired(entry)) {
+        this.store.delete(fullKey);
+        this.removeLRU(fullKey);
+        this.stats.misses++;
+        return Result.ok(Option.none());
+      }
+      this.touchEntry(fullKey, entry);
+      this.stats.hits++;
+      return Result.ok(Option.some(entry.value));
+    } catch (error) {
+      this.logger.error("Cache get failed", { error, key });
+      return Result.err({
+        type: "GET_FAILED",
+        message: `Failed to get cache entry: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async getWithMetadata(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const entry = this.store.get(fullKey);
+      if (!entry) {
+        this.stats.misses++;
+        return Result.ok(Option.none());
+      }
+      if (this.isExpired(entry)) {
+        this.store.delete(fullKey);
+        this.removeLRU(fullKey);
+        this.stats.misses++;
+        return Result.ok(Option.none());
+      }
+      this.touchEntry(fullKey, entry);
+      this.stats.hits++;
+      return Result.ok(Option.some(entry));
+    } catch (error) {
+      this.logger.error("Cache getWithMetadata failed", { error, key });
+      return Result.err({
+        type: "GET_FAILED",
+        message: `Failed to get cache entry with metadata: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async set(key, value, ttl) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const effectiveTTL = ttl !== void 0 ? ttl : this.config.defaultTTL;
+      if (this.config.maxItems && this.store.size >= this.config.maxItems && !this.store.has(fullKey)) {
+        this.evictLRU();
+      }
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = effectiveTTL > 0 ? new Date(now.getTime() + effectiveTTL * 1e3) : void 0;
+      const metadata = {
+        key: fullKey,
+        createdAt: now,
+        lastAccessedAt: now,
+        accessCount: 0,
+        size: this.estimateSize(value),
+        ttl: effectiveTTL,
+        expiresAt
+      };
+      const entry = {
+        value,
+        metadata
+      };
+      if (this.store.has(fullKey)) {
+        this.removeLRU(fullKey);
+      }
+      this.store.set(fullKey, entry);
+      this.lruList.push(fullKey);
+      this.logger.debug("Cache set", { key, ttl: effectiveTTL });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Cache set failed", { error, key });
+      return Result.err({
+        type: "SET_FAILED",
+        message: `Failed to set cache entry: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async delete(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const existed = this.store.delete(fullKey);
+      if (existed) {
+        this.removeLRU(fullKey);
+        this.logger.debug("Cache delete", { key });
+      }
+      return Result.ok(existed);
+    } catch (error) {
+      this.logger.error("Cache delete failed", { error, key });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to delete cache entry: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async deleteMany(keys) {
+    try {
+      let deleted = 0;
+      for (const key of keys) {
+        const result = await this.delete(key);
+        if (result.isOk() && result.unwrap()) {
+          deleted++;
+        }
+      }
+      return Result.ok(deleted);
+    } catch (error) {
+      this.logger.error("Cache deleteMany failed", { error });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to delete multiple cache entries: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async clear() {
+    try {
+      this.store.clear();
+      this.lruList.length = 0;
+      this.logger.debug("Cache cleared");
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Cache clear failed", { error });
+      return Result.err({
+        type: "CLEAR_FAILED",
+        message: `Failed to clear cache: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async has(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const entry = this.store.get(fullKey);
+      if (!entry) {
+        return Result.ok(false);
+      }
+      if (this.isExpired(entry)) {
+        this.store.delete(fullKey);
+        this.removeLRU(fullKey);
+        return Result.ok(false);
+      }
+      return Result.ok(true);
+    } catch (error) {
+      this.logger.error("Cache has failed", { error, key });
+      return Result.err({
+        type: "GET_FAILED",
+        message: `Failed to check cache key existence: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async invalidate(pattern) {
+    try {
+      const fullPattern = this.config.keyPrefix ? `${this.config.keyPrefix}${pattern}` : pattern;
+      const regex = this.patternToRegex(fullPattern);
+      let invalidated = 0;
+      for (const key of this.store.keys()) {
+        if (regex.test(key)) {
+          this.store.delete(key);
+          this.removeLRU(key);
+          invalidated++;
+        }
+      }
+      this.logger.debug("Cache invalidate", { pattern, count: invalidated });
+      return Result.ok(invalidated);
+    } catch (error) {
+      this.logger.error("Cache invalidate failed", { error, pattern });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to invalidate cache entries: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async invalidateTable(table) {
+    try {
+      const pattern = `*${table}*`;
+      return await this.invalidate(pattern);
+    } catch (error) {
+      this.logger.error("Cache invalidateTable failed", { error, table });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to invalidate table cache: ${error}`,
+        cause: error
+      });
+    }
+  }
+  getStats() {
+    try {
+      const totalAccesses = this.stats.hits + this.stats.misses;
+      const hitRate = totalAccesses > 0 ? this.stats.hits / totalAccesses : 0;
+      let totalSize = 0;
+      for (const entry of this.store.values()) {
+        totalSize += entry.metadata.size;
+      }
+      return Result.ok({
+        itemCount: this.store.size,
+        totalSize,
+        hits: this.stats.hits,
+        misses: this.stats.misses,
+        hitRate,
+        evictions: this.stats.evictions
+      });
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get cache stats: ${error}`,
+        cause: error
+      });
+    }
+  }
+  resetStats() {
+    try {
+      this.stats.hits = 0;
+      this.stats.misses = 0;
+      this.stats.evictions = 0;
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to reset cache stats: ${error}`,
+        cause: error
+      });
+    }
+  }
+  generateKey(sql, params) {
+    const data = {
+      sql,
+      params: params || []
+    };
+    const hash = crypto.createHash("sha256").update(JSON.stringify(data)).digest("hex");
+    return hash.substring(0, 16);
+  }
+  /**
+   * Get full cache key with prefix
+   */
+  getFullKey(key) {
+    return this.config.keyPrefix ? `${this.config.keyPrefix}${key}` : key;
+  }
+  /**
+   * Check if entry is expired
+   */
+  isExpired(entry) {
+    if (!entry.metadata.expiresAt) {
+      return false;
+    }
+    return /* @__PURE__ */ new Date() > entry.metadata.expiresAt;
+  }
+  /**
+   * Update entry access metadata and LRU position
+   */
+  touchEntry(key, entry) {
+    entry.metadata.lastAccessedAt = /* @__PURE__ */ new Date();
+    entry.metadata.accessCount++;
+    this.removeLRU(key);
+    this.lruList.push(key);
+  }
+  /**
+   * Remove key from LRU list
+   */
+  removeLRU(key) {
+    const index = this.lruList.indexOf(key);
+    if (index > -1) {
+      this.lruList.splice(index, 1);
+    }
+  }
+  /**
+   * Evict least recently used entry
+   */
+  evictLRU() {
+    if (this.lruList.length === 0) {
+      return;
+    }
+    const lruKey = this.lruList[0];
+    this.store.delete(lruKey);
+    this.lruList.shift();
+    this.stats.evictions++;
+    this.logger.debug("LRU eviction", { key: lruKey });
+  }
+  /**
+   * Estimate size of value in bytes
+   */
+  estimateSize(value) {
+    try {
+      return JSON.stringify(value).length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Convert glob pattern to regex
+   */
+  patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+  }
+};
+var KVCache = class {
+  config;
+  kv;
+  logger;
+  stats = {
+    hits: 0,
+    misses: 0
+  };
+  constructor(kv, config, logger) {
+    this.kv = kv;
+    this.config = config;
+    this.logger = logger;
+  }
+  async get(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      let value = await this.kv.get(fullKey, { type: "json" });
+      if (value === null) {
+        this.stats.misses++;
+        return Result.ok(Option.none());
+      }
+      if (typeof value === "string") {
+        try {
+          value = JSON.parse(value);
+        } catch {
+          this.stats.hits++;
+          return Result.ok(Option.some(value));
+        }
+      }
+      this.stats.hits++;
+      if (value && typeof value === "object" && "value" in value) {
+        return Result.ok(Option.some(value.value));
+      }
+      return Result.ok(Option.some(value));
+    } catch (error) {
+      this.logger.error("KV cache get failed", { error, key });
+      return Result.err({
+        type: "GET_FAILED",
+        message: `Failed to get cache entry from KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async getWithMetadata(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      let value = await this.kv.get(fullKey, { type: "json" });
+      if (value === null) {
+        this.stats.misses++;
+        return Result.ok(Option.none());
+      }
+      if (typeof value === "string") {
+        try {
+          value = JSON.parse(value);
+        } catch {
+          const now2 = /* @__PURE__ */ new Date();
+          this.stats.hits++;
+          const entry2 = {
+            value,
+            metadata: {
+              key: fullKey,
+              createdAt: now2,
+              lastAccessedAt: now2,
+              accessCount: 1,
+              size: this.estimateSize(value),
+              ttl: this.config.defaultTTL
+            }
+          };
+          return Result.ok(Option.some(entry2));
+        }
+      }
+      this.stats.hits++;
+      if (value && typeof value === "object" && "value" in value && "metadata" in value) {
+        const entry2 = value;
+        entry2.metadata.createdAt = new Date(entry2.metadata.createdAt);
+        entry2.metadata.lastAccessedAt = new Date(entry2.metadata.lastAccessedAt);
+        if (entry2.metadata.expiresAt) {
+          entry2.metadata.expiresAt = new Date(entry2.metadata.expiresAt);
+        }
+        return Result.ok(Option.some(entry2));
+      }
+      const now = /* @__PURE__ */ new Date();
+      const entry = {
+        value,
+        metadata: {
+          key: fullKey,
+          createdAt: now,
+          lastAccessedAt: now,
+          accessCount: 1,
+          size: this.estimateSize(value),
+          ttl: this.config.defaultTTL
+        }
+      };
+      return Result.ok(Option.some(entry));
+    } catch (error) {
+      this.logger.error("KV cache getWithMetadata failed", { error, key });
+      return Result.err({
+        type: "GET_FAILED",
+        message: `Failed to get cache entry with metadata from KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async set(key, value, ttl) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const effectiveTTL = ttl !== void 0 ? ttl : this.config.defaultTTL;
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = effectiveTTL > 0 ? new Date(now.getTime() + effectiveTTL * 1e3) : void 0;
+      const metadata = {
+        key: fullKey,
+        createdAt: now,
+        lastAccessedAt: now,
+        accessCount: 0,
+        size: this.estimateSize(value),
+        ttl: effectiveTTL,
+        expiresAt
+      };
+      const entry = {
+        value,
+        metadata
+      };
+      const options = effectiveTTL > 0 ? { expirationTtl: effectiveTTL } : {};
+      await this.kv.put(fullKey, JSON.stringify(entry), options);
+      this.logger.debug("KV cache set", { key, ttl: effectiveTTL });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("KV cache set failed", { error, key });
+      return Result.err({
+        type: "SET_FAILED",
+        message: `Failed to set cache entry in KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async delete(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const existed = await this.kv.get(fullKey);
+      await this.kv.delete(fullKey);
+      const wasDeleted = existed !== null;
+      if (wasDeleted) {
+        this.logger.debug("KV cache delete", { key });
+      }
+      return Result.ok(wasDeleted);
+    } catch (error) {
+      this.logger.error("KV cache delete failed", { error, key });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to delete cache entry from KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async deleteMany(keys) {
+    try {
+      let deleted = 0;
+      for (const key of keys) {
+        const result = await this.delete(key);
+        if (result.isOk() && result.unwrap()) {
+          deleted++;
+        }
+      }
+      return Result.ok(deleted);
+    } catch (error) {
+      this.logger.error("KV cache deleteMany failed", { error });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to delete multiple cache entries from KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async clear() {
+    try {
+      const prefix = this.config.keyPrefix || "";
+      let cursor;
+      let totalDeleted = 0;
+      do {
+        const listResult = await this.kv.list({
+          prefix,
+          limit: 1e3,
+          cursor
+        });
+        const deletePromises = listResult.keys.map(({ name }) => this.kv.delete(name));
+        await Promise.all(deletePromises);
+        totalDeleted += listResult.keys.length;
+        cursor = listResult.list_complete ? void 0 : listResult.cursor;
+      } while (cursor);
+      this.logger.debug("KV cache cleared", { deleted: totalDeleted });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("KV cache clear failed", { error });
+      return Result.err({
+        type: "CLEAR_FAILED",
+        message: `Failed to clear KV cache: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async has(key) {
+    try {
+      const fullKey = this.getFullKey(key);
+      const value = await this.kv.get(fullKey);
+      return Result.ok(value !== null);
+    } catch (error) {
+      this.logger.error("KV cache has failed", { error, key });
+      return Result.err({
+        type: "GET_FAILED",
+        message: `Failed to check cache key existence in KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async invalidate(pattern) {
+    try {
+      const fullPattern = this.config.keyPrefix ? `${this.config.keyPrefix}${pattern}` : pattern;
+      const prefix = fullPattern.split("*")[0].split("?")[0];
+      const regex = this.patternToRegex(fullPattern);
+      let invalidated = 0;
+      let cursor;
+      do {
+        const listResult = await this.kv.list({
+          prefix,
+          limit: 1e3,
+          cursor
+        });
+        const matchingKeys = listResult.keys.map(({ name }) => name).filter((name) => regex.test(name));
+        const deletePromises = matchingKeys.map((name) => this.kv.delete(name));
+        await Promise.all(deletePromises);
+        invalidated += matchingKeys.length;
+        cursor = listResult.list_complete ? void 0 : listResult.cursor;
+      } while (cursor);
+      this.logger.debug("KV cache invalidate", { pattern, count: invalidated });
+      return Result.ok(invalidated);
+    } catch (error) {
+      this.logger.error("KV cache invalidate failed", { error, pattern });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to invalidate cache entries in KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  async invalidateTable(table) {
+    try {
+      const pattern = `*${table}*`;
+      return await this.invalidate(pattern);
+    } catch (error) {
+      this.logger.error("KV cache invalidateTable failed", { error, table });
+      return Result.err({
+        type: "DELETE_FAILED",
+        message: `Failed to invalidate table cache in KV: ${error}`,
+        cause: error
+      });
+    }
+  }
+  getStats() {
+    try {
+      const totalAccesses = this.stats.hits + this.stats.misses;
+      const hitRate = totalAccesses > 0 ? this.stats.hits / totalAccesses : 0;
+      return Result.ok({
+        itemCount: 0,
+        // Not available for KV
+        totalSize: 0,
+        // Not available for KV
+        hits: this.stats.hits,
+        misses: this.stats.misses,
+        hitRate,
+        evictions: 0
+        // KV handles eviction internally
+      });
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get KV cache stats: ${error}`,
+        cause: error
+      });
+    }
+  }
+  resetStats() {
+    try {
+      this.stats.hits = 0;
+      this.stats.misses = 0;
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to reset KV cache stats: ${error}`,
+        cause: error
+      });
+    }
+  }
+  generateKey(sql, params) {
+    const data = {
+      sql,
+      params: params || []
+    };
+    const hash = crypto.createHash("sha256").update(JSON.stringify(data)).digest("hex");
+    return hash.substring(0, 16);
+  }
+  /**
+   * Get full cache key with prefix
+   */
+  getFullKey(key) {
+    return this.config.keyPrefix ? `${this.config.keyPrefix}${key}` : key;
+  }
+  /**
+   * Estimate size of value in bytes
+   */
+  estimateSize(value) {
+    try {
+      return JSON.stringify(value).length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Convert glob pattern to regex
+   */
+  patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+  }
+};
+var CacheInvalidator = class {
+  cache;
+  eventBus;
+  logger;
+  // Tag index: tag -> Set<key>
+  tagIndex = /* @__PURE__ */ new Map();
+  // Entry tags: key -> Set<tag>
+  entryTags = /* @__PURE__ */ new Map();
+  // Statistics
+  stats = {
+    totalInvalidations: 0,
+    tagInvalidations: 0,
+    patternInvalidations: 0,
+    keyInvalidations: 0,
+    expiredInvalidations: 0
+  };
+  constructor(cache, eventBus, logger) {
+    this.cache = cache;
+    this.eventBus = eventBus;
+    this.logger = logger;
+  }
+  /**
+   * Tag a cache entry for group invalidation
+   *
+   * @param key - Cache key
+   * @param tags - Array of tags to associate with this entry
+   * @returns Result with void on success
+   */
+  async tagEntry(key, tags) {
+    try {
+      if (!this.entryTags.has(key)) {
+        this.entryTags.set(key, /* @__PURE__ */ new Set());
+      }
+      const entryTagSet = this.entryTags.get(key);
+      for (const tag of tags) {
+        entryTagSet.add(tag);
+        if (!this.tagIndex.has(tag)) {
+          this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+        }
+        this.tagIndex.get(tag).add(key);
+      }
+      this.logger.debug("Tagged cache entry", { key, tags });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Failed to tag entry", { error, key, tags });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to tag entry: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Remove a tag from a cache entry
+   *
+   * @param key - Cache key
+   * @param tag - Tag to remove
+   * @returns Result with void on success
+   */
+  async removeTag(key, tag) {
+    try {
+      const entryTagSet = this.entryTags.get(key);
+      if (entryTagSet) {
+        entryTagSet.delete(tag);
+        if (entryTagSet.size === 0) {
+          this.entryTags.delete(key);
+        }
+      }
+      const tagSet = this.tagIndex.get(tag);
+      if (tagSet) {
+        tagSet.delete(key);
+        if (tagSet.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+      this.logger.debug("Removed tag from entry", { key, tag });
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Failed to remove tag", { error, key, tag });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to remove tag: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Invalidate all entries with a specific tag
+   *
+   * @param tag - Tag to invalidate (supports wildcards)
+   * @returns Result with number of invalidated entries
+   */
+  async invalidateByTag(tag) {
+    try {
+      const keysToInvalidate = /* @__PURE__ */ new Set();
+      if (tag.includes("*") || tag.includes("?")) {
+        const regex = this.patternToRegex(tag);
+        for (const [tagName, keys] of this.tagIndex.entries()) {
+          if (regex.test(tagName)) {
+            for (const key of keys) {
+              keysToInvalidate.add(key);
+            }
+          }
+        }
+      } else {
+        const keys = this.tagIndex.get(tag);
+        if (keys) {
+          for (const key of keys) {
+            keysToInvalidate.add(key);
+          }
+        }
+      }
+      let invalidated = 0;
+      for (const key of keysToInvalidate) {
+        const result = await this.cache.delete(key);
+        if (result.isOk() && result.unwrap()) {
+          invalidated++;
+          await this.cleanupEntryTags(key);
+        }
+      }
+      this.stats.totalInvalidations += invalidated;
+      this.stats.tagInvalidations += invalidated;
+      this.logger.debug("Invalidated by tag", { tag, count: invalidated });
+      await this.eventBus.emit("cache:invalidated", {
+        type: "tag",
+        tag,
+        count: invalidated
+      });
+      return Result.ok(invalidated);
+    } catch (error) {
+      this.logger.error("Failed to invalidate by tag", { error, tag });
+      return Result.err({
+        type: "INVALIDATION_FAILED",
+        message: `Failed to invalidate by tag: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Invalidate entries by multiple tags
+   *
+   * @param tags - Array of tags to invalidate
+   * @returns Result with number of invalidated entries
+   */
+  async invalidateByTags(tags) {
+    try {
+      const keysToInvalidate = /* @__PURE__ */ new Set();
+      for (const tag of tags) {
+        const result = await this.getTaggedKeys(tag);
+        if (result.isOk()) {
+          const keys = result.unwrap();
+          for (const key of keys) {
+            keysToInvalidate.add(key);
+          }
+        }
+      }
+      let invalidated = 0;
+      for (const key of keysToInvalidate) {
+        const result = await this.cache.delete(key);
+        if (result.isOk() && result.unwrap()) {
+          invalidated++;
+          await this.cleanupEntryTags(key);
+        }
+      }
+      this.stats.totalInvalidations += invalidated;
+      this.stats.tagInvalidations += invalidated;
+      this.logger.debug("Invalidated by tags", { tags, count: invalidated });
+      return Result.ok(invalidated);
+    } catch (error) {
+      this.logger.error("Failed to invalidate by tags", { error, tags });
+      return Result.err({
+        type: "INVALIDATION_FAILED",
+        message: `Failed to invalidate by tags: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Invalidate specific cache keys
+   *
+   * @param keys - Array of keys to invalidate
+   * @returns Result with number of invalidated entries
+   */
+  async invalidateByKeys(keys) {
+    try {
+      let invalidated = 0;
+      for (const key of keys) {
+        const result = await this.cache.delete(key);
+        if (result.isOk() && result.unwrap()) {
+          invalidated++;
+          await this.cleanupEntryTags(key);
+        }
+      }
+      this.stats.totalInvalidations += invalidated;
+      this.stats.keyInvalidations += invalidated;
+      this.logger.debug("Invalidated by keys", { count: invalidated });
+      return Result.ok(invalidated);
+    } catch (error) {
+      this.logger.error("Failed to invalidate by keys", { error, keys });
+      return Result.err({
+        type: "INVALIDATION_FAILED",
+        message: `Failed to invalidate by keys: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Invalidate entries matching a pattern
+   *
+   * @param pattern - Pattern to match (supports wildcards)
+   * @returns Result with number of invalidated entries
+   */
+  async invalidateByPattern(pattern) {
+    try {
+      const result = await this.cache.invalidate(pattern);
+      if (result.isOk()) {
+        const count = result.unwrap();
+        this.stats.totalInvalidations += count;
+        this.stats.patternInvalidations += count;
+      }
+      return result;
+    } catch (error) {
+      this.logger.error("Failed to invalidate by pattern", { error, pattern });
+      return Result.err({
+        type: "INVALIDATION_FAILED",
+        message: `Failed to invalidate by pattern: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Scan and invalidate expired entries
+   *
+   * @returns Result with number of invalidated entries
+   */
+  async invalidateExpired() {
+    try {
+      let invalidated = 0;
+      const allKeys = Array.from(this.entryTags.keys());
+      for (const key of allKeys) {
+        const result = await this.cache.get(key);
+        if (result.isOk() && result.unwrap().isNone()) {
+          await this.cleanupEntryTags(key);
+          invalidated++;
+        }
+      }
+      this.stats.totalInvalidations += invalidated;
+      this.stats.expiredInvalidations += invalidated;
+      this.logger.debug("Invalidated expired entries", { count: invalidated });
+      return Result.ok(invalidated);
+    } catch (error) {
+      this.logger.error("Failed to invalidate expired entries", { error });
+      return Result.err({
+        type: "INVALIDATION_FAILED",
+        message: `Failed to invalidate expired entries: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Subscribe to data change events for automatic invalidation
+   *
+   * @returns Unsubscribe function
+   */
+  subscribeToDataChanges() {
+    const unsubscribers = [];
+    unsubscribers.push(
+      this.eventBus.subscribe("*", async (data) => {
+      })
+    );
+    const cacheInvalidateHandler = async (data) => {
+      if (data && data.tag) {
+        await this.invalidateByTag(data.tag);
+      }
+    };
+    const events = [
+      "cache:invalidate:users",
+      "cache:invalidate:posts",
+      "cache:invalidate:comments"
+    ];
+    for (const event of events) {
+      unsubscribers.push(this.eventBus.subscribe(event, cacheInvalidateHandler));
+    }
+    unsubscribers.push(
+      this.eventBus.subscribe("cache:invalidate:batch", async (data) => {
+        if (data && data.tags) {
+          await this.invalidateByTags(data.tags);
+        }
+      })
+    );
+    const dataUpdateHandler = async (data) => {
+      if (data && data.table) {
+        await this.cache.invalidateTable(data.table);
+      }
+    };
+    const dataEvents = ["data:updated:users", "data:updated:posts"];
+    for (const event of dataEvents) {
+      unsubscribers.push(this.eventBus.subscribe(event, dataUpdateHandler));
+    }
+    return () => {
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe();
+      }
+    };
+  }
+  /**
+   * Get all keys tagged with a specific tag
+   *
+   * @param tag - Tag name
+   * @returns Result with array of keys
+   */
+  async getTaggedKeys(tag) {
+    try {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        return Result.ok([]);
+      }
+      return Result.ok(Array.from(keys));
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get tagged keys: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get all tags for a cache entry
+   *
+   * @param key - Cache key
+   * @returns Result with array of tags
+   */
+  async getEntryTags(key) {
+    try {
+      const tags = this.entryTags.get(key);
+      if (!tags) {
+        return Result.ok([]);
+      }
+      return Result.ok(Array.from(tags));
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get entry tags: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get invalidation statistics
+   *
+   * @returns Result with statistics
+   */
+  getStats() {
+    try {
+      return Result.ok({ ...this.stats });
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get stats: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Reset invalidation statistics
+   *
+   * @returns Result with void on success
+   */
+  resetStats() {
+    try {
+      this.stats = {
+        totalInvalidations: 0,
+        tagInvalidations: 0,
+        patternInvalidations: 0,
+        keyInvalidations: 0,
+        expiredInvalidations: 0
+      };
+      return Result.ok(void 0);
+    } catch (error) {
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to reset stats: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Clean up tag mappings for a deleted entry
+   */
+  async cleanupEntryTags(key) {
+    const tags = this.entryTags.get(key);
+    if (tags) {
+      for (const tag of tags) {
+        const tagSet = this.tagIndex.get(tag);
+        if (tagSet) {
+          tagSet.delete(key);
+          if (tagSet.size === 0) {
+            this.tagIndex.delete(tag);
+          }
+        }
+      }
+      this.entryTags.delete(key);
+    }
+  }
+  /**
+   * Convert glob pattern to regex
+   */
+  patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+  }
+};
+var MigrationLoader = class {
+  config;
+  logger;
+  filePattern;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.filePattern = config.filePattern || /^(\d+|V\d+)[_-].*\.ts$/;
+  }
+  /**
+   * Load all migrations from the configured directory
+   *
+   * @returns Result with array of migrations ordered by version
+   */
+  async loadMigrations() {
+    try {
+      if (!fs.existsSync(this.config.migrationsPath)) {
+        return Result.err({
+          type: "INVALID_MIGRATION",
+          message: `Migrations directory does not exist: ${this.config.migrationsPath}`
+        });
+      }
+      const files = fs.readdirSync(this.config.migrationsPath);
+      const migrationFiles = files.filter((file) => this.filePattern.test(file));
+      this.logger.debug("Found migration files", {
+        total: files.length,
+        migrations: migrationFiles.length
+      });
+      const migrations = [];
+      for (const file of migrationFiles) {
+        const filePath = path.join(this.config.migrationsPath, file);
+        const result = await this.loadMigrationFile(filePath);
+        if (result.isErr()) {
+          return result;
+        }
+        migrations.push(result.unwrap());
+      }
+      const duplicates = this.findDuplicateVersions(migrations);
+      if (duplicates.length > 0) {
+        return Result.err({
+          type: "INVALID_MIGRATION",
+          message: `Duplicate migration versions found: ${duplicates.join(", ")}`
+        });
+      }
+      migrations.sort((a, b) => a.version - b.version);
+      this.logger.debug("Loaded migrations", { count: migrations.length });
+      return Result.ok(migrations);
+    } catch (error) {
+      this.logger.error("Failed to load migrations", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to load migrations: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Load a single migration file
+   *
+   * @param filePath - Path to migration file
+   * @returns Result with Migration or MigrationError
+   */
+  async loadMigrationFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const fileUrl = `file://${filePath.replace(/\\/g, "/")}`;
+      const module = await import(fileUrl);
+      const validation = this.validateMigration(module, filePath);
+      if (validation.isErr()) {
+        return validation;
+      }
+      const { version: version2, name, up, down } = module;
+      const id = this.generateMigrationId(version2, name);
+      const checksum = this.computeChecksum(content);
+      const migration = {
+        id,
+        version: version2,
+        name,
+        up,
+        down,
+        checksum
+      };
+      this.logger.debug("Loaded migration", { id, version: version2, name });
+      return Result.ok(migration);
+    } catch (error) {
+      this.logger.error("Failed to load migration file", { error, filePath });
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Failed to load migration file ${filePath}: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Validate migration module structure
+   *
+   * @param module - Migration module
+   * @param filePath - File path for error messages
+   * @returns Result with void on success or MigrationError
+   */
+  validateMigration(module, filePath) {
+    if (module.version === void 0) {
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Migration ${filePath} is missing 'version' export`
+      });
+    }
+    if (typeof module.version !== "number") {
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Migration ${filePath} has invalid version type (must be number)`
+      });
+    }
+    if (module.version < 0) {
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Migration ${filePath} has negative version number`
+      });
+    }
+    if (!module.name) {
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Migration ${filePath} is missing 'name' export`
+      });
+    }
+    if (!module.up || typeof module.up !== "function") {
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Migration ${filePath} is missing 'up' function`
+      });
+    }
+    if (!module.down || typeof module.down !== "function") {
+      return Result.err({
+        type: "INVALID_MIGRATION",
+        message: `Migration ${filePath} is missing 'down' function`
+      });
+    }
+    return Result.ok(void 0);
+  }
+  /**
+   * Find duplicate version numbers in migrations
+   *
+   * @param migrations - Array of migrations
+   * @returns Array of duplicate version numbers
+   */
+  findDuplicateVersions(migrations) {
+    const versionCounts = /* @__PURE__ */ new Map();
+    for (const migration of migrations) {
+      const count = versionCounts.get(migration.version) || 0;
+      versionCounts.set(migration.version, count + 1);
+    }
+    const duplicates = [];
+    for (const [version2, count] of versionCounts.entries()) {
+      if (count > 1) {
+        duplicates.push(version2);
+      }
+    }
+    return duplicates;
+  }
+  /**
+   * Generate unique migration ID from version and name
+   *
+   * @param version - Migration version
+   * @param name - Migration name
+   * @returns Migration ID
+   */
+  generateMigrationId(version2, name) {
+    return `${version2}_${name}`;
+  }
+  /**
+   * Compute SHA-256 checksum of migration content
+   *
+   * @param content - Migration file content
+   * @returns Checksum string
+   */
+  computeChecksum(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  /**
+   * Get SQL schema for migration tracking table
+   *
+   * @returns SQL CREATE TABLE statement
+   */
+  getMigrationTableSchema() {
+    const tableName = this.config.migrationTable;
+    return `
+CREATE TABLE IF NOT EXISTS ${tableName} (
+  id TEXT PRIMARY KEY,
+  version INTEGER NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  checksum TEXT,
+  status TEXT NOT NULL DEFAULT 'PENDING',
+  executed_at TIMESTAMP,
+  execution_time INTEGER,
+  error TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_${tableName}_version ON ${tableName}(version);
+CREATE INDEX IF NOT EXISTS idx_${tableName}_status ON ${tableName}(status);
+    `.trim();
+  }
+};
+var MigrationRunner = class {
+  connection;
+  loader;
+  config;
+  logger;
+  constructor(connection, loader, config, logger) {
+    this.connection = connection;
+    this.loader = loader;
+    this.config = config;
+    this.logger = logger;
+  }
+  /**
+   * Create migration table if it doesn't exist
+   */
+  async createMigrationTable() {
+    try {
+      const schema = this.loader.getMigrationTableSchema();
+      const result = await this.connection.execute(schema);
+      if (result.isErr()) {
+        return Result.err({
+          type: "UNKNOWN",
+          message: "Failed to create migration table",
+          cause: result.variant.error
+        });
+      }
+      this.logger.debug("Migration table created");
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Failed to create migration table", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to create migration table: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get all available migrations
+   */
+  async getMigrations() {
+    return this.loader.loadMigrations();
+  }
+  /**
+   * Get migration history from database
+   */
+  async getHistory() {
+    try {
+      const query = `SELECT * FROM ${this.config.migrationTable} ORDER BY version DESC`;
+      const result = await this.connection.query(query);
+      if (result.isErr()) {
+        return Result.err({
+          type: "UNKNOWN",
+          message: "Failed to get migration history",
+          cause: result.variant.error
+        });
+      }
+      const rows = result.unwrap();
+      const history = rows.map((row) => ({
+        id: row.id,
+        version: row.version,
+        name: row.name,
+        status: row.status,
+        executedAt: row.executed_at ? new Date(row.executed_at) : void 0,
+        executionTime: row.execution_time,
+        error: row.error,
+        checksum: row.checksum
+      }));
+      return Result.ok(history);
+    } catch (error) {
+      this.logger.error("Failed to get migration history", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get migration history: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get pending migrations
+   */
+  async getPending() {
+    try {
+      const migrationsResult = await this.getMigrations();
+      if (migrationsResult.isErr()) {
+        return migrationsResult;
+      }
+      const allMigrations = migrationsResult.unwrap();
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const appliedVersions = new Set(
+        history.filter((h) => h.status === "COMPLETED").map((h) => h.version)
+      );
+      const pending = allMigrations.filter((m) => !appliedVersions.has(m.version));
+      return Result.ok(pending);
+    } catch (error) {
+      this.logger.error("Failed to get pending migrations", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get pending migrations: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Run all pending migrations
+   */
+  async migrate() {
+    try {
+      if (this.config.validateChecksums) {
+        const validationResult = await this.validateChecksums();
+        if (validationResult.isErr()) {
+          return Result.err(validationResult.variant.error);
+        }
+      }
+      const pendingResult = await this.getPending();
+      if (pendingResult.isErr()) {
+        return Result.err(pendingResult.variant.error);
+      }
+      const pending = pendingResult.unwrap();
+      const applied = [];
+      for (const migration of pending) {
+        const result = await this.runMigration(migration, "UP");
+        if (result.isErr()) {
+          return Result.err(result.variant.error);
+        }
+        applied.push(result.unwrap());
+      }
+      this.logger.info("Migrations completed", { count: applied.length });
+      return Result.ok(applied);
+    } catch (error) {
+      this.logger.error("Migration failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Migration failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Run migrations up to a specific version
+   */
+  async migrateTo(targetVersion) {
+    try {
+      const migrationsResult = await this.getMigrations();
+      if (migrationsResult.isErr()) {
+        return Result.err(migrationsResult.variant.error);
+      }
+      const allMigrations = migrationsResult.unwrap();
+      const targetMigration = allMigrations.find((m) => m.version === targetVersion);
+      if (!targetMigration) {
+        return Result.err({
+          type: "MIGRATION_NOT_FOUND",
+          message: `Migration version ${targetVersion} not found`,
+          migrationId: `${targetVersion}`
+        });
+      }
+      const pendingResult = await this.getPending();
+      if (pendingResult.isErr()) {
+        return Result.err(pendingResult.variant.error);
+      }
+      const pending = pendingResult.unwrap();
+      const toApply = pending.filter((m) => m.version <= targetVersion);
+      const applied = [];
+      for (const migration of toApply) {
+        const result = await this.runMigration(migration, "UP");
+        if (result.isErr()) {
+          return Result.err(result.variant.error);
+        }
+        applied.push(result.unwrap());
+      }
+      this.logger.info("Migrated to version", { version: targetVersion });
+      return Result.ok(applied);
+    } catch (error) {
+      this.logger.error("Migration to version failed", { error, targetVersion });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Migration to version ${targetVersion} failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Rollback the last migration
+   */
+  async rollback() {
+    try {
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const completed = history.filter((h) => h.status === "COMPLETED");
+      if (completed.length === 0) {
+        return Result.err({
+          type: "NOT_APPLIED",
+          message: "No migrations to rollback",
+          migrationId: ""
+        });
+      }
+      const lastMigration = completed[0];
+      const migrationsResult = await this.getMigrations();
+      if (migrationsResult.isErr()) {
+        return Result.err(migrationsResult.variant.error);
+      }
+      const migrations = migrationsResult.unwrap();
+      const migration = migrations.find((m) => m.id === lastMigration.id);
+      if (!migration) {
+        return Result.err({
+          type: "MIGRATION_NOT_FOUND",
+          message: `Migration ${lastMigration.id} not found`,
+          migrationId: lastMigration.id
+        });
+      }
+      const result = await this.runMigration(migration, "DOWN");
+      if (result.isErr()) {
+        return Result.err(result.variant.error);
+      }
+      this.logger.info("Rolled back migration", { id: migration.id });
+      return Result.ok(result.unwrap());
+    } catch (error) {
+      this.logger.error("Rollback failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Rollback failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Rollback to a specific version
+   */
+  async rollbackTo(targetVersion) {
+    try {
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const completed = history.filter((h) => h.status === "COMPLETED" && h.version > targetVersion).sort((a, b) => b.version - a.version);
+      const migrationsResult = await this.getMigrations();
+      if (migrationsResult.isErr()) {
+        return Result.err(migrationsResult.variant.error);
+      }
+      const allMigrations = migrationsResult.unwrap();
+      const rolledBack = [];
+      for (const historyEntry of completed) {
+        const migration = allMigrations.find((m) => m.id === historyEntry.id);
+        if (!migration) {
+          return Result.err({
+            type: "MIGRATION_NOT_FOUND",
+            message: `Migration ${historyEntry.id} not found`,
+            migrationId: historyEntry.id
+          });
+        }
+        const result = await this.runMigration(migration, "DOWN");
+        if (result.isErr()) {
+          return Result.err(result.variant.error);
+        }
+        rolledBack.push(result.unwrap());
+      }
+      this.logger.info("Rolled back to version", { version: targetVersion });
+      return Result.ok(rolledBack);
+    } catch (error) {
+      this.logger.error("Rollback to version failed", { error, targetVersion });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Rollback to version ${targetVersion} failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Reset database by rolling back all migrations
+   */
+  async reset() {
+    return this.rollbackTo(0);
+  }
+  /**
+   * Refresh database by resetting and re-running all migrations
+   */
+  async refresh() {
+    try {
+      const resetResult = await this.reset();
+      if (resetResult.isErr()) {
+        return Result.err(resetResult.variant.error);
+      }
+      const rolledBack = resetResult.unwrap();
+      const migrateResult = await this.migrate();
+      if (migrateResult.isErr()) {
+        return Result.err(migrateResult.variant.error);
+      }
+      const applied = migrateResult.unwrap();
+      this.logger.info("Database refreshed", {
+        rolledBack: rolledBack.length,
+        applied: applied.length
+      });
+      return Result.ok({ rolledBack, applied });
+    } catch (error) {
+      this.logger.error("Refresh failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Refresh failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get current migration version
+   */
+  async getCurrentVersion() {
+    try {
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const completed = history.filter((h) => h.status === "COMPLETED");
+      if (completed.length === 0) {
+        return Result.ok(0);
+      }
+      const maxVersion = Math.max(...completed.map((h) => h.version));
+      return Result.ok(maxVersion);
+    } catch (error) {
+      this.logger.error("Failed to get current version", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get current version: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Validate migration checksums
+   */
+  async validateChecksums() {
+    try {
+      const migrationsResult = await this.getMigrations();
+      if (migrationsResult.isErr()) {
+        return Result.err(migrationsResult.variant.error);
+      }
+      const migrations = migrationsResult.unwrap();
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const completedMigrations = history.filter((h) => h.status === "COMPLETED");
+      for (const historyEntry of completedMigrations) {
+        const migration = migrations.find((m) => m.id === historyEntry.id);
+        if (!migration) {
+          continue;
+        }
+        if (migration.checksum && historyEntry.checksum) {
+          if (migration.checksum !== historyEntry.checksum) {
+            return Result.err({
+              type: "CHECKSUM_MISMATCH",
+              message: `Checksum mismatch for migration ${migration.id}`,
+              migrationId: migration.id
+            });
+          }
+        }
+      }
+      return Result.ok(true);
+    } catch (error) {
+      this.logger.error("Checksum validation failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Checksum validation failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Load migration from file
+   */
+  async loadMigration(filePath) {
+    if (this.loader.loadMigrationFile) {
+      return this.loader.loadMigrationFile(filePath);
+    }
+    return Result.err({
+      type: "UNKNOWN",
+      message: "Migration loader does not support loading individual files"
+    });
+  }
+  /**
+   * Run a single migration in a transaction
+   */
+  async runMigration(migration, direction) {
+    const startTime = Date.now();
+    const isUp = direction === "UP";
+    const fn = isUp ? migration.up : migration.down;
+    try {
+      await this.updateMigrationStatus(
+        migration,
+        isUp ? "RUNNING" : "RUNNING",
+        void 0,
+        void 0
+      );
+      const runFn = async (conn) => {
+        const context = {
+          execute: async (sql, params) => {
+            const result2 = await conn.execute(sql, params);
+            if (result2.isErr()) {
+              return Result.err({
+                type: "MIGRATION_FAILED",
+                message: `Migration execution failed: ${result2.variant.error}`,
+                migrationId: migration.id,
+                cause: result2.variant.error
+              });
+            }
+            return Result.ok(result2.unwrap());
+          },
+          log: (message) => {
+            this.logger.info(message, { migrationId: migration.id });
+          },
+          metadata: {
+            id: migration.id,
+            version: migration.version,
+            name: migration.name,
+            status: "RUNNING"
+          }
+        };
+        return await fn(context);
+      };
+      let result;
+      if (this.config.transactional) {
+        result = await this.connection.transaction(runFn);
+      } else {
+        result = await runFn(this.connection);
+      }
+      const executionTime = Date.now() - startTime;
+      if (result.isErr()) {
+        await this.updateMigrationStatus(
+          migration,
+          "FAILED",
+          executionTime,
+          result.variant.error.message
+        );
+        return Result.err(result.variant.error);
+      }
+      const finalStatus = isUp ? "COMPLETED" : "ROLLED_BACK";
+      await this.updateMigrationStatus(migration, finalStatus, executionTime, void 0);
+      const metadata = {
+        id: migration.id,
+        version: migration.version,
+        name: migration.name,
+        status: finalStatus,
+        executedAt: /* @__PURE__ */ new Date(),
+        executionTime,
+        checksum: migration.checksum
+      };
+      this.logger.info("Migration executed", {
+        id: migration.id,
+        direction,
+        executionTime
+      });
+      return Result.ok(metadata);
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      await this.updateMigrationStatus(
+        migration,
+        "FAILED",
+        executionTime,
+        String(error)
+      );
+      this.logger.error("Migration execution failed", { error, migration: migration.id });
+      return Result.err({
+        type: isUp ? "MIGRATION_FAILED" : "ROLLBACK_FAILED",
+        message: `Migration ${migration.id} failed: ${error}`,
+        migrationId: migration.id,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Update migration status in database
+   */
+  async updateMigrationStatus(migration, status, executionTime, error) {
+    try {
+      const tableName = this.config.migrationTable;
+      if (status === "RUNNING") {
+        const insertSQL = `
+          INSERT OR REPLACE INTO ${tableName} (id, version, name, checksum, status, executed_at, execution_time, error)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `;
+        await this.connection.execute(insertSQL, [
+          {
+            id: migration.id,
+            version: migration.version,
+            name: migration.name,
+            checksum: migration.checksum || null,
+            status,
+            executed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            execution_time: null,
+            error: null
+          }
+        ]);
+      } else {
+        const updateSQL = `
+          UPDATE ${tableName}
+          SET status = ?, execution_time = ?, error = ?, executed_at = ?
+          WHERE id = ?
+        `;
+        await this.connection.execute(updateSQL, [
+          {
+            status,
+            execution_time: executionTime || null,
+            error: error || null,
+            executed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            id: migration.id
+          }
+        ]);
+      }
+    } catch (err) {
+      this.logger.error("Failed to update migration status", {
+        error: err,
+        migration: migration.id
+      });
+    }
+  }
+};
+var DataSeeder = class {
+  connection;
+  config;
+  logger;
+  seedsCache = null;
+  constructor(connection, config, logger) {
+    this.connection = connection;
+    this.config = config;
+    this.logger = logger;
+  }
+  /**
+   * Create seed table if it doesn't exist
+   */
+  async createSeedTable() {
+    try {
+      const schema = this.getSeedTableSchema();
+      const result = await this.connection.execute(schema);
+      if (result.isErr()) {
+        return Result.err({
+          type: "UNKNOWN",
+          message: "Failed to create seed table",
+          cause: result.variant.error
+        });
+      }
+      this.logger.debug("Seed table created");
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Failed to create seed table", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to create seed table: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get all available seeds
+   */
+  async getSeeds() {
+    return this.loadSeedsFromDirectory();
+  }
+  /**
+   * Get seed history from database
+   */
+  async getHistory() {
+    try {
+      const query = `SELECT * FROM ${this.config.seedTable} ORDER BY executed_at DESC`;
+      const result = await this.connection.query(query);
+      if (result.isErr()) {
+        return Result.err({
+          type: "UNKNOWN",
+          message: "Failed to get seed history",
+          cause: result.variant.error
+        });
+      }
+      const rows = result.unwrap();
+      const history = rows.map((row) => ({
+        id: row.id,
+        name: row.name,
+        environment: JSON.parse(row.environment || "[]"),
+        status: row.status,
+        executedAt: row.executed_at ? new Date(row.executed_at) : void 0,
+        executionTime: row.execution_time,
+        error: row.error,
+        checksum: row.checksum
+      }));
+      return Result.ok(history);
+    } catch (error) {
+      this.logger.error("Failed to get seed history", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get seed history: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get pending seeds for current environment
+   */
+  async getPending() {
+    try {
+      const seedsResult = await this.getSeeds();
+      if (seedsResult.isErr()) {
+        return seedsResult;
+      }
+      const allSeeds = seedsResult.unwrap();
+      const environmentSeeds = allSeeds.filter(
+        (seed) => this.matchesEnvironment(seed.environment)
+      );
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const executedIds = new Set(
+        history.filter((h) => h.status === "COMPLETED").map((h) => h.id)
+      );
+      const pending = environmentSeeds.filter((s) => !executedIds.has(s.id));
+      return Result.ok(pending);
+    } catch (error) {
+      this.logger.error("Failed to get pending seeds", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to get pending seeds: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Run all pending seeds for current environment
+   */
+  async seed() {
+    try {
+      if (this.config.validateChecksums) {
+        const validationResult = await this.validateChecksums();
+        if (validationResult.isErr()) {
+          return Result.err(validationResult.variant.error);
+        }
+      }
+      const pendingResult = await this.getPending();
+      if (pendingResult.isErr()) {
+        return Result.err(pendingResult.variant.error);
+      }
+      const pending = pendingResult.unwrap();
+      const executed = [];
+      for (const seed of pending) {
+        const result = await this.executeSeed(seed);
+        if (result.isErr()) {
+          return Result.err(result.variant.error);
+        }
+        executed.push(result.unwrap());
+      }
+      this.logger.info("Seeds completed", { count: executed.length });
+      return Result.ok(executed);
+    } catch (error) {
+      this.logger.error("Seeding failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Seeding failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Run a specific seed by ID
+   */
+  async runSeed(seedId) {
+    try {
+      const seedsResult = await this.getSeeds();
+      if (seedsResult.isErr()) {
+        return Result.err(seedsResult.variant.error);
+      }
+      const allSeeds = seedsResult.unwrap();
+      const seed = allSeeds.find((s) => s.id === seedId);
+      if (!seed) {
+        return Result.err({
+          type: "SEED_NOT_FOUND",
+          message: `Seed ${seedId} not found`,
+          seedId
+        });
+      }
+      return this.executeSeed(seed);
+    } catch (error) {
+      this.logger.error("Run seed failed", { error, seedId });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Run seed ${seedId} failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Reset all seeds (clear history)
+   */
+  async reset() {
+    try {
+      const sql = `DELETE FROM ${this.config.seedTable}`;
+      const result = await this.connection.execute(sql);
+      if (result.isErr()) {
+        return Result.err({
+          type: "UNKNOWN",
+          message: "Failed to reset seeds",
+          cause: result.variant.error
+        });
+      }
+      this.logger.info("All seeds reset");
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Failed to reset seeds", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to reset seeds: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Validate seed checksums
+   */
+  async validateChecksums() {
+    try {
+      const seedsResult = await this.getSeeds();
+      if (seedsResult.isErr()) {
+        return Result.err(seedsResult.variant.error);
+      }
+      const seeds = seedsResult.unwrap();
+      const historyResult = await this.getHistory();
+      if (historyResult.isErr()) {
+        return Result.err(historyResult.variant.error);
+      }
+      const history = historyResult.unwrap();
+      const completedSeeds = history.filter((h) => h.status === "COMPLETED");
+      for (const historyEntry of completedSeeds) {
+        const seed = seeds.find((s) => s.id === historyEntry.id);
+        if (!seed) {
+          continue;
+        }
+        if (seed.checksum && historyEntry.checksum) {
+          if (seed.checksum !== historyEntry.checksum) {
+            return Result.err({
+              type: "CHECKSUM_MISMATCH",
+              message: `Checksum mismatch for seed ${seed.id}`,
+              seedId: seed.id
+            });
+          }
+        }
+      }
+      return Result.ok(true);
+    } catch (error) {
+      this.logger.error("Checksum validation failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Checksum validation failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Load seed from file
+   */
+  async loadSeed(filePath) {
+    return this.loadSeedFile(filePath);
+  }
+  /**
+   * Load seeds from directory
+   */
+  async loadSeedsFromDirectory() {
+    if (this.seedsCache) {
+      return Result.ok(this.seedsCache);
+    }
+    try {
+      if (!fs.existsSync(this.config.seedsPath)) {
+        return Result.err({
+          type: "INVALID_SEED",
+          message: `Seeds directory does not exist: ${this.config.seedsPath}`
+        });
+      }
+      const files = fs.readdirSync(this.config.seedsPath);
+      const filePattern = this.config.filePattern || /^[0-9]+[_-].*\.ts$/;
+      const seedFiles = files.filter((file) => filePattern.test(file));
+      this.logger.debug("Found seed files", {
+        total: files.length,
+        seeds: seedFiles.length
+      });
+      const seeds = [];
+      for (const file of seedFiles) {
+        const filePath = path.join(this.config.seedsPath, file);
+        const result = await this.loadSeedFile(filePath);
+        if (result.isErr()) {
+          return result;
+        }
+        seeds.push(result.unwrap());
+      }
+      seeds.sort((a, b) => a.id.localeCompare(b.id));
+      this.seedsCache = seeds;
+      this.logger.debug("Loaded seeds", { count: seeds.length });
+      return Result.ok(seeds);
+    } catch (error) {
+      this.logger.error("Failed to load seeds", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to load seeds: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Load a single seed file
+   */
+  async loadSeedFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const fileUrl = `file://${filePath.replace(/\\/g, "/")}`;
+      const module = await import(fileUrl);
+      const validation = this.validateSeed(module, filePath);
+      if (validation.isErr()) {
+        return validation;
+      }
+      const { id, name, environment, run } = module;
+      const checksum = this.computeChecksum(content);
+      const seed = {
+        id,
+        name,
+        environment: Array.isArray(environment) ? environment : [environment],
+        run,
+        checksum
+      };
+      this.logger.debug("Loaded seed", { id, name, environment });
+      return Result.ok(seed);
+    } catch (error) {
+      this.logger.error("Failed to load seed file", { error, filePath });
+      return Result.err({
+        type: "INVALID_SEED",
+        message: `Failed to load seed file ${filePath}: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Validate seed module structure
+   */
+  validateSeed(module, filePath) {
+    if (!module.id) {
+      return Result.err({
+        type: "INVALID_SEED",
+        message: `Seed ${filePath} is missing 'id' export`
+      });
+    }
+    if (!module.name) {
+      return Result.err({
+        type: "INVALID_SEED",
+        message: `Seed ${filePath} is missing 'name' export`
+      });
+    }
+    if (!module.environment) {
+      return Result.err({
+        type: "INVALID_SEED",
+        message: `Seed ${filePath} is missing 'environment' export`
+      });
+    }
+    if (!module.run || typeof module.run !== "function") {
+      return Result.err({
+        type: "INVALID_SEED",
+        message: `Seed ${filePath} is missing 'run' function`
+      });
+    }
+    return Result.ok(void 0);
+  }
+  /**
+   * Check if seed matches current environment
+   */
+  matchesEnvironment(environments) {
+    if (environments.includes("all")) {
+      return true;
+    }
+    return environments.includes(this.config.environment);
+  }
+  /**
+   * Execute a single seed
+   */
+  async executeSeed(seed) {
+    const startTime = Date.now();
+    try {
+      await this.updateSeedStatus(seed, "RUNNING", void 0, void 0);
+      const runFn = async (conn) => {
+        const context = {
+          execute: async (sql, params) => {
+            const result2 = await conn.execute(sql, params);
+            if (result2.isErr()) {
+              return Result.err({
+                type: "SEED_FAILED",
+                message: `Seed execution failed: ${result2.variant.error}`,
+                seedId: seed.id,
+                cause: result2.variant.error
+              });
+            }
+            return Result.ok(result2.unwrap());
+          },
+          log: (message) => {
+            this.logger.info(message, { seedId: seed.id });
+          },
+          metadata: {
+            id: seed.id,
+            name: seed.name,
+            environment: seed.environment,
+            status: "RUNNING"
+          },
+          environment: this.config.environment
+        };
+        return await seed.run(context);
+      };
+      let result;
+      if (this.config.transactional) {
+        result = await this.connection.transaction(runFn);
+      } else {
+        result = await runFn(this.connection);
+      }
+      const executionTime = Date.now() - startTime;
+      if (result.isErr()) {
+        await this.updateSeedStatus(seed, "FAILED", executionTime, result.variant.error.message);
+        return Result.err(result.variant.error);
+      }
+      await this.updateSeedStatus(seed, "COMPLETED", executionTime, void 0);
+      const metadata = {
+        id: seed.id,
+        name: seed.name,
+        environment: seed.environment,
+        status: "COMPLETED",
+        executedAt: /* @__PURE__ */ new Date(),
+        executionTime,
+        checksum: seed.checksum
+      };
+      this.logger.info("Seed executed", {
+        id: seed.id,
+        executionTime
+      });
+      return Result.ok(metadata);
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      await this.updateSeedStatus(seed, "FAILED", executionTime, String(error));
+      this.logger.error("Seed execution failed", { error, seed: seed.id });
+      return Result.err({
+        type: "SEED_FAILED",
+        message: `Seed ${seed.id} failed: ${error}`,
+        seedId: seed.id,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Update seed status in database
+   */
+  async updateSeedStatus(seed, status, executionTime, error) {
+    try {
+      const tableName = this.config.seedTable;
+      if (status === "RUNNING") {
+        const insertSQL = `
+          INSERT OR REPLACE INTO ${tableName} (id, name, environment, checksum, status, executed_at, execution_time, error)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `;
+        await this.connection.execute(insertSQL, [
+          seed.id,
+          seed.name,
+          JSON.stringify(seed.environment),
+          seed.checksum || null,
+          status,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          null,
+          null
+        ]);
+      } else {
+        const updateSQL = `
+          UPDATE ${tableName}
+          SET status = ?, execution_time = ?, error = ?, executed_at = ?
+          WHERE id = ?
+        `;
+        await this.connection.execute(updateSQL, [
+          status,
+          executionTime || null,
+          error || null,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          seed.id
+        ]);
+      }
+    } catch (err) {
+      this.logger.error("Failed to update seed status", {
+        error: err,
+        seed: seed.id
+      });
+    }
+  }
+  /**
+   * Compute SHA-256 checksum of seed content
+   */
+  computeChecksum(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  /**
+   * Get SQL schema for seed tracking table
+   */
+  getSeedTableSchema() {
+    const tableName = this.config.seedTable;
+    return `
+CREATE TABLE IF NOT EXISTS ${tableName} (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  environment TEXT NOT NULL,
+  checksum TEXT,
+  status TEXT NOT NULL DEFAULT 'PENDING',
+  executed_at TIMESTAMP,
+  execution_time INTEGER,
+  error TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_${tableName}_status ON ${tableName}(status);
+CREATE INDEX IF NOT EXISTS idx_${tableName}_environment ON ${tableName}(environment);
+    `.trim();
+  }
+};
+var D1DatabaseAdapter = class {
+  config;
+  logger;
+  db;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.db = config.database;
+  }
+  /**
+   * Execute a SQL query and return all results
+   */
+  async query(sql, params) {
+    try {
+      if (this.config.enableQueryLogging) {
+        this.logger.debug("Executing D1 query", { sql, params });
+      }
+      const stmt = this.prepareStatement(sql, params);
+      const result = await stmt.all();
+      if (!result.success) {
+        return Result.err({
+          type: "QUERY_FAILED",
+          message: result.error || "Query failed",
+          sql
+        });
+      }
+      return Result.ok(result.results || []);
+    } catch (error) {
+      this.logger.error("D1 query failed", { error, sql });
+      return Result.err({
+        type: "QUERY_FAILED",
+        message: `Query failed: ${error}`,
+        sql,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Execute a SQL query and return first result
+   */
+  async queryFirst(sql, params) {
+    try {
+      if (this.config.enableQueryLogging) {
+        this.logger.debug("Executing D1 queryFirst", { sql, params });
+      }
+      const stmt = this.prepareStatement(sql, params);
+      const result = await stmt.first();
+      return Result.ok(result);
+    } catch (error) {
+      this.logger.error("D1 queryFirst failed", { error, sql });
+      return Result.err({
+        type: "QUERY_FAILED",
+        message: `QueryFirst failed: ${error}`,
+        sql,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Execute a SQL statement (INSERT, UPDATE, DELETE)
+   */
+  async execute(sql, params) {
+    try {
+      if (this.config.enableQueryLogging) {
+        this.logger.debug("Executing D1 statement", { sql, params });
+      }
+      const stmt = this.prepareStatement(sql, params);
+      const result = await stmt.run();
+      if (!result.success) {
+        return Result.err({
+          type: "QUERY_FAILED",
+          message: result.error || "Execution failed",
+          sql
+        });
+      }
+      return Result.ok(result);
+    } catch (error) {
+      this.logger.error("D1 execute failed", { error, sql });
+      return Result.err({
+        type: "QUERY_FAILED",
+        message: `Execute failed: ${error}`,
+        sql,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Execute multiple SQL statements in a batch
+   */
+  async batch(statements) {
+    try {
+      const maxBatchSize = this.config.maxBatchSize || 100;
+      if (statements.length > maxBatchSize) {
+        return Result.err({
+          type: "BATCH_FAILED",
+          message: `Batch size ${statements.length} exceeds maximum ${maxBatchSize}`
+        });
+      }
+      if (statements.length === 0) {
+        return Result.ok([]);
+      }
+      if (this.config.enableQueryLogging) {
+        this.logger.debug("Executing D1 batch", {
+          count: statements.length
+        });
+      }
+      const preparedStatements = statements.map(
+        ({ sql, params }) => this.prepareStatement(sql, params)
+      );
+      const results = await this.db.batch(preparedStatements);
+      return Result.ok(results);
+    } catch (error) {
+      this.logger.error("D1 batch failed", { error, count: statements.length });
+      return Result.err({
+        type: "BATCH_FAILED",
+        message: `Batch execution failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Execute raw SQL (for migrations and schema changes)
+   */
+  async exec(sql) {
+    try {
+      if (this.config.enableQueryLogging) {
+        this.logger.debug("Executing D1 raw SQL", { sql });
+      }
+      const result = await this.db.exec(sql);
+      return Result.ok(result);
+    } catch (error) {
+      this.logger.error("D1 exec failed", { error, sql });
+      return Result.err({
+        type: "EXEC_FAILED",
+        message: `Exec failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Begin a transaction
+   *
+   * Note: D1 doesn't support explicit transactions yet, so this wraps
+   * the callback execution and provides the same interface for compatibility.
+   * Consider using batch() for atomic multi-statement operations.
+   */
+  async transaction(callback) {
+    try {
+      this.logger.debug("Starting D1 transaction (logical)");
+      const result = await callback(this);
+      return result;
+    } catch (error) {
+      this.logger.error("D1 transaction failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Transaction failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Prepare a SQL statement with parameters
+   */
+  prepareStatement(sql, params) {
+    const stmt = this.db.prepare(sql);
+    if (params && params.length > 0) {
+      return stmt.bind(...params);
+    }
+    return stmt;
+  }
+};
+var DurableObjectStorageAdapter = class _DurableObjectStorageAdapter {
+  config;
+  storage;
+  logger;
+  constructor(storage, config, logger) {
+    this.storage = storage;
+    this.config = config;
+    this.logger = logger;
+  }
+  /**
+   * Get a single value by key
+   */
+  async get(key) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", { operation: "get", key });
+      }
+      const value = await this.storage.get(key);
+      return Result.ok(value === void 0 ? null : value);
+    } catch (error) {
+      this.logger.error("DO Storage get failed", { error, key });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to get value for key "${key}": ${error}`,
+        key,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Get multiple values by keys
+   */
+  async getMultiple(keys) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", {
+          operation: "getMultiple",
+          keyCount: keys.length
+        });
+      }
+      const result = await this.storage.get(keys);
+      const typedResult = result;
+      return Result.ok(typedResult);
+    } catch (error) {
+      this.logger.error("DO Storage getMultiple failed", { error, keyCount: keys.length });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to get multiple values: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Put a single key-value pair
+   */
+  async put(key, value) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", { operation: "put", key });
+      }
+      await this.storage.put(key, value);
+      return Result.ok(void 0);
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes("DataCloneError") || error.message.includes("could not be cloned"))) {
+        this.logger.error("DO Storage serialization failed", { error, key });
+        return Result.err({
+          type: "SERIALIZATION_ERROR",
+          message: `Failed to serialize value for key "${key}": ${error.message}`,
+          cause: error
+        });
+      }
+      if (error instanceof Error && (error.message.includes("QuotaExceededError") || error.message.includes("storage quota exceeded"))) {
+        this.logger.error("DO Storage quota exceeded", { error, key });
+        return Result.err({
+          type: "QUOTA_EXCEEDED",
+          message: `Storage quota exceeded when setting key "${key}"`
+        });
+      }
+      this.logger.error("DO Storage put failed", { error, key });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to put value for key "${key}": ${error}`,
+        key,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Put multiple key-value pairs
+   */
+  async putMultiple(entries) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", {
+          operation: "putMultiple",
+          entryCount: entries.length
+        });
+      }
+      const entriesObj = {};
+      for (const [key, value] of entries) {
+        entriesObj[key] = value;
+      }
+      await this.storage.put(entriesObj);
+      return Result.ok(void 0);
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes("DataCloneError") || error.message.includes("could not be cloned"))) {
+        this.logger.error("DO Storage serialization failed", { error });
+        return Result.err({
+          type: "SERIALIZATION_ERROR",
+          message: `Failed to serialize values: ${error.message}`,
+          cause: error
+        });
+      }
+      if (error instanceof Error && (error.message.includes("QuotaExceededError") || error.message.includes("storage quota exceeded"))) {
+        this.logger.error("DO Storage quota exceeded", { error });
+        return Result.err({
+          type: "QUOTA_EXCEEDED",
+          message: "Storage quota exceeded when setting multiple values"
+        });
+      }
+      this.logger.error("DO Storage putMultiple failed", { error, entryCount: entries.length });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to put multiple values: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Delete a single key
+   */
+  async delete(key) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", { operation: "delete", key });
+      }
+      const result = await this.storage.delete(key);
+      return Result.ok(result);
+    } catch (error) {
+      this.logger.error("DO Storage delete failed", { error, key });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to delete key "${key}": ${error}`,
+        key,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Delete multiple keys
+   */
+  async deleteMultiple(keys) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", {
+          operation: "deleteMultiple",
+          keyCount: keys.length
+        });
+      }
+      const result = await this.storage.delete(keys);
+      return Result.ok(result);
+    } catch (error) {
+      this.logger.error("DO Storage deleteMultiple failed", { error, keyCount: keys.length });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to delete multiple keys: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Delete all keys in storage
+   */
+  async deleteAll() {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", { operation: "deleteAll" });
+      }
+      await this.storage.deleteAll();
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("DO Storage deleteAll failed", { error });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to delete all keys: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * List keys in storage
+   */
+  async list(options) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", { operation: "list", options });
+      }
+      const result = await this.storage.list(options);
+      return Result.ok(result);
+    } catch (error) {
+      this.logger.error("DO Storage list failed", { error, options });
+      return Result.err({
+        type: "STORAGE_FAILED",
+        message: `Failed to list keys: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Execute operations in a transaction
+   */
+  async transaction(callback) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("DO Storage operation", { operation: "transaction" });
+      }
+      const result = await this.storage.transaction(async (txnStorage) => {
+        const txnAdapter = new _DurableObjectStorageAdapter(
+          txnStorage,
+          this.config,
+          this.logger
+        );
+        return await callback(txnAdapter);
+      });
+      return result;
+    } catch (error) {
+      this.logger.error("DO Storage transaction failed", { error });
+      return Result.err({
+        type: "TRANSACTION_FAILED",
+        message: `Transaction failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+};
+var R2BackupAdapter = class {
+  config;
+  bucket;
+  logger;
+  constructor(config, logger) {
+    this.config = config;
+    this.bucket = config.bucket;
+    this.logger = logger;
+  }
+  /**
+   * Create a backup with compression
+   */
+  async backup(data, options) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("R2 Backup operation", { operation: "backup" });
+      }
+      const buffer = data instanceof ArrayBuffer ? Buffer.from(data) : data;
+      if (!buffer || buffer.length === 0) {
+        return Result.err({
+          type: "COMPRESSION_FAILED",
+          message: "Cannot backup empty or invalid data"
+        });
+      }
+      const compressionLevel = options?.compressionLevel ?? this.config.defaultCompressionLevel ?? 6;
+      let compressedData;
+      try {
+        compressedData = gzipSync(buffer, { level: compressionLevel });
+      } catch (error) {
+        this.logger.error("Compression failed", { error });
+        return Result.err({
+          type: "COMPRESSION_FAILED",
+          message: `Failed to compress data: ${error}`,
+          cause: error
+        });
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const key = `${this.config.name}-backup-${timestamp}.gz`;
+      const customMetadata = {
+        originalSize: buffer.length.toString(),
+        compressionRatio: (compressedData.length / buffer.length).toString(),
+        compressionLevel: compressionLevel.toString(),
+        backupDate: (/* @__PURE__ */ new Date()).toISOString(),
+        ...options?.metadata || {}
+      };
+      try {
+        const r2Object = await this.bucket.put(key, compressedData, {
+          httpMetadata: {
+            contentType: "application/gzip",
+            contentEncoding: "gzip",
+            contentDisposition: `attachment; filename="${key}"`
+          },
+          customMetadata,
+          storageClass: options?.storageClass || "Standard"
+        });
+        const backupInfo = {
+          key: r2Object.key,
+          size: buffer.length,
+          compressedSize: r2Object.size,
+          compressionRatio: r2Object.size / buffer.length,
+          uploadedAt: r2Object.uploaded,
+          etag: r2Object.etag,
+          metadata: {
+            databaseVersion: customMetadata.databaseVersion,
+            backupType: customMetadata.backupType,
+            originalChecksum: customMetadata.originalChecksum
+          }
+        };
+        if (this.config.enableLogging) {
+          this.logger.debug("Backup completed", {
+            key: backupInfo.key,
+            originalSize: backupInfo.size,
+            compressedSize: backupInfo.compressedSize,
+            compressionRatio: backupInfo.compressionRatio
+          });
+        }
+        return Result.ok(backupInfo);
+      } catch (error) {
+        this.logger.error("R2 upload failed", { error, key });
+        return Result.err({
+          type: "UPLOAD_FAILED",
+          message: `Failed to upload backup: ${error}`,
+          key,
+          cause: error
+        });
+      }
+    } catch (error) {
+      this.logger.error("Backup operation failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Backup failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Restore from a backup with decompression
+   */
+  async restore(key, options) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("R2 Backup operation", { operation: "restore", key });
+      }
+      let r2Object;
+      try {
+        r2Object = await this.bucket.get(key);
+      } catch (error) {
+        this.logger.error("R2 download failed", { error, key });
+        return Result.err({
+          type: "DOWNLOAD_FAILED",
+          message: `Failed to download backup: ${error}`,
+          key,
+          cause: error
+        });
+      }
+      if (!r2Object) {
+        return Result.err({
+          type: "BACKUP_NOT_FOUND",
+          message: `Backup not found: ${key}`,
+          key
+        });
+      }
+      const compressedData = await r2Object.arrayBuffer();
+      try {
+        const decompressed = gunzipSync(Buffer.from(compressedData));
+        if (this.config.enableLogging) {
+          this.logger.debug("Restore completed", {
+            key,
+            compressedSize: compressedData.byteLength,
+            originalSize: decompressed.length
+          });
+        }
+        return Result.ok(decompressed.buffer);
+      } catch (error) {
+        this.logger.error("Decompression failed", { error, key });
+        return Result.err({
+          type: "DECOMPRESSION_FAILED",
+          message: `Failed to decompress backup: ${error}`,
+          cause: error
+        });
+      }
+    } catch (error) {
+      this.logger.error("Restore operation failed", { error, key });
+      return Result.err({
+        type: "RESTORE_FAILED",
+        message: `Restore failed: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * List all backups
+   */
+  async listBackups(options) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("R2 Backup operation", { operation: "listBackups" });
+      }
+      const r2Objects = await this.bucket.list({
+        prefix: `${this.config.name}-backup`,
+        limit: options?.limit,
+        cursor: options?.cursor,
+        include: ["customMetadata"]
+      });
+      const backups = r2Objects.objects.map((obj) => {
+        const originalSize = parseInt(obj.customMetadata?.originalSize || "0", 10);
+        const compressionRatio = parseFloat(
+          obj.customMetadata?.compressionRatio || "1.0"
+        );
+        return {
+          key: obj.key,
+          size: originalSize,
+          compressedSize: obj.size,
+          compressionRatio,
+          uploadedAt: obj.uploaded,
+          etag: obj.etag,
+          metadata: {
+            databaseVersion: obj.customMetadata?.databaseVersion,
+            backupType: obj.customMetadata?.backupType,
+            originalChecksum: obj.customMetadata?.originalChecksum
+          }
+        };
+      });
+      return Result.ok(backups);
+    } catch (error) {
+      this.logger.error("List backups failed", { error });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to list backups: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Delete a single backup
+   */
+  async deleteBackup(key) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("R2 Backup operation", { operation: "deleteBackup", key });
+      }
+      await this.bucket.delete(key);
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Delete backup failed", { error, key });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to delete backup: ${error}`,
+        cause: error
+      });
+    }
+  }
+  /**
+   * Delete multiple backups (batched for efficiency)
+   */
+  async deleteMultipleBackups(keys) {
+    try {
+      if (this.config.enableLogging) {
+        this.logger.debug("R2 Backup operation", {
+          operation: "deleteMultipleBackups",
+          count: keys.length
+        });
+      }
+      const batchSize = 1e3;
+      const batches = [];
+      for (let i = 0; i < keys.length; i += batchSize) {
+        batches.push(keys.slice(i, i + batchSize));
+      }
+      for (const batch of batches) {
+        await this.bucket.delete(batch);
+      }
+      return Result.ok(void 0);
+    } catch (error) {
+      this.logger.error("Delete multiple backups failed", { error, count: keys.length });
+      return Result.err({
+        type: "UNKNOWN",
+        message: `Failed to delete backups: ${error}`,
+        cause: error
+      });
+    }
+  }
+};
+
+// src/index.ts
+var version = "1.0.0";
+
+export { CacheInvalidator, D1DatabaseAdapter, DataSeeder, DatabaseConnectionManager, DatabaseTransaction, DurableObjectStorageAdapter, KVCache, MemoryCache, MigrationLoader, MigrationRunner, R2BackupAdapter, RawSQLExecutor, TenantAwareQueryBuilder, TenantContextManager, TenantSchemaManager, TypeSafeQueryBuilder, version };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map