@plyaz/db 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -25,6 +25,26 @@ var sanitizeHtml = require('sanitize-html');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var sanitizeHtml__default = /*#__PURE__*/_interopDefault(sanitizeHtml);
 
 // @plyaz package - Built with tsup
@@ -294,15 +314,37 @@ function normalizeDetails(details) {
   }
 }
 __name(normalizeDetails, "normalizeDetails");
+var DEFAULT_FAILOVER_THRESHOLD = 3;
 var HealthManager = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
   static {
     __name(this, "HealthManager");
   }
   lastHealthStatus = null;
   initialized = false;
+  currentAdapter;
+  primaryAdapter;
+  backupAdapters;
+  consecutiveFailures = 0;
+  healthCheckInterval;
+  failoverThreshold;
+  autoFailover;
+  healthCheckTimer;
+  constructor(config) {
+    if ("primary" in config) {
+      this.primaryAdapter = config.primary;
+      this.currentAdapter = config.primary;
+      this.backupAdapters = config.backups ?? [];
+      this.healthCheckInterval = config.healthCheckInterval;
+      this.failoverThreshold = config.failoverThreshold ?? DEFAULT_FAILOVER_THRESHOLD;
+      this.autoFailover = config.autoFailover ?? false;
+    } else {
+      this.primaryAdapter = config;
+      this.currentAdapter = config;
+      this.backupAdapters = [];
+      this.failoverThreshold = DEFAULT_FAILOVER_THRESHOLD;
+      this.autoFailover = false;
+    }
+  }
   /**
    * Initializes the health manager by establishing database connection and performing initial health check
    *
@@ -333,11 +375,14 @@ var HealthManager = class {
    */
   async init() {
     if (this.initialized) return;
-    if (typeof this.adapter.connect === "function") {
-      await this.adapter.connect();
+    if (typeof this.currentAdapter.initialize === "function") {
+      await this.currentAdapter.initialize();
     }
     await this.checkHealth();
     this.initialized = true;
+    if (this.healthCheckInterval && this.healthCheckInterval > 0) {
+      this.startPeriodicHealthChecks();
+    }
   }
   /**
    * Performs a comprehensive health check on the database connection
@@ -396,16 +441,37 @@ var HealthManager = class {
    * ```
    *
    */
+  /**
+   * Handle health check result and update internal state
+   */
+  async handleHealthResult(isSuccess) {
+    if (isSuccess) {
+      this.consecutiveFailures = 0;
+      return;
+    }
+    this.consecutiveFailures++;
+    if (this.autoFailover && this.consecutiveFailures >= this.failoverThreshold) {
+      await this.performFailover();
+    }
+  }
+  /**
+   * Create health status from check result
+   */
+  createHealthStatus(result, responseTime) {
+    return {
+      isHealthy: result.success,
+      responseTime,
+      details: result.success ? normalizeDetails(result.value) : { error: result.error?.message ?? "Unknown error" }
+    };
+  }
   async checkHealth() {
     const startTime = Date.now();
     try {
-      const result = await this.adapter.healthCheck();
-      const status = {
-        isHealthy: result.success,
-        responseTime: Date.now() - startTime,
-        details: result.success ? normalizeDetails(result.value) : { error: result.error?.message ?? "Unknown error" }
-      };
+      const result = await this.currentAdapter.healthCheck();
+      const responseTime = Date.now() - startTime;
+      const status = this.createHealthStatus(result, responseTime);
       this.lastHealthStatus = status;
+      await this.handleHealthResult(result.success);
       return success(status);
     } catch (error) {
       const status = {
@@ -414,6 +480,7 @@ var HealthManager = class {
         details: { error: error.message }
       };
       this.lastHealthStatus = status;
+      await this.handleHealthResult(false);
       return failure(
         new errors.DatabaseError(
           `Health check failed: ${error.message}`,
@@ -438,13 +505,82 @@ var HealthManager = class {
   isHealthy() {
     return this.lastHealthStatus?.isHealthy ?? false;
   }
+  /**
+   * Get the current active adapter
+   */
+  getCurrentAdapter() {
+    return this.currentAdapter;
+  }
+  /**
+   * Try to initialize and verify health of a backup adapter
+   */
+  async tryBackupAdapter(backup) {
+    if (typeof backup.initialize === "function") {
+      const initResult = await backup.initialize();
+      if (!initResult.success) return false;
+    }
+    const healthResult = await backup.healthCheck();
+    return healthResult.success && (healthResult.value?.isHealthy ?? false);
+  }
+  /**
+   * Switch to a healthy backup adapter
+   */
+  async switchToBackup(backup) {
+    await this.currentAdapter.close();
+    this.currentAdapter = backup;
+    this.consecutiveFailures = 0;
+    console.log("[HealthManager] Failover successful to backup adapter");
+  }
+  /**
+   * Perform failover to next available backup adapter
+   */
+  async performFailover() {
+    if (this.backupAdapters.length === 0) {
+      console.warn("[HealthManager] No backup adapters available for failover");
+      return;
+    }
+    for (const backup of this.backupAdapters) {
+      try {
+        const isHealthy = await this.tryBackupAdapter(backup);
+        if (isHealthy) {
+          await this.switchToBackup(backup);
+          return;
+        }
+      } catch (error) {
+        console.error(
+          "[HealthManager] Backup adapter health check failed:",
+          error
+        );
+      }
+    }
+    console.error(
+      "[HealthManager] All backup adapters failed, staying with current adapter"
+    );
+  }
+  /**
+   * Start periodic health checks
+   */
+  startPeriodicHealthChecks() {
+    if (this.healthCheckTimer) return;
+    this.healthCheckTimer = setInterval(async () => {
+      await this.checkHealth();
+    }, this.healthCheckInterval);
+  }
+  /**
+   * Stop periodic health checks
+   */
+  stopPeriodicHealthChecks() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
+  }
   /**
    * Gracefully shut down the health manager
    */
   async shutdown() {
-    if (typeof this.adapter.disconnect === "function") {
-      await this.adapter.disconnect();
-    }
+    this.stopPeriodicHealthChecks();
+    await this.currentAdapter.close();
     this.initialized = false;
     this.lastHealthStatus = null;
   }
@@ -719,6 +855,52 @@ var DatabaseService = class {
     this.healthManager = new HealthManager(config.adapter);
     console.log(`DatabaseService initialized with ${adapterType} adapter`);
   }
+  /**
+   * 🔧 Prepare table name and configuration for operation
+   *
+   * Handles per-operation overrides for:
+   * 1. Schema - prepends schema to table name (e.g., "audit.logs")
+   * 2. ID Column - temporarily registers table with custom ID column
+   *
+   * Priority order:
+   * - Operation config (highest) - per-query override
+   * - TABLE_REGISTRY - global registration
+   * - Default (lowest) - 'id' column, 'public' schema
+   *
+   * @param table Base table name
+   * @param operationConfig Optional operation configuration with idColumn/schema
+   * @returns Final table name to use (with schema prefix if applicable)
+   *
+   * @example
+   * ```typescript
+   * // With schema override
+   * const tableName = this.prepareTable('logs', { schema: 'audit' });
+   * // Returns: 'audit.logs'
+   *
+   * // With ID column override
+   * const tableName = this.prepareTable('feature_flags', { idColumn: 'key' });
+   * // Registers table with 'key' as ID column, returns: 'feature_flags'
+   *
+   * // With both
+   * const tableName = this.prepareTable('users', { schema: 'backoffice', idColumn: 'user_id' });
+   * // Returns: 'backoffice.users' with 'user_id' as ID column
+   * ```
+   */
+  prepareTable(table, operationConfig) {
+    let finalTableName = table;
+    if (operationConfig?.schema) {
+      const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
+      finalTableName = `${operationConfig.schema}.${tableWithoutSchema}`;
+    }
+    if (operationConfig?.idColumn) {
+      this.adapter.registerTable(
+        finalTableName,
+        finalTableName,
+        operationConfig.idColumn
+      );
+    }
+    return finalTableName;
+  }
   /**
    * 🔍 Get a single record by ID
    *
@@ -749,10 +931,28 @@ var DatabaseService = class {
    *   forceAdapter: 'primary',  // Force primary DB
    *   cache: { enabled: false } // Skip cache
    * });
+   *
+   * // With custom ID column (per-query override)
+   * const flag = await this.db.get('feature_flags', 'my-flag-key', {
+   *   idColumn: 'key' // Use 'key' instead of 'id' as primary key
+   * });
+   *
+   * // With custom schema
+   * const auditLog = await this.db.get('logs', '123', {
+   *   schema: 'audit' // Query from audit.logs table
+   * });
+   *
+   * // Combining multiple overrides
+   * const backofficeUser = await this.db.get('users', 'admin-456', {
+   *   schema: 'backoffice',
+   *   idColumn: 'user_id',
+   *   forceAdapter: 'primary'
+   * });
    * ```
    */
   async get(table, id, operationConfig) {
     ConfigMerger.mergeConfigs(this.globalConfig, operationConfig);
+    const finalTable = this.prepareTable(table, operationConfig);
     try {
       if (this.eventHandlers?.onBeforeRead) {
         await this.eventHandlers.onBeforeRead({
@@ -762,7 +962,7 @@ var DatabaseService = class {
           timestamp: /* @__PURE__ */ new Date()
         });
       }
-      const result = await this.adapter.findById(table, id);
+      const result = await this.adapter.findById(finalTable, id);
       if (result.success && this.eventHandlers?.onAfterRead) {
         await this.eventHandlers.onAfterRead({
           type: "afterRead",
@@ -821,6 +1021,7 @@ var DatabaseService = class {
    */
   async create(table, input, operationConfig) {
     ConfigMerger.mergeConfigs(this.globalConfig, operationConfig);
+    const finalTable = this.prepareTable(table, operationConfig);
     if (this.eventHandlers?.onBeforeWrite) {
       await this.eventHandlers.onBeforeWrite({
         type: "beforeWrite",
@@ -830,7 +1031,7 @@ var DatabaseService = class {
         timestamp: /* @__PURE__ */ new Date()
       });
     }
-    const result = await this.adapter.create(table, input);
+    const result = await this.adapter.create(finalTable, input);
     if (result.success && this.eventHandlers?.onAfterWrite) {
       await this.eventHandlers.onAfterWrite({
         type: "afterWrite",
@@ -849,6 +1050,7 @@ var DatabaseService = class {
    */
   async update(table, id, input, operationConfig) {
     ConfigMerger.mergeConfigs(this.globalConfig, operationConfig);
+    const finalTable = this.prepareTable(table, operationConfig);
     if (this.eventHandlers?.onBeforeWrite) {
       await this.eventHandlers.onBeforeWrite({
         type: "beforeWrite",
@@ -858,7 +1060,11 @@ var DatabaseService = class {
         timestamp: /* @__PURE__ */ new Date()
       });
     }
-    const result = await this.adapter.update(table, id, input);
+    const result = await this.adapter.update(
+      finalTable,
+      id,
+      input
+    );
     if (result.success && this.eventHandlers?.onAfterWrite) {
       await this.eventHandlers.onAfterWrite({
         type: "afterWrite",
@@ -877,6 +1083,7 @@ var DatabaseService = class {
    */
   async delete(table, id, operationConfig) {
     ConfigMerger.mergeConfigs(this.globalConfig, operationConfig);
+    const finalTable = this.prepareTable(table, operationConfig);
     if (this.eventHandlers?.onBeforeWrite) {
       await this.eventHandlers.onBeforeWrite({
         type: "beforeWrite",
@@ -886,7 +1093,7 @@ var DatabaseService = class {
         timestamp: /* @__PURE__ */ new Date()
       });
     }
-    const result = await this.adapter.delete(table, id);
+    const result = await this.adapter.delete(finalTable, id);
     if (result.success && this.eventHandlers?.onAfterWrite) {
       await this.eventHandlers.onAfterWrite({
         type: "afterWrite",
@@ -1013,7 +1220,29 @@ var DatabaseService = class {
   async initialize() {
     return success();
   }
-  registerTable() {
+  /**
+   * Registers a table with the underlying adapter.
+   *
+   * @param name - Logical table name (e.g., 'users')
+   * @param table - Physical table name or Drizzle table object
+   * @param idColumn - ID column name (defaults to 'id')
+   *
+   * @example SQL Adapter
+   * ```typescript
+   * db.registerTable('users', 'users', 'id');
+   * db.registerTable('feature_flags', 'feature_flags', 'key');
+   * ```
+   *
+   * @example Drizzle Adapter (requires PgTable objects)
+   * ```typescript
+   * db.registerTable('users', usersTable, usersTable.id);
+   * ```
+   */
+  registerTable(name, table, idColumn) {
+    if (this.adapter && typeof this.adapter.registerTable === "function") {
+      const tableValue = table ?? name;
+      this.adapter.registerTable(name, tableValue, idColumn);
+    }
   }
   async exists(table, id) {
     const result = await this.get(table, id);
@@ -1111,6 +1340,33 @@ var DatabaseService = class {
   get events() {
     return this.eventEmitter;
   }
+  /**
+   * 🔌 Close the database connection
+   *
+   * Gracefully shuts down the database connection and releases all resources.
+   * Should be called when the service is no longer needed.
+   *
+   * @returns Promise resolving to DatabaseResult indicating success or failure
+   */
+  async close() {
+    try {
+      if (this.adapter.close) {
+        return await this.adapter.close();
+      }
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to close database connection: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.DISCONNECT_FAILED,
+          {
+            context: { source: "close" },
+            cause: error
+          }
+        )
+      );
+    }
+  }
 };
 function validatePaginationInputs(total, limit, offset) {
   if (!isNumber(total) || total < 0) {
@@ -1348,6 +1604,7 @@ var DB_REGEX = {
 };
 
 // src/adapters/drizzle/DrizzleAdapter.ts
+var BETWEEN_MIN_ELEMENTS = 2;
 var DrizzleAdapter = class {
   static {
     __name(this, "DrizzleAdapter");
@@ -1357,6 +1614,10 @@ var DrizzleAdapter = class {
   config;
   tableMap = /* @__PURE__ */ new Map();
   idColumnMap = /* @__PURE__ */ new Map();
+  // String-based table registry for auto-registration (fallback when no PgTable schema)
+  stringTableMap = /* @__PURE__ */ new Map();
+  stringIdColumnMap = /* @__PURE__ */ new Map();
+  configIdColumns;
   /**
    * Creates a new DrizzleAdapter instance.
    * @param {DrizzleAdapterConfig} config - Configuration object for Drizzle and PostgreSQL connection.
@@ -1372,6 +1633,7 @@ var DrizzleAdapter = class {
       ...config.pool
     });
     this.db = nodePostgres.drizzle(this.pool);
+    this.configIdColumns = config.tableIdColumns ?? {};
   }
   /**
    * Initializes the adapter by verifying database connectivity.
@@ -1456,6 +1718,23 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Closes the database connection and cleanup resources.
+   * @returns Promise resolving to DatabaseResult indicating success or failure.
+   */
+  async close() {
+    try {
+      await this.disconnect();
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to close connection: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.DISCONNECT_FAILED
+        )
+      );
+    }
+  }
   /**
    * Gets the underlying Drizzle client instance.
    * @returns {TClient} The internal Drizzle client.
@@ -1505,15 +1784,20 @@ var DrizzleAdapter = class {
   }
   /**
    * Registers a table and optional ID column for ORM operations.
-   * @template TTable - Type representing the table structure.
-   * @template TIdColumn - Type representing the ID column.
+   * @template TTable - Type representing the table structure (PgTable or string).
+   * @template TIdColumn - Type representing the ID column (PgColumn or string).
    * @param {string} name - Logical name of the table.
-   * @param {TTable} table - Drizzle table object.
-   * @param {TIdColumn} [idColumn] - Optional primary key column.
+   * @param {TTable} table - Drizzle table object (PgTable) or string table name.
+   * @param {TIdColumn} [idColumn] - Optional primary key column (PgColumn or string).
    * @description
    * Registers a table with the adapter, allowing it to be referenced by a logical name
    * in subsequent operations. This is necessary for the adapter to perform ORM operations
    * on the table. The ID column can also be specified if it differs from the default 'id'.
+   *
+   * **Supports two modes:**
+   * 1. **PgTable mode**: Pass Drizzle schema objects for type-safe ORM operations
+   * 2. **String mode**: Pass string table names for raw SQL fallback (auto-registration)
+   *
    * This registration enables the adapter to map logical table names to actual table objects
    * and ID columns, providing a layer of abstraction between the application and the database schema.
    */
@@ -1525,9 +1809,16 @@ var DrizzleAdapter = class {
           errors$1.DATABASE_ERROR_CODES.INVALID_TABLE_NAME
         );
       }
-      this.tableMap.set(name, table);
-      if (idColumn) {
-        this.idColumnMap.set(name, idColumn);
+      if (typeof table === "string") {
+        this.stringTableMap.set(name, table);
+        if (idColumn && typeof idColumn === "string") {
+          this.stringIdColumnMap.set(name, idColumn);
+        }
+      } else {
+        this.tableMap.set(name, table);
+        if (idColumn) {
+          this.idColumnMap.set(name, idColumn);
+        }
       }
     } catch (error) {
       throw new errors.DatabaseError(
@@ -1542,6 +1833,16 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Execute raw SQL findById query
+   */
+  async rawSqlFindById(table, id) {
+    const tableName = this.getStringTableName(table);
+    const idColumn = this.getStringIdColumn(table);
+    const sqlQuery = `SELECT * FROM "${tableName}" WHERE "${idColumn}" = $1 LIMIT 1`;
+    const result = await this.pool.query(sqlQuery, [id]);
+    return result.rows[0] || null;
+  }
   /**
    * Finds a record by its primary ID.
    * @template T - The expected type of the record.
@@ -1554,28 +1855,59 @@ var DrizzleAdapter = class {
    * If the record is found, it is returned in a success result. If no record is found,
    * null is returned in a success result. If an error occurs during the operation,
    * a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
    */
   async findById(table, id) {
     try {
+      if (this.isStringMode(table)) {
+        return success(await this.rawSqlFindById(table, id));
+      }
       const tableObj = this.getTable(table);
       const idColumn = this.getIdColumn(table);
       const result = await this.db.select().from(tableObj).where(drizzleOrm.eq(idColumn, id)).limit(1);
       return success(result[0] || null);
     } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        return this.handleStringModeFallback(
+          () => this.rawSqlFindById(table, id),
+          table,
+          "DrizzleAdapter.findById",
+          errors$1.DATABASE_ERROR_CODES.FIND_BY_ID_FAILED
+        );
+      }
       return failure(
         new errors.DatabaseError(
           `Failed to find by id in table ${table}: ${error.message}`,
           errors$1.DATABASE_ERROR_CODES.FIND_BY_ID_FAILED,
           {
-            context: {
-              source: "DrizzleAdapter.findById"
-            },
+            context: { source: "DrizzleAdapter.findById" },
             cause: error
           }
         )
       );
     }
   }
+  /**
+   * Handle USE_STRING_MODE fallback with error wrapping
+   */
+  async handleStringModeFallback(operation, table, source, errorCode) {
+    try {
+      return success(await operation());
+    } catch (sqlError) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed operation on table ${table}: ${sqlError.message}`,
+          errorCode,
+          {
+            context: { source },
+            cause: sqlError
+          }
+        )
+      );
+    }
+  }
   /**
    * Retrieves multiple records with optional filtering, sorting, and pagination.
    * @template T - The expected type of the records.
@@ -1589,10 +1921,16 @@ var DrizzleAdapter = class {
    * of records returned. The result includes the data array, total count of matching records,
    * and pagination metadata such as current page, total pages, and next/previous cursors.
    * If an error occurs during the operation, a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
    */
   // eslint-disable-next-line complexity
   async findMany(table, options) {
     try {
+      if (this.isStringMode(table)) {
+        return this.findManyRawSql(table, options);
+      }
       const tableObj = this.getTable(table);
       let query = this.db.select().from(tableObj);
       if (options?.sort) {
@@ -1627,6 +1965,9 @@ var DrizzleAdapter = class {
         pagination: calculatePagination(total, options?.pagination)
       });
     } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        return this.findManyRawSql(table, options);
+      }
       return failure(
         new errors.DatabaseError(
           `Failed to find many in table ${table}: ${error.message}`,
@@ -1641,6 +1982,126 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Raw SQL fallback for findMany when no PgTable schema is registered.
+   * @private
+   */
+  // eslint-disable-next-line complexity
+  async findManyRawSql(table, options) {
+    try {
+      const tableName = this.getStringTableName(table);
+      const params = [];
+      let whereClause = "";
+      let paramIndex = 1;
+      if (options?.filter) {
+        const { field, operator, value } = options.filter;
+        whereClause = this.buildSqlWhereClause({
+          field,
+          operator,
+          value,
+          params,
+          startIndex: paramIndex
+        });
+        paramIndex = params.length + 1;
+      }
+      const countSql = `SELECT COUNT(*) as total FROM "${tableName}"${whereClause}`;
+      const countResult = await this.pool.query(countSql, params);
+      const total = Number.parseInt(countResult.rows[0].total);
+      let orderClause = "";
+      if (options?.sort?.length) {
+        orderClause = " ORDER BY " + options.sort.map((s) => `"${s.field}" ${s.direction.toUpperCase()}`).join(", ");
+      }
+      const queryParams = [...params];
+      let limitClause = "";
+      if (options?.pagination?.limit) {
+        limitClause += ` LIMIT $${paramIndex++}`;
+        queryParams.push(options.pagination.limit);
+      }
+      if (options?.pagination?.offset) {
+        limitClause += ` OFFSET $${paramIndex++}`;
+        queryParams.push(options.pagination.offset);
+      }
+      const sqlQuery = `SELECT * FROM "${tableName}"${whereClause}${orderClause}${limitClause}`;
+      const result = await this.pool.query(sqlQuery, queryParams);
+      return success({
+        data: result.rows,
+        total,
+        pagination: calculatePagination(total, options?.pagination)
+      });
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to find many in table ${table}: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.FIND_MANY_FAILED,
+          {
+            context: {
+              source: "DrizzleAdapter.findManyRawSql"
+            },
+            cause: error
+          }
+        )
+      );
+    }
+  }
+  /**
+   * Builds a SQL WHERE clause string for raw SQL queries.
+   * @private
+   */
+  // eslint-disable-next-line complexity
+  buildSqlWhereClause(options) {
+    const { field, operator, value, params, startIndex } = options;
+    let clause = "";
+    switch (operator) {
+      case "eq":
+        clause = ` WHERE "${field}" = $${startIndex}`;
+        params.push(value);
+        break;
+      case "ne":
+        clause = ` WHERE "${field}" != $${startIndex}`;
+        params.push(value);
+        break;
+      case "gt":
+        clause = ` WHERE "${field}" > $${startIndex}`;
+        params.push(value);
+        break;
+      case "gte":
+        clause = ` WHERE "${field}" >= $${startIndex}`;
+        params.push(value);
+        break;
+      case "lt":
+        clause = ` WHERE "${field}" < $${startIndex}`;
+        params.push(value);
+        break;
+      case "lte":
+        clause = ` WHERE "${field}" <= $${startIndex}`;
+        params.push(value);
+        break;
+      case "in":
+        if (Array.isArray(value)) {
+          const placeholders = value.map((_, i) => `$${startIndex + i}`).join(", ");
+          clause = ` WHERE "${field}" IN (${placeholders})`;
+          params.push(...value);
+        }
+        break;
+      case "like":
+        clause = ` WHERE "${field}" LIKE $${startIndex}`;
+        params.push(value);
+        break;
+      case "between":
+        if (Array.isArray(value) && value.length >= BETWEEN_MIN_ELEMENTS) {
+          clause = ` WHERE "${field}" BETWEEN $${startIndex} AND $${startIndex + 1}`;
+          params.push(value[0], value[1]);
+        }
+        break;
+      case "isNull":
+        clause = ` WHERE "${field}" IS NULL`;
+        break;
+      case "isNotNull":
+        clause = ` WHERE "${field}" IS NOT NULL`;
+        break;
+    }
+    return clause;
+  }
   /**
    * Inserts a new record into the specified table.
    * @template T - The expected type of the record.
@@ -1653,13 +2114,22 @@ var DrizzleAdapter = class {
    * After insertion, it returns the inserted record with any auto-generated fields
    * (like IDs) populated. If an error occurs during the operation,
    * a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
    */
   async create(table, data) {
     try {
+      if (this.isStringMode(table)) {
+        return this.createRawSql(table, data);
+      }
       const tableObj = this.getTable(table);
       const result = await this.db.insert(tableObj).values(data).returning();
       return success(result[0]);
     } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        return this.createRawSql(table, data);
+      }
       return failure(
         new errors.DatabaseError(
           `Failed to create in table ${table}: ${error.message}`,
@@ -1675,29 +2145,67 @@ var DrizzleAdapter = class {
     }
   }
   /**
-   * Updates an existing record by ID.
-   * @template T - The expected type of the record.
-   * @param {string} table - Table name.
-   * @param {string} id - Record ID.
-   * @param {Partial<T>} data - Partial object containing fields to update.
-   * @returns {Promise<DatabaseResult<T>>} Updated record.
-   * @description
-   * Updates an existing record in the specified table using its primary ID.
-   * Only the fields provided in the data object are updated, allowing for partial updates.
-   * The method uses the registered table and ID column to construct the update query.
-   * After updating, it returns the updated record. If an error occurs during the operation,
-   * a failure result with an error message is returned.
+   * Raw SQL fallback for create when no PgTable schema is registered.
+   * @private
    */
-  async update(table, id, data) {
+  async createRawSql(table, data) {
     try {
-      const tableObj = this.getTable(table);
-      const idColumn = this.getIdColumn(table);
-      const result = await this.db.update(tableObj).set(data).where(drizzleOrm.eq(idColumn, id)).returning();
-      return success(result[0]);
-    } catch (error) {
-      return failure(
-        new errors.DatabaseError(
-          `Failed to update in table ${table}: ${error.message}`,
+      const tableName = this.getStringTableName(table);
+      const keys = Object.keys(data);
+      const values = Object.values(data);
+      const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+      const escapedKeys = keys.map((k) => `"${k}"`).join(", ");
+      const sqlQuery = `INSERT INTO "${tableName}" (${escapedKeys}) VALUES (${placeholders}) RETURNING *`;
+      const result = await this.pool.query(sqlQuery, values);
+      return success(result.rows[0]);
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to create in table ${table}: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.CREATE_FAILED,
+          {
+            context: {
+              source: "DrizzleAdapter.createRawSql"
+            },
+            cause: error
+          }
+        )
+      );
+    }
+  }
+  /**
+   * Updates an existing record by ID.
+   * @template T - The expected type of the record.
+   * @param {string} table - Table name.
+   * @param {string} id - Record ID.
+   * @param {Partial<T>} data - Partial object containing fields to update.
+   * @returns {Promise<DatabaseResult<T>>} Updated record.
+   * @description
+   * Updates an existing record in the specified table using its primary ID.
+   * Only the fields provided in the data object are updated, allowing for partial updates.
+   * The method uses the registered table and ID column to construct the update query.
+   * After updating, it returns the updated record. If an error occurs during the operation,
+   * a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
+   */
+  async update(table, id, data) {
+    try {
+      if (this.isStringMode(table)) {
+        return this.updateRawSql(table, id, data);
+      }
+      const tableObj = this.getTable(table);
+      const idColumn = this.getIdColumn(table);
+      const result = await this.db.update(tableObj).set(data).where(drizzleOrm.eq(idColumn, id)).returning();
+      return success(result[0]);
+    } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        return this.updateRawSql(table, id, data);
+      }
+      return failure(
+        new errors.DatabaseError(
+          `Failed to update in table ${table}: ${error.message}`,
           errors$1.DATABASE_ERROR_CODES.UPDATE_FAILED,
           {
             context: {
@@ -1709,6 +2217,35 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Raw SQL fallback for update when no PgTable schema is registered.
+   * @private
+   */
+  async updateRawSql(table, id, data) {
+    try {
+      const tableName = this.getStringTableName(table);
+      const idColumn = this.getStringIdColumn(table);
+      const keys = Object.keys(data);
+      const values = Object.values(data);
+      const setClause = keys.map((key, i) => `"${key}" = $${i + 1}`).join(", ");
+      const sqlQuery = `UPDATE "${tableName}" SET ${setClause} WHERE "${idColumn}" = $${keys.length + 1} RETURNING *`;
+      const result = await this.pool.query(sqlQuery, [...values, id]);
+      return success(result.rows[0]);
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to update in table ${table}: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.UPDATE_FAILED,
+          {
+            context: {
+              source: "DrizzleAdapter.updateRawSql"
+            },
+            cause: error
+          }
+        )
+      );
+    }
+  }
   /**
    * Deletes a record by ID.
    * @param {string} table - Table name.
@@ -1719,14 +2256,23 @@ var DrizzleAdapter = class {
    * The method uses the registered table and ID column to construct the delete query.
    * If the operation is successful, it returns a success result with no value.
    * If an error occurs during the operation, a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
    */
   async delete(table, id) {
     try {
+      if (this.isStringMode(table)) {
+        return this.deleteRawSql(table, id);
+      }
       const tableObj = this.getTable(table);
       const idColumn = this.getIdColumn(table);
       await this.db.delete(tableObj).where(drizzleOrm.eq(idColumn, id));
       return success();
     } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        return this.deleteRawSql(table, id);
+      }
       return failure(
         new errors.DatabaseError(
           `Failed to delete from table ${table}: ${error.message}`,
@@ -1741,6 +2287,32 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Raw SQL fallback for delete when no PgTable schema is registered.
+   * @private
+   */
+  async deleteRawSql(table, id) {
+    try {
+      const tableName = this.getStringTableName(table);
+      const idColumn = this.getStringIdColumn(table);
+      const sqlQuery = `DELETE FROM "${tableName}" WHERE "${idColumn}" = $1`;
+      await this.pool.query(sqlQuery, [id]);
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to delete from table ${table}: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.DELETE_FAILED,
+          {
+            context: {
+              source: "DrizzleAdapter.deleteRawSql"
+            },
+            cause: error
+          }
+        )
+      );
+    }
+  }
   /**
    * Executes a transactional operation with rollback on failure.
    * @template T - The expected type of the transaction result.
@@ -1753,6 +2325,8 @@ var DrizzleAdapter = class {
    * is rolled back, ensuring that no partial changes are applied to the database.
    * The method returns the result of the callback function if successful,
    * or a failure result with an error message if an error occurs.
+   *
+   * **Auto-registers tables**: Transaction operations use raw SQL mode for unregistered tables.
    */
   async transaction(callback) {
     const client = await this.pool.connect();
@@ -1761,23 +2335,57 @@ var DrizzleAdapter = class {
       const trxDb = nodePostgres.drizzle(client);
       const trx = {
         findById: /* @__PURE__ */ __name(async (table, id) => {
+          if (this.isStringMode(table)) {
+            const tableName = this.getStringTableName(table);
+            const idColumn2 = this.getStringIdColumn(table);
+            const sqlQuery = `SELECT * FROM "${tableName}" WHERE "${idColumn2}" = $1 LIMIT 1`;
+            const result3 = await client.query(sqlQuery, [id]);
+            return success(result3.rows[0] || null);
+          }
           const tableObj = this.getTable(table);
           const idColumn = this.getIdColumn(table);
           const result2 = await trxDb.select().from(tableObj).where(drizzleOrm.eq(idColumn, id)).limit(1);
           return success(result2[0] || null);
         }, "findById"),
         create: /* @__PURE__ */ __name(async (table, data) => {
+          if (this.isStringMode(table)) {
+            const tableName = this.getStringTableName(table);
+            const keys = Object.keys(data);
+            const values = Object.values(data);
+            const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+            const escapedKeys = keys.map((k) => `"${k}"`).join(", ");
+            const sqlQuery = `INSERT INTO "${tableName}" (${escapedKeys}) VALUES (${placeholders}) RETURNING *`;
+            const result3 = await client.query(sqlQuery, values);
+            return success(result3.rows[0]);
+          }
           const tableObj = this.getTable(table);
           const result2 = await trxDb.insert(tableObj).values(data).returning();
           return success(result2[0]);
         }, "create"),
         update: /* @__PURE__ */ __name(async (table, id, data) => {
+          if (this.isStringMode(table)) {
+            const tableName = this.getStringTableName(table);
+            const idColumn2 = this.getStringIdColumn(table);
+            const keys = Object.keys(data);
+            const values = Object.values(data);
+            const setClause = keys.map((key, i) => `"${key}" = $${i + 1}`).join(", ");
+            const sqlQuery = `UPDATE "${tableName}" SET ${setClause} WHERE "${idColumn2}" = $${keys.length + 1} RETURNING *`;
+            const result3 = await client.query(sqlQuery, [...values, id]);
+            return success(result3.rows[0]);
+          }
           const tableObj = this.getTable(table);
           const idColumn = this.getIdColumn(table);
           const result2 = await trxDb.update(tableObj).set(data).where(drizzleOrm.eq(idColumn, id)).returning();
           return success(result2[0]);
         }, "update"),
         delete: /* @__PURE__ */ __name(async (table, id) => {
+          if (this.isStringMode(table)) {
+            const tableName = this.getStringTableName(table);
+            const idColumn2 = this.getStringIdColumn(table);
+            const sqlQuery = `DELETE FROM "${tableName}" WHERE "${idColumn2}" = $1`;
+            await client.query(sqlQuery, [id]);
+            return success();
+          }
           const tableObj = this.getTable(table);
           const idColumn = this.getIdColumn(table);
           await trxDb.delete(tableObj).where(drizzleOrm.eq(idColumn, id));
@@ -1821,14 +2429,31 @@ var DrizzleAdapter = class {
    * The method uses the registered table and ID column to construct the query.
    * It returns a success result with a boolean value indicating whether the record exists.
    * If an error occurs during the operation, a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
    */
   async exists(table, id) {
     try {
+      if (this.isStringMode(table)) {
+        const tableName = this.getStringTableName(table);
+        const idColumn2 = this.getStringIdColumn(table);
+        const sqlQuery = `SELECT 1 FROM "${tableName}" WHERE "${idColumn2}" = $1 LIMIT 1`;
+        const result2 = await this.pool.query(sqlQuery, [id]);
+        return success(result2.rows.length > 0);
+      }
       const tableObj = this.getTable(table);
       const idColumn = this.getIdColumn(table);
       const result = await this.db.select({ exists: drizzleOrm.sql`1` }).from(tableObj).where(drizzleOrm.eq(idColumn, id)).limit(1);
       return success(!!result.length);
     } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        const tableName = this.getStringTableName(table);
+        const idColumn = this.getStringIdColumn(table);
+        const sqlQuery = `SELECT 1 FROM "${tableName}" WHERE "${idColumn}" = $1 LIMIT 1`;
+        const result = await this.pool.query(sqlQuery, [id]);
+        return success(result.rows.length > 0);
+      }
       return failure(
         new errors.DatabaseError(
           `Failed to check existence in table ${table}: ${error.message}`,
@@ -1854,9 +2479,15 @@ var DrizzleAdapter = class {
    * If a filter is provided, it is applied to narrow down the count to matching records.
    * It returns a success result with the count of matching records.
    * If an error occurs during the operation, a failure result with an error message is returned.
+   *
+   * **Auto-registers tables**: If table is not registered with PgTable schema,
+   * falls back to raw SQL mode (same behavior as SQLAdapter).
    */
   async count(table, filter) {
     try {
+      if (this.isStringMode(table)) {
+        return this.countRawSql(table, filter);
+      }
       const tableObj = this.getTable(table);
       const baseQuery = this.db.select({ count: drizzleOrm.sql`count(*)::int` }).from(tableObj);
       const query = filter && this.buildWhereClause(filter, tableObj) ? baseQuery.where(this.buildWhereClause(filter, tableObj)) : baseQuery;
@@ -1864,6 +2495,9 @@ var DrizzleAdapter = class {
       const countValue = result.length > 0 ? result[0].count : 0;
       return success(Number(countValue));
     } catch (error) {
+      if (error instanceof errors.DatabaseError && error.message === "USE_STRING_MODE") {
+        return this.countRawSql(table, filter);
+      }
       return failure(
         new errors.DatabaseError(
           `Failed to count in table ${table}: ${error.message}`,
@@ -1878,6 +2512,44 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Raw SQL fallback for count when no PgTable schema is registered.
+   * @private
+   */
+  async countRawSql(table, filter) {
+    try {
+      const tableName = this.getStringTableName(table);
+      const params = [];
+      let whereClause = "";
+      if (filter) {
+        const { field, operator, value } = filter;
+        whereClause = this.buildSqlWhereClause({
+          field,
+          operator,
+          value,
+          params,
+          startIndex: 1
+        });
+      }
+      const sqlQuery = `SELECT COUNT(*) as count FROM "${tableName}"${whereClause}`;
+      const result = await this.pool.query(sqlQuery, params);
+      const rowCount = Number.parseInt(result.rows[0].count);
+      return success(Number(rowCount));
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to count in table ${table}: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.COUNT_FAILED,
+          {
+            context: {
+              source: "DrizzleAdapter.countRawSql"
+            },
+            cause: error
+          }
+        )
+      );
+    }
+  }
   /**
    * Performs a health check on the database connection.
    * @returns {Promise<DatabaseResult<DatabaseHealthStatus>>} Health status with response time.
@@ -1911,16 +2583,25 @@ var DrizzleAdapter = class {
     }
   }
   // --- Private Helpers ---
+  /**
+   * Checks if a table is registered in string mode (raw SQL fallback).
+   * @private
+   * @param {string} name - Table name.
+   * @returns {boolean} True if table is registered in string mode.
+   */
+  isStringMode(name) {
+    return this.stringTableMap.has(name) || !this.tableMap.has(name);
+  }
   /**
    * Retrieves a registered table by name.
    * @private
    * @param {string} name - Table name.
    * @returns {PgTable} Table object.
-   * @throws {DatabaseError} If table is not registered.
+   * @throws {DatabaseError} If table is not registered and cannot be auto-registered.
    * @description
    * Retrieves a table object that has been previously registered with the adapter.
-   * This method is used internally by other methods to ensure that operations are performed
-   * on valid, registered tables. If the table is not found, it throws a DatabaseError.
+   * If the table is not found in PgTable mode, it auto-registers in string mode
+   * for raw SQL operations (same behavior as SQLAdapter).
    */
   getTable(name) {
     try {
@@ -1932,8 +2613,11 @@ var DrizzleAdapter = class {
       }
       const table = this.tableMap.get(name);
       if (!table) {
+        if (!this.stringTableMap.has(name)) {
+          this.stringTableMap.set(name, name);
+        }
         throw new errors.DatabaseError(
-          "Table is not registered with the adapter",
+          "USE_STRING_MODE",
           errors$1.DATABASE_ERROR_CODES.TABLE_NOT_REGISTERED
         );
       }
@@ -1945,6 +2629,46 @@ var DrizzleAdapter = class {
       );
     }
   }
+  /**
+   * Gets the string table name for raw SQL operations.
+   * @private
+   * @param {string} name - Logical table name.
+   * @returns {string} Physical table name.
+   */
+  getStringTableName(name) {
+    let tableName = this.stringTableMap.get(name);
+    if (!tableName) {
+      const customIdColumn = this.configIdColumns[name];
+      if (customIdColumn) {
+        this.stringIdColumnMap.set(name, customIdColumn);
+      }
+      this.stringTableMap.set(name, name);
+      tableName = name;
+    }
+    return tableName;
+  }
+  /**
+   * Gets the string ID column for raw SQL operations.
+   * @private
+   * @param {string} name - Logical table name.
+   * @returns {string} ID column name (defaults to 'id').
+   * @description
+   * Retrieves the ID column for a table. Checks in this order:
+   * 1. Runtime registered ID column (from registerTable calls)
+   * 2. Config-provided ID column (from tableIdColumns in config)
+   * 3. Default 'id' column
+   */
+  getStringIdColumn(name) {
+    const runtimeIdColumn = this.stringIdColumnMap.get(name);
+    if (runtimeIdColumn) {
+      return runtimeIdColumn;
+    }
+    const configIdColumn = this.configIdColumns[name];
+    if (configIdColumn) {
+      return configIdColumn;
+    }
+    return "id";
+  }
   /**
    * Retrieves the registered ID column for a table.
    * @private
@@ -2033,7 +2757,11 @@ var DrizzleAdapter = class {
         case "like":
           return drizzleOrm.like(column, value);
         case "between":
-          return drizzleOrm.between(column, value[0], value[1]);
+          return drizzleOrm.between(
+            column,
+            value[0],
+            value[1]
+          );
         case "isNull":
           return drizzleOrm.isNull(column);
         case "isNotNull":
@@ -2101,6 +2829,7 @@ var SupabaseAdapter = class {
   config;
   tableMap = /* @__PURE__ */ new Map();
   idColumnMap = /* @__PURE__ */ new Map();
+  configIdColumns;
   /**
    * Creates a new SupabaseAdapter instance.
    * @param {SupabaseAdapterConfig} config - Configuration for the Supabase adapter.
@@ -2114,6 +2843,7 @@ var SupabaseAdapter = class {
    */
   constructor(config) {
     this.config = config;
+    this.configIdColumns = config.tableIdColumns ?? {};
     if (!config.supabaseUrl) {
       throw new errors.DatabaseError(
         "Supabase URL is required for Supabase adapter",
@@ -2131,6 +2861,9 @@ var SupabaseAdapter = class {
       auth: {
         persistSession: false,
         autoRefreshToken: false
+      },
+      db: {
+        schema: config.schema ?? "public"
       }
     });
   }
@@ -2202,6 +2935,15 @@ var SupabaseAdapter = class {
    */
   async disconnect() {
   }
+  /**
+   * Closes the database connection and cleanup resources.
+   * Supabase handles connections automatically, so this just returns success.
+   * @returns Promise resolving to DatabaseResult indicating success.
+   */
+  async close() {
+    await this.disconnect();
+    return success();
+  }
   /**
    * Gets the underlying Supabase client instance.
    * @template TClient - The type of the Supabase client to return.
@@ -2769,7 +3511,9 @@ var SupabaseAdapter = class {
   getTableName(name) {
     let tableName = this.tableMap.get(name);
     if (!tableName) {
-      this.registerTable(name);
+      const hasRuntimeIdColumn = this.idColumnMap.has(name);
+      const customIdColumn = hasRuntimeIdColumn ? void 0 : this.configIdColumns[name];
+      this.registerTable(name, name, customIdColumn);
       tableName = name;
     }
     return tableName;
@@ -2885,6 +3629,8 @@ var SQLAdapter = class {
   config;
   tableMap = /* @__PURE__ */ new Map();
   idColumnMap = /* @__PURE__ */ new Map();
+  configIdColumns;
+  defaultSchema;
   /**
    * Creates a new SQLAdapter instance.
    * @param {SQLAdapterConfig} config - Configuration for the SQL adapter.
@@ -2897,10 +3643,22 @@ var SQLAdapter = class {
    */
   constructor(config) {
     this.config = config;
+    this.defaultSchema = config.schema ?? "public";
     this.pool = new pg.Pool({
       connectionString: config.connectionString,
       ...config.pool
     });
+    this.configIdColumns = config.tableIdColumns ?? {};
+  }
+  /**
+   * Get fully-qualified table name with schema
+   */
+  getQualifiedTableName(table, schema) {
+    const targetSchema = schema ?? this.defaultSchema;
+    if (table.includes(".")) {
+      return table;
+    }
+    return `${targetSchema}.${table}`;
   }
   /**
    * Initialize the adapter.
@@ -2914,7 +3672,11 @@ var SQLAdapter = class {
    */
   async initialize() {
     try {
-      await this.pool.connect();
+      const client = await this.pool.connect();
+      if (this.defaultSchema && this.defaultSchema !== "public") {
+        await client.query(`SET search_path TO ${this.defaultSchema}, public`);
+      }
+      client.release();
       return success();
     } catch (error) {
       return failure(
@@ -2953,6 +3715,23 @@ var SQLAdapter = class {
   async disconnect() {
     await this.pool.end();
   }
+  /**
+   * Closes the database connection and cleanup resources.
+   * @returns Promise resolving to DatabaseResult indicating success or failure.
+   */
+  async close() {
+    try {
+      await this.disconnect();
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to close connection: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.DISCONNECT_FAILED
+        )
+      );
+    }
+  }
   /**
    * Gets the underlying PostgreSQL client instance.
    * @template TClient - The type of the database client to return.
@@ -3033,8 +3812,9 @@ var SQLAdapter = class {
       const validationError = this.validateBasicParams(table, id);
       if (validationError) return failure(validationError);
       const tableName = this.getTableName(table);
-      const idColumn = this.idColumnMap.get(table) ?? "id";
-      const sql2 = `SELECT * FROM "${tableName}" WHERE "${idColumn}" = $1`;
+      const qualifiedTable = this.getQualifiedTableName(tableName);
+      const idColumn = this.getIdColumn(table);
+      const sql2 = `SELECT * FROM ${qualifiedTable} WHERE "${idColumn}" = $1`;
       const result = await this.pool.query(sql2, [id]);
       if (!result?.rows) {
         return failure(
@@ -3097,6 +3877,7 @@ var SQLAdapter = class {
   async findMany(table, options) {
     try {
       const tableName = this.getTableName(table);
+      const qualifiedTable = this.getQualifiedTableName(tableName);
       const params = [];
       let whereClause = "";
       let paramIndex = 1;
@@ -3104,7 +3885,7 @@ var SQLAdapter = class {
         whereClause = this.buildWhereClause(options.filter, params, paramIndex);
         paramIndex += params.length;
       }
-      const countSql = `SELECT COUNT(*) as total FROM ${tableName}${whereClause}`;
+      const countSql = `SELECT COUNT(*) as total FROM ${qualifiedTable}${whereClause}`;
       const countResult = await this.pool.query(countSql, params);
       if (!countResult.rows || countResult.rows.length === 0) {
         throw new errors.DatabaseError(
@@ -3132,7 +3913,7 @@ var SQLAdapter = class {
         limitClause += ` OFFSET $${paramIndex++}`;
         params.push(options.pagination.offset);
       }
-      const sql2 = `SELECT * FROM ${tableName}${whereClause}${orderClause}${limitClause}`;
+      const sql2 = `SELECT * FROM ${qualifiedTable}${whereClause}${orderClause}${limitClause}`;
       const result = await this.pool.query(sql2, params);
       return success({
         data: result.rows,
@@ -3172,11 +3953,12 @@ var SQLAdapter = class {
       const validationError = this.validateCreateParams(table, data);
       if (validationError) return failure(validationError);
       const tableName = this.getTableName(table);
+      const qualifiedTable = this.getQualifiedTableName(tableName);
       const keys = Object.keys(data);
       const values = Object.values(data);
       const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
       const escapedKeys = keys.map((k) => `"${k}"`).join(", ");
-      const sql2 = `INSERT INTO "${tableName}" (${escapedKeys}) VALUES (${placeholders}) RETURNING *`;
+      const sql2 = `INSERT INTO ${qualifiedTable} (${escapedKeys}) VALUES (${placeholders}) RETURNING *`;
       const result = await this.pool.query(sql2, values);
       if (!result?.rows?.length) {
         return failure(
@@ -3222,11 +4004,12 @@ var SQLAdapter = class {
       const validationError = this.validateUpdateParams(table, id, data);
       if (validationError) return failure(validationError);
       const tableName = this.getTableName(table);
+      const qualifiedTable = this.getQualifiedTableName(tableName);
       const keys = Object.keys(data);
       const values = Object.values(data);
       const setClause = keys.map((key, i) => `"${key}" = $${i + 1}`).join(", ");
-      const idColumn = this.idColumnMap.get(table) ?? "id";
-      const sql2 = `UPDATE "${tableName}" SET ${setClause} WHERE "${idColumn}" = $${keys.length + 1} RETURNING *`;
+      const idColumn = this.getIdColumn(table);
+      const sql2 = `UPDATE ${qualifiedTable} SET ${setClause} WHERE "${idColumn}" = $${keys.length + 1} RETURNING *`;
       const result = await this.pool.query(sql2, [...values, id]);
       if (!result.rows?.length) {
         return failure(
@@ -3274,8 +4057,9 @@ var SQLAdapter = class {
         );
       }
       const tableName = this.getTableName(table);
-      const idColumn = this.idColumnMap.get(table) ?? "id";
-      const sql2 = `DELETE FROM "${tableName}" WHERE "${idColumn}" = $1`;
+      const qualifiedTable = this.getQualifiedTableName(tableName);
+      const idColumn = this.getIdColumn(table);
+      const sql2 = `DELETE FROM ${qualifiedTable} WHERE "${idColumn}" = $1`;
       const result = await this.pool.query(sql2, [id]);
       if (!result) {
         return failure(
@@ -3323,34 +4107,39 @@ var SQLAdapter = class {
       const trx = {
         findById: /* @__PURE__ */ __name(async (table, id) => {
           const tableName = this.getTableName(table);
-          const idColumn = this.idColumnMap.get(table) ?? "id";
-          const sql2 = `SELECT * FROM ${tableName} WHERE ${idColumn} = $1`;
+          const qualifiedTable = this.getQualifiedTableName(tableName);
+          const idColumn = this.getIdColumn(table);
+          const sql2 = `SELECT * FROM ${qualifiedTable} WHERE "${idColumn}" = $1`;
           const result2 = await client.query(sql2, [id]);
           return success(result2.rows[0] ?? null);
         }, "findById"),
         create: /* @__PURE__ */ __name(async (table, data) => {
           const tableName = this.getTableName(table);
+          const qualifiedTable = this.getQualifiedTableName(tableName);
           const keys = Object.keys(data);
           const values = Object.values(data);
           const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
-          const sql2 = `INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;
+          const escapedKeys = keys.map((k) => `"${k}"`).join(", ");
+          const sql2 = `INSERT INTO ${qualifiedTable} (${escapedKeys}) VALUES (${placeholders}) RETURNING *`;
           const result2 = await client.query(sql2, values);
           return success(result2.rows[0]);
         }, "create"),
         update: /* @__PURE__ */ __name(async (table, id, data) => {
           const tableName = this.getTableName(table);
+          const qualifiedTable = this.getQualifiedTableName(tableName);
           const keys = Object.keys(data);
           const values = Object.values(data);
-          const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-          const idColumn = this.idColumnMap.get(table) ?? "id";
-          const sql2 = `UPDATE ${tableName} SET ${setClause} WHERE ${idColumn} = $${keys.length + 1} RETURNING *`;
+          const setClause = keys.map((key, i) => `"${key}" = $${i + 1}`).join(", ");
+          const idColumn = this.getIdColumn(table);
+          const sql2 = `UPDATE ${qualifiedTable} SET ${setClause} WHERE "${idColumn}" = $${keys.length + 1} RETURNING *`;
           const result2 = await client.query(sql2, [...values, id]);
           return success(result2.rows[0]);
         }, "update"),
         delete: /* @__PURE__ */ __name(async (table, id) => {
           const tableName = this.getTableName(table);
-          const idColumn = this.idColumnMap.get(table) ?? "id";
-          const sql2 = `DELETE FROM ${tableName} WHERE ${idColumn} = $1`;
+          const qualifiedTable = this.getQualifiedTableName(tableName);
+          const idColumn = this.getIdColumn(table);
+          const sql2 = `DELETE FROM ${qualifiedTable} WHERE "${idColumn}" = $1`;
           await client.query(sql2, [id]);
           return success();
         }, "delete"),
@@ -3397,8 +4186,9 @@ var SQLAdapter = class {
   async exists(table, id) {
     try {
       const tableName = this.getTableName(table);
-      const idColumn = this.idColumnMap.get(table) ?? "id";
-      const sql2 = `SELECT 1 FROM ${tableName} WHERE ${idColumn} = $1 LIMIT 1`;
+      const qualifiedTable = this.getQualifiedTableName(tableName);
+      const idColumn = this.getIdColumn(table);
+      const sql2 = `SELECT 1 FROM ${qualifiedTable} WHERE "${idColumn}" = $1 LIMIT 1`;
       const result = await this.pool.query(sql2, [id]);
       return success(result.rows.length > 0);
     } catch (error) {
@@ -3430,12 +4220,13 @@ var SQLAdapter = class {
   async count(table, filter) {
     try {
       const tableName = this.getTableName(table);
+      const qualifiedTable = this.getQualifiedTableName(tableName);
       let whereClause = "";
       let params = [];
       if (filter) {
         whereClause = this.buildWhereClause(filter, params, 1);
       }
-      const sql2 = `SELECT COUNT(*) as count FROM ${tableName}${whereClause}`;
+      const sql2 = `SELECT COUNT(*) as count FROM ${qualifiedTable}${whereClause}`;
       const result = await this.pool.query(sql2, params);
       const rowCount = Number.parseInt(result.rows[0].count);
       return success(Number(rowCount));
@@ -3488,22 +4279,43 @@ var SQLAdapter = class {
    * @private
    * @param {string} name - Logical table name.
    * @returns {string} Actual table name.
-   * @throws {DatabaseError} If table is not registered.
    * @description
-   * Retrieves the actual table name that has been previously registered with the adapter.
-   * This method is used internally by other methods to ensure that operations are performed
-   * on valid, registered tables. If the table is not found, it throws a DatabaseError.
+   * Retrieves the actual table name. If not registered, auto-registers it with
+   * the same logical name as the physical table name. This enables seamless
+   * table operations without manual registration (matching Supabase adapter behavior).
    */
   getTableName(name) {
-    const tableName = this.tableMap.get(name);
+    let tableName = this.tableMap.get(name);
     if (!tableName) {
-      throw new errors.DatabaseError(
-        `Table ${name} is not registered with the adapter`,
-        errors$1.DATABASE_ERROR_CODES.TABLE_NOT_REGISTERED
-      );
+      const hasRuntimeIdColumn = this.idColumnMap.has(name);
+      const customIdColumn = hasRuntimeIdColumn ? void 0 : this.configIdColumns[name];
+      this.registerTable(name, name, customIdColumn);
+      tableName = name;
     }
     return tableName;
   }
+  /**
+   * Get the ID column for a table.
+   * @private
+   * @param {string} table - Logical table name.
+   * @returns {string} ID column name (defaults to 'id').
+   * @description
+   * Retrieves the ID column for a table. Checks in this order:
+   * 1. Runtime registered ID column (from registerTable calls)
+   * 2. Config-provided ID column (from tableIdColumns in config)
+   * 3. Default 'id' column
+   */
+  getIdColumn(table) {
+    const runtimeIdColumn = this.idColumnMap.get(table);
+    if (runtimeIdColumn) {
+      return runtimeIdColumn;
+    }
+    const configIdColumn = this.configIdColumns[table];
+    if (configIdColumn) {
+      return configIdColumn;
+    }
+    return "id";
+  }
   validateBasicParams(table, id) {
     if (!table || !id) {
       return new errors.DatabaseError(
@@ -3661,35 +4473,448 @@ var SQLAdapter = class {
     return clause;
   }
 };
-var AdapterFactory = class {
+var DEFAULT_PAGINATION_LIMIT = 50;
+var RANDOM_STRING_BASE = 36;
+var ID_SUBSTRING_START = 2;
+var ID_SUBSTRING_END = 9;
+var BETWEEN_VALUES_LENGTH = 2;
+var FILTER_OPERATORS = {
+  eq: /* @__PURE__ */ __name((fieldValue, value) => fieldValue === value, "eq"),
+  ne: /* @__PURE__ */ __name((fieldValue, value) => fieldValue !== value, "ne"),
+  gt: /* @__PURE__ */ __name((fieldValue, value) => fieldValue > value, "gt"),
+  gte: /* @__PURE__ */ __name((fieldValue, value) => fieldValue >= value, "gte"),
+  lt: /* @__PURE__ */ __name((fieldValue, value) => fieldValue < value, "lt"),
+  lte: /* @__PURE__ */ __name((fieldValue, value) => fieldValue <= value, "lte"),
+  in: /* @__PURE__ */ __name((fieldValue, value) => Array.isArray(value) && value.includes(fieldValue), "in"),
+  like: /* @__PURE__ */ __name((fieldValue, value) => String(fieldValue).toLowerCase().includes(String(value).toLowerCase()), "like"),
+  between: /* @__PURE__ */ __name((fieldValue, value) => {
+    const betweenValues = value;
+    return Array.isArray(betweenValues) && betweenValues.length === BETWEEN_VALUES_LENGTH && fieldValue >= betweenValues[0] && fieldValue <= betweenValues[1];
+  }, "between"),
+  isNull: /* @__PURE__ */ __name((fieldValue) => fieldValue === null || fieldValue === void 0, "isNull"),
+  isNotNull: /* @__PURE__ */ __name((fieldValue) => fieldValue !== null && fieldValue !== void 0, "isNotNull")
+};
+var MockAdapter = class {
   static {
-    __name(this, "AdapterFactory");
+    __name(this, "MockAdapter");
+  }
+  data = /* @__PURE__ */ new Map();
+  config;
+  tableIdColumns = /* @__PURE__ */ new Map();
+  defaultSchema;
+  isInitialized = false;
+  transactionDepth = 0;
+  transactionData = null;
+  constructor(config = {}) {
+    this.config = {
+      autoGenerateIds: true,
+      latency: 0,
+      failRate: 0,
+      ...config
+    };
+    this.defaultSchema = config.schema ?? "public";
+    if (config.initialData) {
+      this.initializeTableData(config.initialData);
+    }
+    if (config.tableIdColumns) {
+      for (const [table, idColumn] of Object.entries(config.tableIdColumns)) {
+        this.tableIdColumns.set(table, idColumn);
+      }
+    }
+  }
+  async initialize() {
+    await this.simulateLatency();
+    if (this.shouldFail()) {
+      return failure(
+        new errors.DatabaseError(
+          "Mock initialization failed",
+          errors$1.DATABASE_ERROR_CODES.INIT_FAILED
+        )
+      );
+    }
+    this.isInitialized = true;
+    return success();
+  }
+  async close() {
+    await this.simulateLatency();
+    this.data.clear();
+    this.isInitialized = false;
+    return success();
+  }
+  registerTable(name, table, idColumn) {
+    if (idColumn && typeof idColumn === "string") {
+      this.tableIdColumns.set(name, idColumn);
+    }
+    if (!this.data.has(name)) {
+      this.data.set(name, /* @__PURE__ */ new Map());
+    }
+  }
+  async findById(table, id) {
+    await this.simulateLatency();
+    if (this.shouldFail()) {
+      return failure(
+        new errors.DatabaseError(
+          "Mock findById failed",
+          errors$1.DATABASE_ERROR_CODES.FIND_BY_ID_FAILED
+        )
+      );
+    }
+    const tableData = this.getTableData(table);
+    const record = tableData.get(id);
+    return success(record ? { ...record } : null);
   }
   /**
-   * Creates a new database adapter instance based on the configuration
-   *
-   * This is the core factory method that instantiates the appropriate database adapter
-   * based on the provided type and configuration. Uses TypeScript generics to ensure
-   * type safety between adapter type and configuration.
-   *
-   * **Creation Process:**
-   * 1. Validates input parameters (type and config)
-   * 2. Uses switch statement to match adapter type
-   * 3. Instantiates appropriate adapter class with type-safe config
-   * 4. Returns DatabaseAdapterType interface implementation
-   *
-   * **Type Safety:**
-   * - Generic T extends DatabaseConfig ensures config matches adapter type
-   * - Type assertions (as DrizzleAdapterConfig) provide compile-time safety
-   * - Runtime validation prevents invalid configurations
-   *
-   * @template T - Database configuration type that extends DatabaseConfig
-   * @param {T["adapter"]} type - Adapter type from ADAPTERS enum (drizzle, supabase, sql)
-   * @param {T} config - Database configuration object matching the adapter type
-   * @returns {DatabaseAdapterType} The appropriate adapter implementation
-   *
-   * @throws {Error} If adapter type is not provided
-   * @throws {Error} If adapter configuration is not provided
+   * Apply query options (filter, sort) to records
+   */
+  applyQueryOptions(records, options) {
+    let result = records;
+    if (options?.filter) {
+      result = this.applyFilter(result, options.filter);
+    }
+    if (options?.sort) {
+      result = this.applySort(result, options.sort);
+    }
+    return result;
+  }
+  /**
+   * Get pagination params with defaults
+   */
+  getPaginationParams(options) {
+    return {
+      offset: options?.pagination?.offset ?? 0,
+      limit: options?.pagination?.limit ?? DEFAULT_PAGINATION_LIMIT
+    };
+  }
+  /**
+   * Apply pagination to records
+   */
+  applyPagination(records, offset, limit) {
+    return records.slice(offset, offset + limit);
+  }
+  async findMany(table, options) {
+    await this.simulateLatency();
+    if (this.shouldFail()) {
+      return failure(
+        new errors.DatabaseError(
+          "Mock findMany failed",
+          errors$1.DATABASE_ERROR_CODES.FIND_MANY_FAILED
+        )
+      );
+    }
+    const tableData = this.getTableData(table);
+    const allRecords = Array.from(tableData.values());
+    const filteredRecords = this.applyQueryOptions(allRecords, options);
+    const total = filteredRecords.length;
+    const { offset, limit } = this.getPaginationParams(options);
+    const paginatedRecords = this.applyPagination(
+      filteredRecords,
+      offset,
+      limit
+    );
+    return success({
+      data: paginatedRecords,
+      total,
+      pagination: calculatePagination(total, options?.pagination)
+    });
+  }
+  async create(table, data) {
+    await this.simulateLatency();
+    if (this.shouldFail()) {
+      return failure(
+        new errors.DatabaseError(
+          "Mock create failed",
+          errors$1.DATABASE_ERROR_CODES.CREATE_FAILED
+        )
+      );
+    }
+    const tableData = this.getTableData(table);
+    const idColumn = this.getIdColumn(table);
+    const record = { ...data };
+    if (!record[idColumn] && this.config.autoGenerateIds) {
+      record[idColumn] = this.generateId();
+    }
+    const id = record[idColumn];
+    if (!id) {
+      return failure(
+        new errors.DatabaseError(
+          "Record must have an ID",
+          errors$1.DATABASE_ERROR_CODES.CREATE_FAILED
+        )
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    record.created_at ??= now;
+    record.updated_at ??= now;
+    tableData.set(String(id), record);
+    return success(record);
+  }
+  async update(table, id, data) {
+    await this.simulateLatency();
+    if (this.shouldFail()) {
+      return failure(
+        new errors.DatabaseError(
+          "Mock update failed",
+          errors$1.DATABASE_ERROR_CODES.UPDATE_FAILED
+        )
+      );
+    }
+    const tableData = this.getTableData(table);
+    const existing = tableData.get(id);
+    if (!existing) {
+      return failure(
+        new errors.DatabaseError(
+          "Record not found",
+          errors$1.DATABASE_ERROR_CODES.RECORD_NOT_FOUND
+        )
+      );
+    }
+    const updated = {
+      ...existing,
+      ...data,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    tableData.set(id, updated);
+    return success(updated);
+  }
+  async delete(table, id) {
+    await this.simulateLatency();
+    if (this.shouldFail()) {
+      return failure(
+        new errors.DatabaseError(
+          "Mock delete failed",
+          errors$1.DATABASE_ERROR_CODES.DELETE_FAILED
+        )
+      );
+    }
+    const tableData = this.getTableData(table);
+    const existed = tableData.delete(id);
+    if (!existed) {
+      return failure(
+        new errors.DatabaseError(
+          "Record not found",
+          errors$1.DATABASE_ERROR_CODES.RECORD_NOT_FOUND
+        )
+      );
+    }
+    return success();
+  }
+  async transaction(callback) {
+    await this.simulateLatency();
+    const snapshot = /* @__PURE__ */ new Map();
+    for (const [table, tableData] of this.data.entries()) {
+      snapshot.set(table, new Map(tableData));
+    }
+    this.transactionDepth++;
+    this.transactionData = snapshot;
+    try {
+      const trx = {
+        findById: /* @__PURE__ */ __name(async (table, id) => this.findById(table, id), "findById"),
+        create: /* @__PURE__ */ __name(async (table, data) => this.create(table, data), "create"),
+        update: /* @__PURE__ */ __name(async (table, id, data) => this.update(table, id, data), "update"),
+        delete: /* @__PURE__ */ __name(async (table, id) => this.delete(table, id), "delete"),
+        commit: /* @__PURE__ */ __name(async () => {
+        }, "commit"),
+        rollback: /* @__PURE__ */ __name(async () => {
+          this.data = snapshot;
+        }, "rollback")
+      };
+      const result = await callback(trx);
+      this.transactionDepth--;
+      this.transactionData = null;
+      return success(result);
+    } catch (error) {
+      this.data = snapshot;
+      this.transactionDepth--;
+      this.transactionData = null;
+      return failure(
+        new errors.DatabaseError(
+          `Transaction failed: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.TRANSACTION_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  async exists(table, id) {
+    await this.simulateLatency();
+    const tableData = this.getTableData(table);
+    return success(tableData.has(id));
+  }
+  async count(table, filter) {
+    await this.simulateLatency();
+    const tableData = this.getTableData(table);
+    let records = Array.from(tableData.values());
+    if (filter) {
+      records = this.applyFilter(records, filter);
+    }
+    return success(records.length);
+  }
+  async healthCheck() {
+    await this.simulateLatency();
+    return success({
+      isHealthy: this.isInitialized,
+      responseTime: this.config.latency ?? 0,
+      details: {
+        adapter: "mock",
+        tables: this.data.size,
+        totalRecords: Array.from(this.data.values()).reduce(
+          (sum, table) => sum + table.size,
+          0
+        )
+      }
+    });
+  }
+  // DatabaseAdapterType required methods
+  async connect() {
+    await this.simulateLatency();
+  }
+  async disconnect() {
+    await this.close();
+  }
+  getClient() {
+    return {
+      type: "mock",
+      data: this.data,
+      config: this.config
+    };
+  }
+  async query() {
+    await this.simulateLatency();
+    return [];
+  }
+  // Utility methods
+  /**
+   * Get fully-qualified table name with schema
+   */
+  getQualifiedTableName(table, schema) {
+    const targetSchema = schema ?? this.defaultSchema;
+    if (table.includes(".")) {
+      return table;
+    }
+    if (targetSchema === "public") {
+      return table;
+    }
+    return `${targetSchema}.${table}`;
+  }
+  initializeTableData(initialData) {
+    for (const [table, records] of Object.entries(initialData)) {
+      const tableData = /* @__PURE__ */ new Map();
+      const idColumn = this.getIdColumn(table);
+      for (const record of records) {
+        const id = record[idColumn];
+        if (id) {
+          tableData.set(String(id), { ...record });
+        }
+      }
+      this.data.set(table, tableData);
+    }
+  }
+  getTableData(table) {
+    const qualifiedTable = this.getQualifiedTableName(table);
+    if (!this.data.has(qualifiedTable)) {
+      this.data.set(qualifiedTable, /* @__PURE__ */ new Map());
+    }
+    return this.data.get(qualifiedTable);
+  }
+  getIdColumn(table) {
+    const baseTable = table.includes(".") ? table.split(".")[1] : table;
+    return this.tableIdColumns.get(baseTable) ?? "id";
+  }
+  generateId() {
+    return `mock-${Date.now()}-${Math.random().toString(RANDOM_STRING_BASE).substring(ID_SUBSTRING_START, ID_SUBSTRING_END)}`;
+  }
+  async simulateLatency() {
+    if (this.config.latency && this.config.latency > 0) {
+      await new Promise((resolve3) => setTimeout(resolve3, this.config.latency));
+    }
+  }
+  shouldFail() {
+    if (!this.config.failRate || this.config.failRate <= 0) return false;
+    return Math.random() < this.config.failRate;
+  }
+  applyFilter(records, filter) {
+    const { field, operator, value } = filter;
+    const handler = FILTER_OPERATORS[operator];
+    return records.filter((record) => {
+      const fieldValue = record[field];
+      return handler ? handler(fieldValue, value) : true;
+    });
+  }
+  applySort(records, sort) {
+    return records.sort((a, b) => {
+      for (const { field, direction } of sort) {
+        const aVal = a[field];
+        const bVal = b[field];
+        if (aVal === bVal) continue;
+        const comparison = aVal < bVal ? -1 : 1;
+        return direction === "asc" ? comparison : -comparison;
+      }
+      return 0;
+    });
+  }
+  /**
+   * Test utility: Clear all data
+   */
+  clearAll() {
+    this.data.clear();
+  }
+  /**
+   * Test utility: Get current data for inspection
+   */
+  getData(table) {
+    if (table) {
+      return Array.from(this.getTableData(table).values());
+    }
+    const result = {};
+    for (const [tableName, tableData] of this.data.entries()) {
+      result[tableName] = Array.from(tableData.values());
+    }
+    return result;
+  }
+  /**
+   * Test utility: Set data directly
+   */
+  setData(table, records) {
+    const tableData = /* @__PURE__ */ new Map();
+    const idColumn = this.getIdColumn(table);
+    for (const record of records) {
+      const id = record[idColumn];
+      if (id) {
+        tableData.set(String(id), { ...record });
+      }
+    }
+    this.data.set(table, tableData);
+  }
+};
+var AdapterFactory = class {
+  static {
+    __name(this, "AdapterFactory");
+  }
+  /**
+   * Creates a new database adapter instance based on the configuration
+   *
+   * This is the core factory method that instantiates the appropriate database adapter
+   * based on the provided type and configuration. Uses TypeScript generics to ensure
+   * type safety between adapter type and configuration.
+   *
+   * **Creation Process:**
+   * 1. Validates input parameters (type and config)
+   * 2. Uses switch statement to match adapter type
+   * 3. Instantiates appropriate adapter class with type-safe config
+   * 4. Returns DatabaseAdapterType interface implementation
+   *
+   * **Type Safety:**
+   * - Generic T extends DatabaseConfig ensures config matches adapter type
+   * - Type assertions (as DrizzleAdapterConfig) provide compile-time safety
+   * - Runtime validation prevents invalid configurations
+   *
+   * @template T - Database configuration type that extends DatabaseConfig
+   * @param {T["adapter"]} type - Adapter type from ADAPTERS enum (drizzle, supabase, sql)
+   * @param {T} config - Database configuration object matching the adapter type
+   * @returns {DatabaseAdapterType} The appropriate adapter implementation
+   *
+   * @throws {Error} If adapter type is not provided
+   * @throws {Error} If adapter configuration is not provided
    * @throws {Error} If unsupported adapter type is specified
    * @throws {Error} If adapter instantiation fails
    *
@@ -3754,6 +4979,9 @@ var AdapterFactory = class {
         // SQL adapter - for raw SQL operations and custom database integrations
         case db.ADAPTERS.SQL:
           return new SQLAdapter(config);
+        // Mock adapter - for in-memory testing without real database
+        case db.ADAPTERS.MOCK:
+          return new MockAdapter(config);
         // Default case - handles unsupported or invalid adapter types
         default:
           throw new errors.DatabaseError(
@@ -3852,6 +5080,9 @@ var SoftDeleteAdapter = class {
   async disconnect() {
     return this.baseAdapter.disconnect();
   }
+  async close() {
+    return this.baseAdapter.close();
+  }
   /**
    * Gets the underlying database client.
    *
@@ -4235,8 +5466,41 @@ var SoftDeleteAdapter = class {
     return this.config.excludeTables?.includes(table) ?? false;
   }
 };
+var DATE_PART_MIN_WIDTH = 2;
+var CONTEXT_SOURCE_PATTERNS = [
+  { patterns: ["encrypt"], source: db.EXTENSION_SOURCE.Encryption },
+  {
+    patterns: ["softdelete", "soft_delete"],
+    source: db.EXTENSION_SOURCE.SoftDelete
+  },
+  { patterns: ["cach"], source: db.EXTENSION_SOURCE.Caching },
+  { patterns: ["audit"], source: db.EXTENSION_SOURCE.Audit },
+  {
+    patterns: ["replica", "read_replica"],
+    source: db.EXTENSION_SOURCE.ReadReplica
+  },
+  {
+    patterns: ["multi_write", "multiwrite"],
+    source: db.EXTENSION_SOURCE.MultiWrite
+  }
+];
+var MESSAGE_SOURCE_PATTERNS = [
+  { patterns: ["encrypt"], source: db.EXTENSION_SOURCE.Encryption },
+  {
+    patterns: ["soft delete", "softdelete"],
+    source: db.EXTENSION_SOURCE.SoftDelete
+  },
+  { patterns: ["cache", "caching"], source: db.EXTENSION_SOURCE.Caching },
+  {
+    patterns: ["replica", "read replica"],
+    source: db.EXTENSION_SOURCE.ReadReplica
+  },
+  {
+    patterns: ["multi-write", "multiwrite"],
+    source: db.EXTENSION_SOURCE.MultiWrite
+  }
+];
 var AuditAdapter = class {
-  // Using shared logger instance from @plyaz/logger
   /**
    * Creates a new AuditAdapter instance.
    *
@@ -4250,9 +5514,11 @@ var AuditAdapter = class {
    * ```typescript
    * const auditAdapter = new AuditAdapter(baseAdapter, {
    *   enabled: true,
-   *   retentionDays: 90,
+   *   retentionDays: 180,
    *   excludeFields: ['password', 'token'],
    *   excludeTables: ['temp_data'],
+   *   schema: 'audit',
+   *   usePartitionedTables: true,
    *   onAuditAfterWrite: async (event) => {
    *     await complianceService.recordAudit(event);
    *   }
@@ -4262,11 +5528,18 @@ var AuditAdapter = class {
   constructor(baseAdapter, config) {
     this.baseAdapter = baseAdapter;
     this.config = config;
+    this.auditSchema = config.schema ?? "audit";
+    this.usePartitionedTables = config.usePartitionedTables ?? true;
   }
   static {
     __name(this, "AuditAdapter");
   }
   auditContext = {};
+  // Using shared logger instance from @plyaz/logger
+  /** Cached schema-qualified table name */
+  auditSchema;
+  /** Whether to use daily partitioned tables */
+  usePartitionedTables;
   /**
    * Initializes the audit adapter and underlying adapter.
    *
@@ -4316,6 +5589,9 @@ var AuditAdapter = class {
   async disconnect() {
     return this.baseAdapter.disconnect();
   }
+  async close() {
+    return this.baseAdapter.close();
+  }
   /**
    * Gets the underlying database client.
    *
@@ -4454,11 +5730,36 @@ var AuditAdapter = class {
   }
   async create(table, data) {
     this.validateCreateParams(table, data);
-    const result = await this.baseAdapter.create(table, data);
-    if (result.success && this.shouldAudit(table)) {
-      await this.handleCreateAudit(table, result.value);
+    try {
+      const result = await this.baseAdapter.create(table, data);
+      if (result.success && this.shouldAudit(table)) {
+        await this.logAudit({
+          operation: db.AUDIT_OPERATION.Create,
+          table,
+          recordId: result.value?.id,
+          changes: {
+            after: result.value,
+            encryptedFields: this.getEncryptedFields(table)
+          },
+          userId: this.auditContext.userId,
+          requestId: this.auditContext.requestId,
+          timestamp: /* @__PURE__ */ new Date(),
+          ipAddress: this.auditContext.ipAddress,
+          userAgent: this.auditContext.userAgent
+        });
+      }
+      return result;
+    } catch (error) {
+      if (this.shouldAudit(table)) {
+        await this.logOperationFailure({
+          operation: db.AUDIT_OPERATION.Create,
+          table,
+          data,
+          error
+        });
+      }
+      throw error;
     }
-    return result;
   }
   validateCreateParams(table, data) {
     if (!table || !data) {
@@ -4472,14 +5773,99 @@ var AuditAdapter = class {
       );
     }
   }
-  async handleCreateAudit(table, value) {
+  async update(table, id, data) {
+    const before = await this.baseAdapter.findById(table, id);
+    try {
+      const result = await this.baseAdapter.update(table, id, data);
+      if (result.success && this.shouldAudit(table)) {
+        await this.logAudit({
+          operation: db.AUDIT_OPERATION.Update,
+          table,
+          recordId: id,
+          changes: {
+            before: before.success ? before.value : void 0,
+            after: result.value,
+            fields: Object.keys(data),
+            encryptedFields: this.getEncryptedFields(table)
+          },
+          userId: this.auditContext.userId,
+          requestId: this.auditContext.requestId,
+          timestamp: /* @__PURE__ */ new Date(),
+          ipAddress: this.auditContext.ipAddress,
+          userAgent: this.auditContext.userAgent
+        });
+      }
+      return result;
+    } catch (error) {
+      if (this.shouldAudit(table)) {
+        await this.logOperationFailure({
+          operation: db.AUDIT_OPERATION.Update,
+          table,
+          data,
+          error,
+          recordId: id,
+          beforeState: before.value
+        });
+      }
+      throw error;
+    }
+  }
+  async delete(table, id) {
+    const before = await this.baseAdapter.findById(table, id);
+    try {
+      const result = await this.baseAdapter.delete(table, id);
+      if (result.success && this.shouldAudit(table)) {
+        await this.logAudit({
+          operation: db.AUDIT_OPERATION.Delete,
+          table,
+          recordId: id,
+          changes: {
+            before: before.success ? before.value : void 0
+          },
+          userId: this.auditContext.userId,
+          requestId: this.auditContext.requestId,
+          timestamp: /* @__PURE__ */ new Date(),
+          ipAddress: this.auditContext.ipAddress,
+          userAgent: this.auditContext.userAgent
+        });
+      }
+      return result;
+    } catch (error) {
+      if (this.shouldAudit(table)) {
+        await this.logOperationFailure({
+          operation: db.AUDIT_OPERATION.Delete,
+          table,
+          data: null,
+          error,
+          recordId: id,
+          beforeState: before.value
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * Logs operation failures to audit for compliance tracking.
+   * Captures the before state, attempted changes, and error details.
+   */
+  async logOperationFailure(options) {
+    const { operation, table, data, error, recordId, beforeState } = options;
     try {
+      const errorSource = this.getErrorSource(error);
+      const failedOperation = this.getFailedOperation(operation);
       await this.logAudit({
-        operation: db.AUDIT_OPERATION.CREATE,
+        operation: failedOperation,
         table,
-        recordId: value?.id,
+        recordId: recordId ?? data?.id,
         changes: {
-          after: value
+          before: beforeState,
+          attempted: data,
+          failure: {
+            source: errorSource,
+            error_type: error.name,
+            error_message: error.message,
+            error_code: error.errorCode
+          }
         },
         userId: this.auditContext.userId,
         requestId: this.auditContext.requestId,
@@ -4489,55 +5875,67 @@ var AuditAdapter = class {
       });
     } catch (auditError) {
       logger.logger.error(
-        `Audit logging failed for CREATE operation: ${auditError.message}`
+        `Failed to log operation failure to audit: ${auditError.message}`
       );
     }
   }
-  async update(table, id, data) {
-    const before = await this.baseAdapter.findById(table, id);
-    const result = await this.baseAdapter.update(table, id, data);
-    if (result.success && this.shouldAudit(table)) {
-      await this.logAudit({
-        operation: db.AUDIT_OPERATION.UPDATE,
-        table,
-        recordId: id,
-        changes: {
-          before: before.success ? before.value : void 0,
-          after: result.value,
-          fields: Object.keys(data)
-        },
-        userId: this.auditContext.userId,
-        requestId: this.auditContext.requestId,
-        timestamp: /* @__PURE__ */ new Date(),
-        ipAddress: this.auditContext.ipAddress,
-        userAgent: this.auditContext.userAgent
-      });
+  /**
+   * Maps a successful operation to its failed counterpart.
+   */
+  getFailedOperation(operation) {
+    switch (operation) {
+      case db.AUDIT_OPERATION.Create:
+        return db.AUDIT_OPERATION.CreateFailed;
+      case db.AUDIT_OPERATION.Update:
+        return db.AUDIT_OPERATION.UpdateFailed;
+      case db.AUDIT_OPERATION.Delete:
+        return db.AUDIT_OPERATION.DeleteFailed;
+      default:
+        return operation;
     }
-    return result;
   }
-  async delete(table, id) {
-    const before = await this.baseAdapter.findById(table, id);
-    const result = await this.baseAdapter.delete(table, id);
-    if (result.success && this.shouldAudit(table)) {
-      await this.logAudit({
-        operation: db.AUDIT_OPERATION.DELETE,
-        table,
-        recordId: id,
-        changes: {
-          before: before.success ? before.value : void 0
-        },
-        userId: this.auditContext.userId,
-        requestId: this.auditContext.requestId,
-        timestamp: /* @__PURE__ */ new Date(),
-        ipAddress: this.auditContext.ipAddress,
-        userAgent: this.auditContext.userAgent
-      });
+  /**
+   * Determines which extension/layer caused the error based on error details.
+   */
+  getErrorSource(error) {
+    const errorMessage = error.message.toLowerCase();
+    const dbError = error;
+    const errorContext = dbError.context?.source?.toLowerCase();
+    if (errorContext) {
+      const contextSource = this.matchPatterns(
+        errorContext,
+        CONTEXT_SOURCE_PATTERNS
+      );
+      if (contextSource) return contextSource;
     }
-    return result;
+    const messageSource = this.matchPatterns(
+      errorMessage,
+      MESSAGE_SOURCE_PATTERNS
+    );
+    if (messageSource) return messageSource;
+    return db.EXTENSION_SOURCE.DatabaseAdapter;
   }
   /**
-   * Executes operations within a transaction with audit logging.
-   *
+   * Matches a text against a list of pattern groups.
+   */
+  matchPatterns(text, patternGroups) {
+    for (const { patterns, source } of patternGroups) {
+      if (patterns.some((pattern) => text.includes(pattern))) {
+        return source;
+      }
+    }
+    return null;
+  }
+  /**
+   * Gets the list of encrypted fields for a table.
+   * Returns undefined if no fields are encrypted for this table.
+   */
+  getEncryptedFields(table) {
+    return this.config.encryptedFields?.[table];
+  }
+  /**
+   * Executes operations within a transaction with audit logging.
+   *
    * **RESPONSIBILITY:** Passes transaction to base adapter
    * **BEHAVIOR:** Individual operations within transaction are audited
    * **ATOMICITY:** Audit records are part of the transaction
@@ -4709,11 +6107,38 @@ var AuditAdapter = class {
       );
     }
   }
+  /**
+   * Generates the audit table name based on configuration.
+   *
+   * **RESPONSIBILITY:** Determines the correct table name for audit records
+   * **TABLE NAMING:**
+   *   - Partitioned: `{schema}.audit_log_yyyy_mm_dd` (e.g., audit.audit_log_2024_12_01)
+   *   - Non-partitioned: `{schema}.audit_logs` (e.g., audit.audit_logs)
+   *
+   * @private
+   * @param timestamp - Timestamp to use for partition date
+   * @returns Schema-qualified table name
+   */
+  getAuditTableName(timestamp) {
+    if (this.usePartitionedTables) {
+      const year = timestamp.getFullYear();
+      const month = String(timestamp.getMonth() + 1).padStart(
+        DATE_PART_MIN_WIDTH,
+        "0"
+      );
+      const day = String(timestamp.getDate()).padStart(
+        DATE_PART_MIN_WIDTH,
+        "0"
+      );
+      return `${this.auditSchema}.audit_log_${year}_${month}_${day}`;
+    }
+    return `${this.auditSchema}.audit_logs`;
+  }
   /**
    * Writes audit record to daily audit table.
    *
    * **RESPONSIBILITY:** Persists audit event to database
-   * **TABLE NAMING:** Uses daily tables (audit_YYYYMMDD)
+   * **TABLE NAMING:** Uses daily partitioned tables (audit.audit_log_yyyy_mm_dd) by default
    * **STRUCTURE:** Converts event to database record format
    *
    * @private
@@ -4722,7 +6147,7 @@ var AuditAdapter = class {
    *
    * @example
    * ```typescript
-   * // Internal usage - writes to audit_20241201 table
+   * // Internal usage - writes to audit.audit_log_2024_12_01 table
    * await this.writeAuditRecord({
    *   operation: 'UPDATE',
    *   table: 'users',
@@ -4733,7 +6158,7 @@ var AuditAdapter = class {
    * ```
    */
   async writeAuditRecord(event) {
-    const tableName = "audit_logs";
+    const tableName = this.getAuditTableName(event.timestamp);
     try {
       const auditResult = await this.baseAdapter.create(tableName, {
         operation: event.operation,
@@ -4821,6 +6246,9 @@ var EncryptionAdapter = class {
   async disconnect() {
     return this.baseAdapter.disconnect();
   }
+  async close() {
+    return this.baseAdapter.close();
+  }
   getClient() {
     return this.baseAdapter.getClient();
   }
@@ -4890,14 +6318,10 @@ var EncryptionAdapter = class {
     return this.config.enabled && isObject(data) && Boolean(this.config.fields[table]);
   }
   encryptSingleField(result, field) {
-    try {
-      if (result[field]) {
-        result[field] = this.encrypt(
-          String(result[field])
-        );
-      }
-    } catch (error) {
-      console.error(`Failed to encrypt field ${field}:`, error);
+    if (result[field]) {
+      result[field] = this.encrypt(
+        String(result[field])
+      );
     }
   }
   decryptFields(table, data) {
@@ -4910,15 +6334,18 @@ var EncryptionAdapter = class {
     return result;
   }
   decryptSingleField(result, field) {
-    try {
-      if (result[field]) {
-        const fieldValue = String(result[field]);
-        if (this.isEncryptedValue(fieldValue)) {
+    if (result[field]) {
+      const fieldValue = String(result[field]);
+      if (this.isEncryptedValue(fieldValue)) {
+        try {
           result[field] = this.decrypt(fieldValue);
+        } catch (error) {
+          console.warn(
+            `Failed to decrypt field ${field}, returning as-is:`,
+            error.message
+          );
         }
       }
-    } catch (error) {
-      console.error(`Failed to decrypt field ${field}:`, error);
     }
   }
   encrypt(text) {
@@ -5124,6 +6551,9 @@ var CachingAdapter = class {
   async disconnect() {
     return this.baseAdapter.disconnect();
   }
+  async close() {
+    return this.baseAdapter.close();
+  }
   /**
    * Gets the underlying database client.
    *
@@ -5548,6 +6978,9 @@ var ReadReplicaAdapter = class {
   async disconnect() {
     return this.primaryAdapter.disconnect();
   }
+  async close() {
+    return this.primaryAdapter.close();
+  }
   getClient() {
     return this.primaryAdapter.getClient();
   }
@@ -5625,7 +7058,11 @@ function buildAdapterChain(baseAdapter, config) {
     adapter = new CachingAdapter(adapter, config.cache);
   }
   if (config.audit?.enabled) {
-    adapter = new AuditAdapter(adapter, config.audit);
+    adapter = new AuditAdapter(adapter, {
+      ...config.audit,
+      // Pass encrypted fields config so audit can log which fields are encrypted at rest
+      encryptedFields: config.encryption?.enabled ? config.encryption.fields : void 0
+    });
   }
   if (config.readReplica?.enabled) {
     adapter = new ReadReplicaAdapter(adapter, {
@@ -5647,8 +7084,10 @@ function createAdapterConfig(config) {
       // orm: ADAPTERS.SUPABASE,
       connectionString: drizzleConfig.connectionString ?? drizzleConfig.url,
       // Support both formats
-      pool: drizzleConfig.poolSize ? { max: drizzleConfig.poolSize } : void 0
+      pool: drizzleConfig.poolSize ? { max: drizzleConfig.poolSize } : void 0,
       // Optional connection pooling
+      tableIdColumns: drizzleConfig.tableIdColumns
+      // Custom ID column mappings
     };
   }
   if (config.adapter === db.ADAPTER_TYPES.SUPABASE) {
@@ -5662,15 +7101,28 @@ function createAdapterConfig(config) {
       // Public API key
       supabaseServiceKey: supabaseConfig.supabaseServiceKey,
       // Service role key (admin)
-      schema: supabaseConfig.schema
+      schema: supabaseConfig.schema,
       // Database schema
+      tableIdColumns: supabaseConfig.tableIdColumns
+      // Custom ID column mappings
+    };
+  }
+  if (config.adapter === db.ADAPTER_TYPES.MOCK) {
+    return {
+      adapter: db.ADAPTERS.MOCK,
+      ...config.config
+      // Pass through all mock config options
     };
   }
   const sqlConfig = config.config;
   return {
     adapter: db.ADAPTERS.SQL,
-    connectionString: sqlConfig.connectionString ?? sqlConfig.url
+    connectionString: sqlConfig.connectionString ?? sqlConfig.url,
     // Support both formats
+    schema: sqlConfig.schema,
+    // Default schema for all tables
+    tableIdColumns: sqlConfig.tableIdColumns
+    // Custom ID column mappings
   };
 }
 __name(createAdapterConfig, "createAdapterConfig");
@@ -5751,18 +7203,33 @@ __name(createDatabaseService, "createDatabaseService");
 
 // src/repository/BaseRepository.ts
 var BaseRepository = class {
-  // Using shared logger instance from @plyaz/logger
-  constructor(db, tableName) {
+  constructor(db, tableName, defaultConfig) {
     this.db = db;
     this.tableName = tableName;
+    this.defaultConfig = defaultConfig;
   }
   static {
     __name(this, "BaseRepository");
   }
+  defaultConfig;
+  /**
+   * Merges default repository config with per-operation config
+   * Per-operation config takes precedence over default config
+   */
+  mergeConfig(operationConfig) {
+    if (!this.defaultConfig && !operationConfig) {
+      return void 0;
+    }
+    return {
+      ...this.defaultConfig,
+      ...operationConfig
+    };
+  }
   /**
    * Find a single entity by its primary key ID
    *
    * @param {string} id - The primary key ID of the entity to retrieve
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<T | null>>} Promise resolving to the entity or null if not found
    *
    * @example
@@ -5771,15 +7238,21 @@ var BaseRepository = class {
    * if (result.success && result.value) {
    *   console.log('Found user:', result.value.name);
    * }
+   *
+   * // Use specific adapter for this query
+   * const analyticsResult = await userRepository.findById('user-123', {
+   *   adapter: 'analytics'
+   * });
    * ```
    */
-  async findById(id) {
-    return this.db.findById(this.tableName, id);
+  async findById(id, config) {
+    return this.db.get(this.tableName, id, this.mergeConfig(config));
   }
   /**
    * Find multiple entities with optional filtering, sorting, and pagination
    *
-   * @param {QueryOptions} [options] - Optional query configuration
+   * @param {QueryOptions<T>} [options] - Optional query configuration with type-safe fields
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<PaginatedResult<T>>>} Promise resolving to paginated results
    *
    * @example
@@ -5789,15 +7262,21 @@ var BaseRepository = class {
    *   sort: [{ field: 'createdAt', direction: 'desc' }],
    *   pagination: { limit: 20, offset: 0 }
    * });
+   *
+   * // Query from analytics database
+   * const analyticsResult = await userRepository.findMany({}, {
+   *   adapter: 'analytics'
+   * });
    * ```
    */
-  async findMany(options) {
-    return this.db.findMany(this.tableName, options);
+  async findMany(options, config) {
+    return this.db.list(this.tableName, options, this.mergeConfig(config));
   }
   /**
    * Create a new entity in the database
    *
-   * @param {T} data - The entity data to create
+   * @param {CreateInput<T>} data - The entity data to create (id is auto-generated)
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<T>>} Promise resolving to the created entity
    *
    * @example
@@ -5806,16 +7285,25 @@ var BaseRepository = class {
    *   name: 'John Doe',
    *   email: 'john@example.com'
    * });
+   *
+   * // Create in specific database/schema
+   * const result = await userRepository.create({
+   *   name: 'Jane Doe'
+   * }, {
+   *   adapter: 'secondary',
+   *   schema: 'backoffice'
+   * });
    * ```
    */
-  async create(data) {
-    return this.db.create(this.tableName, data);
+  async create(data, config) {
+    return this.db.create(this.tableName, data, this.mergeConfig(config));
   }
   /**
    * Update an existing entity by ID
    *
    * @param {string} id - The primary key ID of the entity to update
    * @param {Partial<T>} data - Partial entity data containing fields to update
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<T>>} Promise resolving to the updated entity
    *
    * @example
@@ -5824,15 +7312,29 @@ var BaseRepository = class {
    *   email: 'newemail@example.com',
    *   updatedAt: new Date()
    * });
+   *
+   * // Update in specific adapter with custom ID column
+   * const result = await userRepository.update('flag-key', {
+   *   value: true
+   * }, {
+   *   adapter: 'config',
+   *   idColumn: 'key'
+   * });
    * ```
    */
-  async update(id, data) {
-    return this.db.update(this.tableName, id, data);
+  async update(id, data, config) {
+    return this.db.update(
+      this.tableName,
+      id,
+      data,
+      this.mergeConfig(config)
+    );
   }
   /**
    * Delete an entity by ID (hard delete)
    *
    * @param {string} id - The primary key ID of the entity to delete
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<void>>} Promise resolving when deletion is complete
    *
    * @warning This is a permanent operation that cannot be undone
@@ -5841,15 +7343,21 @@ var BaseRepository = class {
    * @example
    * ```typescript
    * const result = await userRepository.delete('user-123');
+   *
+   * // Delete from specific adapter
+   * const result = await userRepository.delete('user-123', {
+   *   adapter: 'archive'
+   * });
    * ```
    */
-  async delete(id) {
-    return this.db.delete(this.tableName, id);
+  async delete(id, config) {
+    return this.db.delete(this.tableName, id, this.mergeConfig(config));
   }
   /**
    * Count entities matching optional filter criteria
    *
-   * @param {Filter} [filter] - Optional filter conditions
+   * @param {Filter<T>} [filter] - Optional filter conditions with type-safe fields
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<number>>} Promise resolving to the count
    *
    * @example
@@ -5858,15 +7366,21 @@ var BaseRepository = class {
    * const activeResult = await userRepository.count({
    *   field: 'status', operator: 'eq', value: 'active'
    * });
+   *
+   * // Count in specific adapter
+   * const archiveCount = await userRepository.count(undefined, {
+   *   adapter: 'archive'
+   * });
    * ```
    */
-  async count(filter) {
-    return this.db.count(this.tableName, filter);
+  async count(filter, config) {
+    return this.db.count(this.tableName, filter, this.mergeConfig(config));
   }
   /**
    * Check if an entity exists by ID
    *
    * @param {string} id - The primary key ID to check
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<boolean>>} Promise resolving to existence status
    *
    * @example
@@ -5875,15 +7389,30 @@ var BaseRepository = class {
    * if (existsResult.success && existsResult.value) {
    *   console.log('User exists');
    * }
+   *
+   * // Check existence in specific adapter
+   * const existsInArchive = await userRepository.exists('user-123', {
+   *   adapter: 'archive'
+   * });
    * ```
    */
-  async exists(id) {
-    return this.db.exists(this.tableName, id);
+  async exists(id, config) {
+    const result = await this.db.get(
+      this.tableName,
+      id,
+      this.mergeConfig(config)
+    );
+    return {
+      success: result.success,
+      value: result.success && result.value !== null,
+      error: result.error
+    };
   }
   /**
    * Find the first entity matching filter criteria
    *
-   * @param {Filter} filter - Filter conditions to match
+   * @param {Filter<T>} filter - Filter conditions with type-safe fields
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<T | null>>} Promise resolving to first match or null
    *
    * @example
@@ -5891,15 +7420,24 @@ var BaseRepository = class {
    * const result = await userRepository.findOne({
    *   field: 'email', operator: 'eq', value: 'john@example.com'
    * });
+   *
+   * // Find in specific adapter
+   * const archivedUser = await userRepository.findOne({
+   *   field: 'email', operator: 'eq', value: 'john@example.com'
+   * }, {
+   *   adapter: 'archive',
+   *   includeSoftDeleted: true
+   * });
    * ```
    */
-  async findOne(filter) {
-    return this.db.findOne(this.tableName, filter);
+  async findOne(filter, config) {
+    return this.db.findOne(this.tableName, filter, this.mergeConfig(config));
   }
   /**
    * Soft delete an entity by ID (recoverable deletion)
    *
    * @param {string} id - The primary key ID of the entity to soft delete
+   * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
    * @returns {Promise<DatabaseResult<void>>} Promise resolving when soft deletion is complete
    *
    * @see {@link delete} For permanent deletion
@@ -5908,241 +7446,669 @@ var BaseRepository = class {
    * ```typescript
    * const result = await userRepository.softDelete('user-123');
    * // User is hidden but can be recovered
+   *
+   * // Soft delete in specific adapter
+   * const result = await userRepository.softDelete('user-123', {
+   *   adapter: 'primary',
+   *   skipAudit: false
+   * });
    * ```
    */
-  async softDelete(id) {
-    return this.db.softDelete(this.tableName, id);
+  async softDelete(id, config) {
+    return this.db.softDelete(this.tableName, id, this.mergeConfig(config));
   }
 };
-var USE_REPLICA_KEY = "use_replica";
-function UseReplica(options = {}) {
-  return (target, propertyKey, descriptor) => {
-    common.SetMetadata(USE_REPLICA_KEY, options)(target, propertyKey, descriptor);
-  };
-}
-__name(UseReplica, "UseReplica");
-var RedisCache = class {
+var MultiWriteAdapter = class {
   static {
-    __name(this, "RedisCache");
+    __name(this, "MultiWriteAdapter");
   }
-  redis;
-  defaultTTL;
-  // Using shared logger instance from @plyaz/logger
-  /**
-   * Creates a new RedisCache instance.
-   * @param config Redis configuration
-   *
-   * @example
-   * ```typescript
-   * // Basic configuration
-   * const cache = new RedisCache({
-   *   url: 'redis://localhost:6379'
-   * });
-   *
-   * // With custom default TTL
-   * const cacheWithCustomTTL = new RedisCache({
-   *   url: 'redis://localhost:6379',
-   *   defaultTTL: 1800 // 30 minutes
-   * });
-   *
-   * // Production configuration with options
-   * const productionCache = new RedisCache({
-   *   url: 'redis://redis-cluster.example.com:6379',
-   *   defaultTTL: 3600,
-   *   // Additional Redis options can be passed here
-   * });
-   * ```
-   */
-  constructor(config$1) {
-    this.redis = new ioredis.Redis(config$1.url);
-    this.defaultTTL = config$1.defaultTTL ?? config.NUMERIX.THIRTY_SIX_HUNDERD;
+  baseAdapter;
+  config;
+  constructor(baseAdapter, config) {
+    this.baseAdapter = baseAdapter;
+    this.config = {
+      mode: "best-effort",
+      onSecondaryFailure: "log",
+      timeout: 5e3,
+      ...config
+    };
   }
-  /**
-   * Retrieves a value from cache by key.
-   * Automatically handles JSON deserialization.
-   *
-   * @param key Cache key
-   * @returns DatabaseResult containing cached value or null if not found
-   *
-   * @example
-   * ```typescript
-   * // Get user profile
-   * const result = await cache.get<UserProfile>('profile:123');
-   * if (result.success && result.value) {
-   *   console.log('User:', result.value.name);
-   * } else {
-   *   console.log('Profile not found or cache error');
-   * }
-   *
-   * // Get product list
-   * const products = await cache.get<Product[]>('products:featured');
-   * if (products.success && products.value) {
-   *   products.value.forEach(product => {
-   *     console.log(product.name, product.price);
-   *   });
-   * }
-   * ```
-   */
-  async get(key) {
-    try {
-      const value = await this.redis.get(key);
-      if (!value) {
-        return success();
+  async initialize() {
+    return this.baseAdapter.initialize();
+  }
+  async close() {
+    return this.baseAdapter.close();
+  }
+  async connect() {
+    await this.baseAdapter.connect();
+    for (const secondary of this.config.adapters) {
+      if (typeof secondary.connect === "function") {
+        await secondary.connect();
       }
-      const parsed = JSON.parse(value);
-      if (parsed && typeof parsed === "object") {
-        return success(parsed);
+    }
+  }
+  async disconnect() {
+    await this.baseAdapter.disconnect();
+    for (const secondary of this.config.adapters) {
+      if (typeof secondary.disconnect === "function") {
+        await secondary.disconnect();
       }
-      return success();
-    } catch (error) {
-      return failure(
-        new errors.DatabaseError(
-          "Cache get failed",
-          errors$1.DATABASE_ERROR_CODES.CACHE_GET_FAILED,
-          { context: { source: "RedisCache.get", key, cause: error } }
-        )
-      );
+    }
+  }
+  getClient() {
+    return this.baseAdapter.getClient();
+  }
+  async query(sql2, params) {
+    return this.baseAdapter.query(sql2, params);
+  }
+  registerTable(name, table, idColumn) {
+    this.baseAdapter.registerTable(name, table, idColumn);
+    for (const secondary of this.config.adapters) {
+      if (typeof secondary.registerTable === "function") {
+        secondary.registerTable(name, table, idColumn);
+      }
+    }
+  }
+  // Read operations - always use primary
+  async findById(table, id) {
+    return this.baseAdapter.findById(table, id);
+  }
+  async findMany(table, options) {
+    return this.baseAdapter.findMany(table, options);
+  }
+  async exists(table, id) {
+    return this.baseAdapter.exists(table, id);
+  }
+  async count(table, filter) {
+    return this.baseAdapter.count(table, filter);
+  }
+  // Write operations - replicate to secondaries
+  async create(table, data) {
+    const primaryResult = await this.baseAdapter.create(table, data);
+    if (!primaryResult.success) {
+      return primaryResult;
+    }
+    await this.replicateWrite(
+      () => Promise.all(
+        this.config.adapters.map((adapter) => adapter.create(table, data))
+      )
+    );
+    return primaryResult;
+  }
+  async update(table, id, data) {
+    const primaryResult = await this.baseAdapter.update(table, id, data);
+    if (!primaryResult.success) {
+      return primaryResult;
+    }
+    await this.replicateWrite(
+      () => Promise.all(
+        this.config.adapters.map((adapter) => adapter.update(table, id, data))
+      )
+    );
+    return primaryResult;
+  }
+  async delete(table, id) {
+    const primaryResult = await this.baseAdapter.delete(table, id);
+    if (!primaryResult.success) {
+      return primaryResult;
+    }
+    await this.replicateWrite(
+      () => Promise.all(
+        this.config.adapters.map((adapter) => adapter.delete(table, id))
+      )
+    );
+    return primaryResult;
+  }
+  async transaction(callback) {
+    return this.baseAdapter.transaction(callback);
+  }
+  async healthCheck() {
+    return this.baseAdapter.healthCheck();
+  }
+  /**
+   * Replicate write operation to secondary adapters
+   */
+  async replicateWrite(fn) {
+    if (this.config.mode === "strict") {
+      const results = await Promise.allSettled([
+        this.executeWithTimeout(fn(), this.config.timeout)
+      ]);
+      const failures = results.filter((r) => r.status === "rejected");
+      if (failures.length > 0) {
+        this.handleSecondaryFailure(failures);
+      }
+    } else {
+      this.executeWithTimeout(fn(), this.config.timeout).then((results) => {
+        const failures = results.filter((r) => !r.success);
+        if (failures.length > 0) {
+          this.handleSecondaryFailure(
+            failures.map((f) => ({
+              status: "rejected",
+              reason: f.error
+            }))
+          );
+        }
+      }).catch((error) => {
+        this.handleSecondaryFailure([
+          { status: "rejected", reason: error }
+        ]);
+      });
     }
   }
   /**
-   * Sets a value in cache with optional TTL.
-   * Automatically handles JSON serialization.
-   *
-   * @param key Cache key
-   * @param value Value to cache
-   * @param ttl Time to live in seconds (uses default if not specified)
-   * @returns DatabaseResult indicating operation success
-   *
-   * @example
-   * ```typescript
-   * // Cache with default TTL
-   * await cache.set('user:123', { id: 123, name: 'John' });
-   *
-   * // Cache with custom TTL (5 minutes)
-   * await cache.set('session:abc123', sessionData, 300);
-   *
-   * // Cache with long TTL for static data
-   * await cache.set('config:app-settings', appSettings, 86400); // 24 hours
-   *
-   * // Cache with short TTL for frequently changing data
-   * await cache.set('metrics:realtime', realtimeData, 60); // 1 minute
-   * ```
+   * Execute operation with timeout
    */
-  async set(key, value, ttl) {
-    try {
-      const ttlValue = ttl ?? this.defaultTTL;
-      await this.redis.set(key, JSON.stringify(value), "EX", ttlValue);
-      return success();
-    } catch (error) {
-      return failure(
-        new errors.DatabaseError(
-          "Cache set failed",
-          errors$1.DATABASE_ERROR_CODES.CACHE_SET_FAILED,
-          { context: { source: "RedisCache.set", key, cause: error } }
+  async executeWithTimeout(promise, timeoutMs) {
+    return Promise.race([
+      promise,
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error("Secondary write timeout")),
+          timeoutMs
         )
-      );
-    }
+      )
+    ]);
   }
   /**
-   * Deletes a value from cache.
-   *
-   * @param key Cache key
-   * @returns DatabaseResult indicating operation success
-   *
-   * @example
-   * ```typescript
-   * // Delete specific cache entry
-   * await cache.del('user:123');
-   *
-   * // Delete session on logout
-   * await cache.del(`session:${sessionId}`);
-   *
-   * // Delete cached configuration
-   * await cache.del('config:feature-flags');
-   * ```
+   * Handle secondary adapter failures
    */
-  async del(key) {
+  handleSecondaryFailure(failures) {
+    const errorMessages = failures.map(
+      (f) => f.status === "rejected" ? f.reason?.message : "Unknown error"
+    ).join(", ");
+    const message = `Multi-write secondary failure: ${errorMessages}`;
+    switch (this.config.onSecondaryFailure) {
+      case "log":
+        console.log(`[MultiWrite] ${message}`);
+        break;
+      case "warn":
+        console.warn(`[MultiWrite] ${message}`);
+        break;
+      case "throw":
+        throw new errors.DatabasePackageError(message, errors$1.ERROR_CODES.DB_UPDATE_FAILED);
+    }
+  }
+};
+var EMA_EXISTING_WEIGHT = 0.8;
+var EMA_NEW_WEIGHT = 0.2;
+var MultiReadAdapter = class {
+  static {
+    __name(this, "MultiReadAdapter");
+  }
+  baseAdapter;
+  config;
+  currentReadIndex = 0;
+  replicaHealth = /* @__PURE__ */ new Map();
+  healthCheckTimer;
+  constructor(baseAdapter, config) {
+    this.baseAdapter = baseAdapter;
+    this.config = {
+      strategy: "round-robin",
+      fallbackToPrimary: true,
+      healthCheckInterval: 3e4,
+      maxFailures: 3,
+      ...config
+    };
+    this.initializeHealthTracking();
+    if (this.config.adapters.length > 0) {
+      this.startHealthChecks();
+    }
+  }
+  async initialize() {
+    return this.baseAdapter.initialize();
+  }
+  async close() {
+    this.stopHealthChecks();
+    return this.baseAdapter.close();
+  }
+  async connect() {
+    await this.baseAdapter.connect();
+    for (const replica of this.config.adapters) {
+      if (typeof replica.connect === "function") {
+        await replica.connect();
+      }
+    }
+  }
+  async disconnect() {
+    await this.baseAdapter.disconnect();
+    for (const replica of this.config.adapters) {
+      if (typeof replica.disconnect === "function") {
+        await replica.disconnect();
+      }
+    }
+  }
+  getClient() {
+    return this.baseAdapter.getClient();
+  }
+  async query(sql2, params) {
+    return this.baseAdapter.query(sql2, params);
+  }
+  registerTable(name, table, idColumn) {
+    this.baseAdapter.registerTable(name, table, idColumn);
+    for (const replica of this.config.adapters) {
+      if (typeof replica.registerTable === "function") {
+        replica.registerTable(name, table, idColumn);
+      }
+    }
+  }
+  // Read operations - use replicas with load balancing
+  async findById(table, id) {
+    return this.readFromReplicas((adapter) => adapter.findById(table, id));
+  }
+  async findMany(table, options) {
+    return this.readFromReplicas(
+      (adapter) => adapter.findMany(table, options)
+    );
+  }
+  async exists(table, id) {
+    return this.readFromReplicas((adapter) => adapter.exists(table, id));
+  }
+  async count(table, filter) {
+    return this.readFromReplicas((adapter) => adapter.count(table, filter));
+  }
+  // Write operations - always use primary
+  async create(table, data) {
+    return this.baseAdapter.create(table, data);
+  }
+  async update(table, id, data) {
+    return this.baseAdapter.update(table, id, data);
+  }
+  async delete(table, id) {
+    return this.baseAdapter.delete(table, id);
+  }
+  async transaction(callback) {
+    return this.baseAdapter.transaction(callback);
+  }
+  async healthCheck() {
+    return this.baseAdapter.healthCheck();
+  }
+  /**
+   * Read from replica adapters using configured strategy
+   */
+  async readFromReplicas(fn) {
+    const healthyReplicas = this.config.adapters.filter(
+      (adapter) => this.isReplicaHealthy(adapter)
+    );
+    if (healthyReplicas.length === 0) {
+      if (this.config.fallbackToPrimary) {
+        return fn(this.baseAdapter);
+      }
+      return failure(
+        new errors.DatabasePackageError(
+          "No healthy read replicas available",
+          errors$1.ERROR_CODES.DB_CONNECTION_FAILED
+        )
+      );
+    }
+    const selectedReplica = this.selectReplica(healthyReplicas);
+    const startTime = Date.now();
     try {
-      await this.redis.del(key);
-      return success();
+      const result = await fn(selectedReplica);
+      this.updateHealthMetrics(selectedReplica, true, Date.now() - startTime);
+      if (result.success) {
+        return result;
+      }
+      if (this.config.fallbackToPrimary) {
+        this.updateHealthMetrics(
+          selectedReplica,
+          false,
+          Date.now() - startTime
+        );
+        return fn(this.baseAdapter);
+      }
+      return result;
     } catch (error) {
+      this.updateHealthMetrics(selectedReplica, false, Date.now() - startTime);
+      if (this.config.fallbackToPrimary) {
+        return fn(this.baseAdapter);
+      }
       return failure(
-        new errors.DatabaseError(
-          "Cache delete failed",
-          errors$1.DATABASE_ERROR_CODES.CACHE_DELETE_FAILED,
-          {
-            context: {
-              source: "RedisCache.del",
-              key,
-              cause: error
-            }
-          }
+        new errors.DatabasePackageError(
+          `Read from replica failed: ${error.message}`,
+          errors$1.ERROR_CODES.DB_QUERY_FAILED,
+          { cause: error }
         )
       );
     }
   }
   /**
-   * Invalidates all cache entries matching a pattern.
-   * Useful for clearing related cache entries when data changes.
-   *
-   * @param pattern Redis key pattern (e.g., 'users:*')
-   * @returns DatabaseResult indicating operation success
+   * Select a replica based on load balancing strategy
+   */
+  selectReplica(replicas) {
+    switch (this.config.strategy) {
+      case "round-robin":
+        this.currentReadIndex = (this.currentReadIndex + 1) % replicas.length;
+        return replicas[this.currentReadIndex];
+      case "random":
+        return replicas[Math.floor(Math.random() * replicas.length)];
+      case "fastest":
+        return replicas.reduce((fastest, current) => {
+          const fastestHealth = this.replicaHealth.get(fastest);
+          const currentHealth = this.replicaHealth.get(current);
+          if (!fastestHealth || !currentHealth) return fastest;
+          return currentHealth.avgResponseTime < fastestHealth.avgResponseTime ? current : fastest;
+        });
+      case "least-conn":
+        return this.selectReplica(
+          replicas.filter((r) => this.isReplicaHealthy(r))
+        );
+      default:
+        return replicas[0];
+    }
+  }
+  /**
+   * Initialize health tracking for all replicas
+   */
+  initializeHealthTracking() {
+    for (const adapter of this.config.adapters) {
+      this.replicaHealth.set(adapter, {
+        adapter,
+        isHealthy: true,
+        failureCount: 0,
+        lastChecked: Date.now(),
+        avgResponseTime: 0
+      });
+    }
+  }
+  /**
+   * Update health metrics for a replica
+   */
+  updateHealthMetrics(adapter, success2, responseTime) {
+    const health = this.replicaHealth.get(adapter);
+    if (!health) return;
+    if (success2) {
+      health.failureCount = 0;
+      health.isHealthy = true;
+      health.avgResponseTime = health.avgResponseTime * EMA_EXISTING_WEIGHT + responseTime * EMA_NEW_WEIGHT;
+    } else {
+      health.failureCount++;
+      if (health.failureCount >= this.config.maxFailures) {
+        health.isHealthy = false;
+      }
+    }
+    health.lastChecked = Date.now();
+  }
+  /**
+   * Check if replica is healthy
+   */
+  isReplicaHealthy(adapter) {
+    const health = this.replicaHealth.get(adapter);
+    return health?.isHealthy ?? true;
+  }
+  /**
+   * Start health check interval
+   */
+  startHealthChecks() {
+    this.healthCheckTimer = setInterval(async () => {
+      for (const adapter of this.config.adapters) {
+        const startTime = Date.now();
+        try {
+          const result = await adapter.healthCheck();
+          const responseTime = Date.now() - startTime;
+          this.updateHealthMetrics(adapter, result.success, responseTime);
+        } catch {
+          this.updateHealthMetrics(adapter, false, Date.now() - startTime);
+        }
+      }
+    }, this.config.healthCheckInterval);
+  }
+  /**
+   * Stop health checks
+   */
+  stopHealthChecks() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
+  }
+  /**
+   * Get health status of all replicas
+   */
+  getHealthStatus() {
+    const status = {};
+    let index = 0;
+    for (const [, health] of this.replicaHealth.entries()) {
+      status[`replica-${index++}`] = health;
+    }
+    return status;
+  }
+  /**
+   * Cleanup resources
+   */
+  dispose() {
+    this.stopHealthChecks();
+    this.replicaHealth.clear();
+  }
+};
+var USE_REPLICA_KEY = "use_replica";
+function UseReplica(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(USE_REPLICA_KEY, options)(target, propertyKey, descriptor);
+  };
+}
+__name(UseReplica, "UseReplica");
+var RedisCache = class {
+  static {
+    __name(this, "RedisCache");
+  }
+  redis;
+  defaultTTL;
+  // Using shared logger instance from @plyaz/logger
+  /**
+   * Creates a new RedisCache instance.
+   * @param config Redis configuration
    *
    * @example
    * ```typescript
-   * // Invalidate all user-related caches
-   * await cache.invalidatePattern('users:*');
+   * // Basic configuration
+   * const cache = new RedisCache({
+   *   url: 'redis://localhost:6379'
+   * });
    *
-   * // Invalidate all caches for a specific category
-   * await cache.invalidatePattern('products:category:electronics:*');
+   * // With custom default TTL
+   * const cacheWithCustomTTL = new RedisCache({
+   *   url: 'redis://localhost:6379',
+   *   defaultTTL: 1800 // 30 minutes
+   * });
    *
-   * // Invalidate all session caches
-   * await cache.invalidatePattern('session:*');
+   * // Production configuration with options
+   * const productionCache = new RedisCache({
+   *   url: 'redis://redis-cluster.example.com:6379',
+   *   defaultTTL: 3600,
+   *   // Additional Redis options can be passed here
+   * });
+   * ```
+   */
+  constructor(config$1) {
+    this.redis = new ioredis.Redis(config$1.url);
+    this.defaultTTL = config$1.defaultTTL ?? config.NUMERIX.THIRTY_SIX_HUNDERD;
+  }
+  /**
+   * Retrieves a value from cache by key.
+   * Automatically handles JSON deserialization.
    *
-   * // Invalidate all caches for a tenant
-   * await cache.invalidatePattern(`tenant:${tenantId}:*`);
+   * @param key Cache key
+   * @returns DatabaseResult containing cached value or null if not found
    *
-   * // Invalidate all analytics caches
-   * await cache.invalidatePattern('analytics:*');
+   * @example
+   * ```typescript
+   * // Get user profile
+   * const result = await cache.get<UserProfile>('profile:123');
+   * if (result.success && result.value) {
+   *   console.log('User:', result.value.name);
+   * } else {
+   *   console.log('Profile not found or cache error');
+   * }
+   *
+   * // Get product list
+   * const products = await cache.get<Product[]>('products:featured');
+   * if (products.success && products.value) {
+   *   products.value.forEach(product => {
+   *     console.log(product.name, product.price);
+   *   });
+   * }
    * ```
    */
-  async invalidatePattern(pattern) {
+  async get(key) {
     try {
-      const keys = await this.redis.keys(pattern);
-      if (keys.length > 0) {
-        await this.redis.del(...keys);
+      const value = await this.redis.get(key);
+      if (!value) {
+        return success();
+      }
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object") {
+        return success(parsed);
       }
       return success();
     } catch (error) {
       return failure(
         new errors.DatabaseError(
-          "Cache invalidate failed",
-          errors$1.DATABASE_ERROR_CODES.CACHE_INVALIDATE_FAILED,
-          {
-            context: {
-              source: "RedisCache.invalidatePattern",
-              pattern,
-              cause: error
-            }
-          }
+          "Cache get failed",
+          errors$1.DATABASE_ERROR_CODES.CACHE_GET_FAILED,
+          { context: { source: "RedisCache.get", key, cause: error } }
         )
       );
     }
   }
   /**
-   * Generates a cache key for database queries.
-   * Creates consistent, URL-safe keys that include table, operation, and parameters.
+   * Sets a value in cache with optional TTL.
+   * Automatically handles JSON serialization.
    *
-   * @param table Database table name
-   * @param operation Database operation type
-   * @param params Query parameters object
-   * @returns Generated cache key
+   * @param key Cache key
+   * @param value Value to cache
+   * @param ttl Time to live in seconds (uses default if not specified)
+   * @returns DatabaseResult indicating operation success
    *
    * @example
    * ```typescript
-   * // Simple key generation
-   * const key = cache.generateKey('users', 'findById', { id: '123' });
-   * // Returns: 'db:users:findById:eyJpYXJhbTAiOiIxMjMifQ=='
+   * // Cache with default TTL
+   * await cache.set('user:123', { id: 123, name: 'John' });
+   *
+   * // Cache with custom TTL (5 minutes)
+   * await cache.set('session:abc123', sessionData, 300);
+   *
+   * // Cache with long TTL for static data
+   * await cache.set('config:app-settings', appSettings, 86400); // 24 hours
+   *
+   * // Cache with short TTL for frequently changing data
+   * await cache.set('metrics:realtime', realtimeData, 60); // 1 minute
+   * ```
+   */
+  async set(key, value, ttl) {
+    try {
+      const ttlValue = ttl ?? this.defaultTTL;
+      await this.redis.set(key, JSON.stringify(value), "EX", ttlValue);
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          "Cache set failed",
+          errors$1.DATABASE_ERROR_CODES.CACHE_SET_FAILED,
+          { context: { source: "RedisCache.set", key, cause: error } }
+        )
+      );
+    }
+  }
+  /**
+   * Deletes a value from cache.
+   *
+   * @param key Cache key
+   * @returns DatabaseResult indicating operation success
+   *
+   * @example
+   * ```typescript
+   * // Delete specific cache entry
+   * await cache.del('user:123');
+   *
+   * // Delete session on logout
+   * await cache.del(`session:${sessionId}`);
+   *
+   * // Delete cached configuration
+   * await cache.del('config:feature-flags');
+   * ```
+   */
+  async del(key) {
+    try {
+      await this.redis.del(key);
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          "Cache delete failed",
+          errors$1.DATABASE_ERROR_CODES.CACHE_DELETE_FAILED,
+          {
+            context: {
+              source: "RedisCache.del",
+              key,
+              cause: error
+            }
+          }
+        )
+      );
+    }
+  }
+  /**
+   * Invalidates all cache entries matching a pattern.
+   * Useful for clearing related cache entries when data changes.
+   *
+   * @param pattern Redis key pattern (e.g., 'users:*')
+   * @returns DatabaseResult indicating operation success
+   *
+   * @example
+   * ```typescript
+   * // Invalidate all user-related caches
+   * await cache.invalidatePattern('users:*');
+   *
+   * // Invalidate all caches for a specific category
+   * await cache.invalidatePattern('products:category:electronics:*');
+   *
+   * // Invalidate all session caches
+   * await cache.invalidatePattern('session:*');
+   *
+   * // Invalidate all caches for a tenant
+   * await cache.invalidatePattern(`tenant:${tenantId}:*`);
+   *
+   * // Invalidate all analytics caches
+   * await cache.invalidatePattern('analytics:*');
+   * ```
+   */
+  async invalidatePattern(pattern) {
+    try {
+      const keys = await this.redis.keys(pattern);
+      if (keys.length > 0) {
+        await this.redis.del(...keys);
+      }
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          "Cache invalidate failed",
+          errors$1.DATABASE_ERROR_CODES.CACHE_INVALIDATE_FAILED,
+          {
+            context: {
+              source: "RedisCache.invalidatePattern",
+              pattern,
+              cause: error
+            }
+          }
+        )
+      );
+    }
+  }
+  /**
+   * Generates a cache key for database queries.
+   * Creates consistent, URL-safe keys that include table, operation, and parameters.
+   *
+   * @param table Database table name
+   * @param operation Database operation type
+   * @param params Query parameters object
+   * @returns Generated cache key
+   *
+   * @example
+   * ```typescript
+   * // Simple key generation
+   * const key = cache.generateKey('users', 'findById', { id: '123' });
+   * // Returns: 'db:users:findById:eyJpYXJhbTAiOiIxMjMifQ=='
    *
    * // Complex query key
    * const complexKey = cache.generateKey('products', 'findMany', {
@@ -8476,6 +10442,655 @@ __name(exports.DataValidationPipe, "DataValidationPipe");
 exports.DataValidationPipe = __decorateClass([
   common.Injectable()
 ], exports.DataValidationPipe);
+var MigrationManager = class {
+  static {
+    __name(this, "MigrationManager");
+  }
+  adapter;
+  migrationsPath;
+  tableName;
+  schema;
+  constructor(config) {
+    this.adapter = config.adapter;
+    this.migrationsPath = path__namespace.resolve(config.migrationsPath ?? "./migrations");
+    this.schema = config.schema ?? "public";
+    this.tableName = this.schema !== "public" ? `${this.schema}.${config.tableName ?? "schema_migrations"}` : config.tableName ?? "schema_migrations";
+  }
+  /**
+   * Initialize migrations table if it doesn't exist
+   */
+  async initialize() {
+    try {
+      const createTableSQL = `
+        CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          version VARCHAR(255) PRIMARY KEY,
+          name VARCHAR(255) NOT NULL,
+          file_path VARCHAR(500),
+          applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          execution_time INTEGER NOT NULL
+        )
+      `;
+      if (typeof this.adapter.query === "function") {
+        await this.adapter.query(createTableSQL);
+        await this.adapter.query(
+          `
+          DO $$
+          BEGIN
+            IF NOT EXISTS (
+              SELECT 1 FROM information_schema.columns
+              WHERE table_name = '${this.tableName.split(".").pop()}'
+              AND column_name = 'file_path'
+            ) THEN
+              ALTER TABLE ${this.tableName} ADD COLUMN file_path VARCHAR(500);
+            END IF;
+          END $$;
+        `
+        ).catch(() => {
+        });
+      }
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to initialize migrations table: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.INIT_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Discover migration files from migrations directory (including subdirectories)
+   */
+  async discoverMigrations() {
+    if (!fs__namespace.existsSync(this.migrationsPath)) {
+      return [];
+    }
+    const migrations = [];
+    const scanDirectory = /* @__PURE__ */ __name((dir) => {
+      const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path__namespace.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          const match = entry.name.match(/^(\d+)_(.+)\.(ts|js|sql)$/);
+          if (match) {
+            const [, version, name] = match;
+            migrations.push({
+              filePath: fullPath,
+              version,
+              name: name.replace(/_/g, " ")
+            });
+          }
+        }
+      }
+    }, "scanDirectory");
+    scanDirectory(this.migrationsPath);
+    return migrations.sort((a, b) => a.version.localeCompare(b.version));
+  }
+  /**
+   * Parse SQL content to extract UP and DOWN sections
+   */
+  parseSqlSections(sql2) {
+    const hasUpMarker = sql2.includes("-- UP");
+    const hasDownMarker = sql2.includes("-- DOWN");
+    if (hasUpMarker && hasDownMarker) {
+      const parts = sql2.split("-- DOWN");
+      return {
+        upSQL: parts[0].replace("-- UP", "").trim(),
+        downSQL: parts[1].trim()
+      };
+    }
+    if (hasDownMarker) {
+      const parts = sql2.split("-- DOWN");
+      return {
+        upSQL: parts[0].trim(),
+        downSQL: parts[1].trim()
+      };
+    }
+    return { upSQL: sql2.trim(), downSQL: null };
+  }
+  /**
+   * Load SQL migration from file
+   */
+  loadSqlMigration(migrationFile) {
+    const sql2 = fs__namespace.readFileSync(migrationFile.filePath, "utf-8");
+    const { upSQL, downSQL } = this.parseSqlSections(sql2);
+    return {
+      version: migrationFile.version,
+      name: migrationFile.name,
+      up: /* @__PURE__ */ __name(async (adapter) => {
+        if (typeof adapter.query === "function") {
+          await adapter.query(upSQL);
+        }
+      }, "up"),
+      down: /* @__PURE__ */ __name(async (adapter) => {
+        if (downSQL && typeof adapter.query === "function") {
+          await adapter.query(downSQL);
+        } else {
+          console.warn(
+            `[Migrations] No DOWN migration for ${migrationFile.version}`
+          );
+        }
+      }, "down")
+    };
+  }
+  /**
+   * Load TypeScript/JavaScript migration from file
+   */
+  async loadJsMigration(migrationFile) {
+    const importPath = migrationFile.filePath.startsWith("/") ? migrationFile.filePath : new URL(`file:///${migrationFile.filePath.replace(/\\/g, "/")}`).href;
+    const migrationModule = await import(importPath);
+    return {
+      version: migrationFile.version,
+      name: migrationFile.name,
+      up: migrationModule.up ?? migrationModule.default?.up,
+      down: migrationModule.down ?? migrationModule.default?.down
+    };
+  }
+  /**
+   * Load migration from file
+   */
+  async loadMigration(migrationFile) {
+    const ext = path__namespace.extname(migrationFile.filePath);
+    switch (ext) {
+      case ".sql":
+        return this.loadSqlMigration(migrationFile);
+      case ".ts":
+      case ".js":
+        return this.loadJsMigration(migrationFile);
+      default:
+        throw new errors.DatabaseError(
+          `Unsupported migration file extension: ${ext}`,
+          errors$1.DATABASE_ERROR_CODES.INVALID_PARAMETERS,
+          { cause: new Error(`Unsupported extension: ${ext}`) }
+        );
+    }
+  }
+  /**
+   * Get applied migrations from database
+   */
+  async getAppliedMigrations() {
+    try {
+      if (typeof this.adapter.query === "function") {
+        const result = await this.adapter.query(
+          `SELECT * FROM ${this.tableName} ORDER BY version ASC`
+        );
+        return Array.isArray(result) ? result : result.rows || [];
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Record migration as applied
+   */
+  async recordMigration(version, name, executionTime, filePath) {
+    if (typeof this.adapter.query === "function") {
+      const relativePath = filePath ? path__namespace.relative(this.migrationsPath, filePath) : null;
+      await this.adapter.query(
+        `INSERT INTO ${this.tableName} (version, name, file_path, execution_time) VALUES ($1, $2, $3, $4)`,
+        [version, name, relativePath, executionTime]
+      );
+    }
+  }
+  /**
+   * Remove migration record (for rollback)
+   */
+  async unrecordMigration(version) {
+    if (typeof this.adapter.query === "function") {
+      await this.adapter.query(
+        `DELETE FROM ${this.tableName} WHERE version = $1`,
+        [version]
+      );
+    }
+  }
+  /**
+   * Get migration status (applied and pending)
+   */
+  async status() {
+    try {
+      await this.initialize();
+      const allMigrations = await this.discoverMigrations();
+      const appliedMigrations = await this.getAppliedMigrations();
+      const appliedVersions = new Set(appliedMigrations.map((m) => m.version));
+      const pending = allMigrations.filter((m) => !appliedVersions.has(m.version)).map((m) => `${m.version}_${m.name}`);
+      return success({
+        applied: appliedMigrations,
+        pending
+      });
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to get migration status: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Run all pending migrations
+   */
+  async up(targetVersion) {
+    try {
+      await this.initialize();
+      const allMigrations = await this.discoverMigrations();
+      const appliedMigrations = await this.getAppliedMigrations();
+      const appliedVersions = new Set(appliedMigrations.map((m) => m.version));
+      let applied = 0;
+      for (const migrationFile of allMigrations) {
+        if (appliedVersions.has(migrationFile.version)) {
+          continue;
+        }
+        if (targetVersion && migrationFile.version > targetVersion) {
+          break;
+        }
+        console.log(
+          `[Migrations] Applying ${migrationFile.version}_${migrationFile.name}...`
+        );
+        const migration = await this.loadMigration(migrationFile);
+        const startTime = Date.now();
+        if (typeof this.adapter.transaction === "function") {
+          await this.adapter.transaction(async () => {
+            await migration.up(this.adapter);
+          });
+        } else {
+          await migration.up(this.adapter);
+        }
+        const executionTime = Date.now() - startTime;
+        await this.recordMigration(
+          migration.version,
+          migration.name,
+          executionTime,
+          migrationFile.filePath
+        );
+        console.log(
+          `[Migrations] Applied ${migration.version} in ${executionTime}ms`
+        );
+        applied++;
+      }
+      return success(applied);
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Migration failed: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Rollback last migration or rollback to specific version
+   */
+  async down(steps = 1) {
+    try {
+      const appliedMigrations = await this.getAppliedMigrations();
+      if (appliedMigrations.length === 0) {
+        return success(0);
+      }
+      const toRollback = appliedMigrations.slice(-steps).reverse();
+      let rolledBack = 0;
+      for (const appliedMigration of toRollback) {
+        console.log(
+          `[Migrations] Rolling back ${appliedMigration.version}_${appliedMigration.name}...`
+        );
+        const allMigrations = await this.discoverMigrations();
+        const migrationFile = allMigrations.find(
+          (m) => m.version === appliedMigration.version
+        );
+        if (!migrationFile) {
+          console.warn(
+            `[Migrations] Migration file not found for version ${appliedMigration.version}`
+          );
+          continue;
+        }
+        const migration = await this.loadMigration(migrationFile);
+        const startTime = Date.now();
+        if (typeof this.adapter.transaction === "function") {
+          await this.adapter.transaction(async () => {
+            await migration.down(this.adapter);
+          });
+        } else {
+          await migration.down(this.adapter);
+        }
+        const executionTime = Date.now() - startTime;
+        await this.unrecordMigration(appliedMigration.version);
+        console.log(
+          `[Migrations] Rolled back ${appliedMigration.version} in ${executionTime}ms`
+        );
+        rolledBack++;
+      }
+      return success(rolledBack);
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Rollback failed: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Reset database (rollback all migrations)
+   */
+  async reset() {
+    const appliedMigrations = await this.getAppliedMigrations();
+    return this.down(appliedMigrations.length);
+  }
+  /**
+   * Clear migration history (delete all records from tracking table)
+   *
+   * Use this to force fresh migrations in test/development environments
+   * without rolling back actual database changes.
+   *
+   * @example
+   * ```typescript
+   * // Clear history and re-run all migrations
+   * await migrationManager.clearHistory();
+   * await migrationManager.up();
+   * ```
+   */
+  async clearHistory() {
+    try {
+      if (typeof this.adapter.query === "function") {
+        await this.adapter.query(`DELETE FROM ${this.tableName}`);
+      }
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to clear migration history: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+};
+var SeedManager = class {
+  static {
+    __name(this, "SeedManager");
+  }
+  adapter;
+  seedsPath;
+  tableName;
+  schema;
+  skipExisting;
+  constructor(config) {
+    this.adapter = config.adapter;
+    this.seedsPath = path__namespace.resolve(config.seedsPath ?? "./seeds");
+    this.schema = config.schema ?? "public";
+    this.tableName = this.schema !== "public" ? `${this.schema}.${config.tableName ?? "seed_history"}` : config.tableName ?? "seed_history";
+    this.skipExisting = config.skipExisting ?? false;
+  }
+  /**
+   * Initialize seeds tracking table if it doesn't exist
+   */
+  async initialize() {
+    try {
+      const createTableSQL = `
+        CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          name VARCHAR(255) PRIMARY KEY,
+          file_path VARCHAR(500),
+          run_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          execution_time INTEGER NOT NULL
+        )
+      `;
+      if (typeof this.adapter.query === "function") {
+        await this.adapter.query(createTableSQL);
+        await this.adapter.query(
+          `
+          DO $$
+          BEGIN
+            IF NOT EXISTS (
+              SELECT 1 FROM information_schema.columns
+              WHERE table_name = '${this.tableName.split(".").pop()}'
+              AND column_name = 'file_path'
+            ) THEN
+              ALTER TABLE ${this.tableName} ADD COLUMN file_path VARCHAR(500);
+            END IF;
+          END $$;
+        `
+        ).catch(() => {
+        });
+      }
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to initialize seeds table: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.INIT_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Discover seed files from seeds directory
+   */
+  async discoverSeeds() {
+    if (!fs__namespace.existsSync(this.seedsPath)) {
+      return [];
+    }
+    const files = fs__namespace.readdirSync(this.seedsPath);
+    const seeds = [];
+    for (const file of files) {
+      const match = file.match(/^(\d+)_(.+)\.(ts|js)$/);
+      if (match) {
+        const [, order, name] = match;
+        seeds.push({
+          filePath: path__namespace.join(this.seedsPath, file),
+          order: Number.parseInt(order, 10),
+          name
+        });
+      }
+    }
+    return seeds.sort((a, b) => a.order - b.order);
+  }
+  /**
+   * Load seed from file
+   */
+  async loadSeed(seedFile) {
+    const importPath = seedFile.filePath.startsWith("/") ? seedFile.filePath : new URL(`file:///${seedFile.filePath.replace(/\\/g, "/")}`).href;
+    const seedModule = await import(importPath);
+    return {
+      name: seedFile.name,
+      run: seedModule.run ?? seedModule.default?.run ?? seedModule.seed ?? seedModule.default,
+      cleanup: seedModule.cleanup ?? seedModule.default?.cleanup
+    };
+  }
+  /**
+   * Get executed seeds from database
+   */
+  async getExecutedSeeds() {
+    try {
+      if (typeof this.adapter.query === "function") {
+        const result = await this.adapter.query(
+          `SELECT * FROM ${this.tableName} ORDER BY run_at ASC`
+        );
+        return Array.isArray(result) ? result : result.rows || [];
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Record seed as executed
+   */
+  async recordSeed(name, executionTime, filePath) {
+    if (typeof this.adapter.query === "function") {
+      const relativePath = filePath ? path__namespace.relative(this.seedsPath, filePath) : null;
+      await this.adapter.query(
+        `INSERT INTO ${this.tableName} (name, file_path, execution_time) VALUES ($1, $2, $3)
+         ON CONFLICT (name) DO UPDATE SET run_at = CURRENT_TIMESTAMP, file_path = $2, execution_time = $3`,
+        [name, relativePath, executionTime]
+      );
+    }
+  }
+  /**
+   * Remove seed record (for reset)
+   */
+  async unrecordSeed(name) {
+    if (typeof this.adapter.query === "function") {
+      await this.adapter.query(
+        `DELETE FROM ${this.tableName} WHERE name = $1`,
+        [name]
+      );
+    }
+  }
+  /**
+   * Execute a seed function with optional transaction support
+   */
+  async executeSeed(seed) {
+    if (typeof this.adapter.transaction === "function") {
+      await this.adapter.transaction(async () => {
+        await seed.run(this.adapter);
+      });
+    } else {
+      await seed.run(this.adapter);
+    }
+  }
+  /**
+   * Check if a seed should be skipped and log if applicable
+   */
+  shouldSkipSeed(seedFile, seedName, executedNames) {
+    if (seedName && seedFile.name !== seedName) return true;
+    if (this.skipExisting && executedNames.has(seedFile.name)) {
+      console.log(`[Seeds] Skipping ${seedFile.name} (already executed)`);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Run all seeds or a specific seed
+   */
+  async run(seedName) {
+    try {
+      await this.initialize();
+      const allSeeds = await this.discoverSeeds();
+      const executedSeeds = await this.getExecutedSeeds();
+      const executedNames = new Set(executedSeeds.map((s) => s.name));
+      let executed = 0;
+      for (const seedFile of allSeeds) {
+        if (this.shouldSkipSeed(seedFile, seedName, executedNames)) {
+          continue;
+        }
+        console.log(`[Seeds] Running ${seedFile.name}...`);
+        const seed = await this.loadSeed(seedFile);
+        const startTime = Date.now();
+        await this.executeSeed(seed);
+        const executionTime = Date.now() - startTime;
+        await this.recordSeed(seed.name, executionTime, seedFile.filePath);
+        console.log(`[Seeds] Executed ${seed.name} in ${executionTime}ms`);
+        executed++;
+        if (seedName) break;
+      }
+      return success(executed);
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Seed execution failed: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Execute cleanup function with optional transaction support
+   */
+  async executeCleanup(seed) {
+    if (!seed.cleanup) return;
+    if (typeof this.adapter.transaction === "function") {
+      await this.adapter.transaction(async () => {
+        await seed.cleanup(this.adapter);
+      });
+    } else {
+      await seed.cleanup(this.adapter);
+    }
+  }
+  /**
+   * Reset all seeds (run cleanup functions)
+   */
+  async reset() {
+    try {
+      const allSeeds = await this.discoverSeeds();
+      let cleaned = 0;
+      for (const seedFile of allSeeds.reverse()) {
+        console.log(`[Seeds] Cleaning up ${seedFile.name}...`);
+        const seed = await this.loadSeed(seedFile);
+        if (!seed.cleanup) {
+          console.warn(`[Seeds] No cleanup function for ${seed.name}`);
+          continue;
+        }
+        const startTime = Date.now();
+        await this.executeCleanup(seed);
+        const executionTime = Date.now() - startTime;
+        await this.unrecordSeed(seed.name);
+        console.log(`[Seeds] Cleaned ${seed.name} in ${executionTime}ms`);
+        cleaned++;
+      }
+      return success(cleaned);
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Seed cleanup failed: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Get seed execution status
+   */
+  async status() {
+    try {
+      await this.initialize();
+      const allSeeds = await this.discoverSeeds();
+      const executedSeeds = await this.getExecutedSeeds();
+      const executedNames = new Set(executedSeeds.map((s) => s.name));
+      const pending = allSeeds.filter((s) => !executedNames.has(s.name)).map((s) => s.name);
+      return success({
+        executed: executedSeeds,
+        pending
+      });
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to get seed status: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+  /**
+   * Clear seed history (doesn't clean data, just removes tracking records)
+   */
+  async clearHistory() {
+    try {
+      if (typeof this.adapter.query === "function") {
+        await this.adapter.query(`DELETE FROM ${this.tableName}`);
+      }
+      return success();
+    } catch (error) {
+      return failure(
+        new errors.DatabaseError(
+          `Failed to clear seed history: ${error.message}`,
+          errors$1.DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        )
+      );
+    }
+  }
+};
 
 exports.AdapterFactory = AdapterFactory;
 exports.AlertManager = AlertManager;
@@ -8493,9 +11108,14 @@ exports.DynamicPool = DynamicPool;
 exports.EncryptionAdapter = EncryptionAdapter;
 exports.HealthManager = HealthManager;
 exports.MetricsCollector = MetricsCollector;
+exports.MigrationManager = MigrationManager;
+exports.MockAdapter = MockAdapter;
+exports.MultiReadAdapter = MultiReadAdapter;
+exports.MultiWriteAdapter = MultiWriteAdapter;
 exports.ReadReplicaAdapter = ReadReplicaAdapter;
 exports.RedisCache = RedisCache;
 exports.SQLAdapter = SQLAdapter;
+exports.SeedManager = SeedManager;
 exports.ShardKeyManager = ShardKeyManager;
 exports.ShardRouter = ShardRouter;
 exports.SoftDeleteAdapter = SoftDeleteAdapter;