@zhin.js/database 1.0.3 → 1.0.5

package/src/dialects/mysql.ts

@@ -1,28 +1,50 @@
-import {Dialect} from '../base';
-import {RelatedDatabase} from "../type/related/database";
-import {Registry} from "../registry";
-import type { ConnectionOptions } from 'mysql2/promise';
-import {Database} from "../base";
-import {Column} from "../types";
+import {Dialect} from '../base/index.js';
+import {RelatedDatabase} from "../type/related/database.js";
+import {Registry} from "../registry.js";
+import type { ConnectionOptions, PoolOptions } from 'mysql2/promise';
+import {Database} from "../base/index.js";
+import {Column, Transaction, TransactionOptions, IsolationLevel, PoolConfig} from "../types.js";
 
-export interface MySQLDialectConfig extends ConnectionOptions {}
+export interface MySQLDialectConfig extends ConnectionOptions {
+  /**
+   * 连接池配置
+   * 如果提供此选项，将使用连接池而不是单连接
+   */
+  pool?: PoolConfig;
+}
 
-export class MySQLDialect extends Dialect<MySQLDialectConfig, string> {
+export class MySQLDialect<S extends Record<string, object> = Record<string, object>> extends Dialect<MySQLDialectConfig, S, string> {
   private connection: any = null;
+  private pool: any = null;
+  private usePool: boolean = false;
 
   constructor(config: MySQLDialectConfig) {
     super('mysql', config);
+    this.usePool = !!config.pool;
   }
 
   // Connection management
   isConnected(): boolean {
-    return this.connection !== null;
+    return this.usePool ? this.pool !== null : this.connection !== null;
   }
 
   async connect(): Promise<void> {
     try {
+      if (this.usePool) {
+        const { createPool } = await import('mysql2/promise');
+        const poolConfig: PoolOptions = {
+          ...this.config,
+          waitForConnections: true,
+          connectionLimit: this.config.pool?.max ?? 10,
+          queueLimit: 0,
+          idleTimeout: this.config.pool?.idleTimeoutMillis ?? 60000,
+        };
+        this.pool = createPool(poolConfig);
+        console.log(`MySQL 连接池已创建 (max: ${poolConfig.connectionLimit})`);
+      } else {
       const { createConnection } = await import('mysql2/promise');
       this.connection = await createConnection(this.config);
+      }
     } catch (error) {
       console.error('forgot install mysql2 ?');
       throw new Error(`MySQL 连接失败: ${error}`);
@@ -30,23 +52,50 @@ export class MySQLDialect extends Dialect<MySQLDialectConfig, string> {
   }
 
   async disconnect(): Promise<void> {
+    if (this.usePool && this.pool) {
+      await this.pool.end();
+      this.pool = null;
+      console.log('MySQL 连接池已关闭');
+    } else if (this.connection) {
+      await this.connection.end();
     this.connection = null;
+    }
   }
 
   async healthCheck(): Promise<boolean> {
-    return this.isConnected();
+    if (!this.isConnected()) return false;
+    try {
+      await this.query('SELECT 1');
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   async query<U = any>(sql: string, params?: any[]): Promise<U> {
+    if (this.usePool) {
+      const [rows] = await this.pool.execute(sql, params);
+      return rows as U;
+    } else {
     const [rows] = await this.connection.execute(sql, params);
     return rows as U;
+    }
   }
 
   async dispose(): Promise<void> {
-    if (this.connection) {
-      await this.connection.end();
-      this.connection = null;
-    }
+    await this.disconnect();
+  }
+  
+  /**
+   * 获取连接池统计信息（仅在使用连接池时有效）
+   */
+  getPoolStats(): { total: number; idle: number; waiting: number } | null {
+    if (!this.usePool || !this.pool) return null;
+    return {
+      total: this.pool.pool?._allConnections?.length ?? 0,
+      idle: this.pool.pool?._freeConnections?.length ?? 0,
+      waiting: this.pool.pool?._connectionQueue?.length ?? 0,
+    };
   }
 
   // SQL generation methods
@@ -118,8 +167,8 @@ export class MySQLDialect extends Dialect<MySQLDialectConfig, string> {
     return `LIMIT ${offset}, ${limit}`;
   }
 
-  formatCreateTable(tableName: string, columns: string[]): string {
-    return `CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(tableName)} (${columns.join(', ')}) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`;
+  formatCreateTable<T extends keyof S>(tableName: T, columns: string[]): string {
+    return `CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(String(tableName))} (${columns.join(', ')}) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`;
   }
 
   formatColumnDefinition(field: string, column: Column<any>): string {
@@ -137,21 +186,101 @@ export class MySQLDialect extends Dialect<MySQLDialectConfig, string> {
     return `${name} ${type}${length}${primary}${unique}${autoIncrement}${nullable}${defaultVal}`;
   }
 
-  formatAlterTable(tableName: string, alterations: string[]): string {
-    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ${alterations.join(', ')}`;
+  formatAlterTable<T extends keyof S>(tableName: T, alterations: string[]): string {
+    return `ALTER TABLE ${this.quoteIdentifier(String(tableName))} ${alterations.join(', ')}`;
   }
 
-  formatDropTable(tableName: string, ifExists?: boolean): string {
+  formatDropTable<T extends keyof S>(tableName: T, ifExists?: boolean): string {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
-    return `DROP TABLE ${ifExistsClause}${this.quoteIdentifier(tableName)}`;
+    return `DROP TABLE ${ifExistsClause}${this.quoteIdentifier(String(tableName))}`;
   }
 
-  formatDropIndex(indexName: string, tableName: string, ifExists?: boolean): string {
+  formatDropIndex<T extends keyof S>(indexName: string, tableName: T, ifExists?: boolean): string {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
-    return `DROP INDEX ${ifExistsClause}${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}`;
+    return `DROP INDEX ${ifExistsClause}${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(String(tableName))}`;
+  }
+  
+  // ============================================================================
+  // Transaction Support
+  // ============================================================================
+  
+  /**
+   * MySQL 支持事务
+   */
+  supportsTransactions(): boolean {
+    return true;
+  }
+  
+  /**
+   * 开始事务
+   * 在连接池模式下，会获取一个专用连接用于事务
+   */
+  async beginTransaction(options?: TransactionOptions): Promise<Transaction> {
+    if (this.usePool) {
+      // 从连接池获取一个连接用于事务
+      const connection = await this.pool.getConnection();
+      
+      // 设置隔离级别
+      if (options?.isolationLevel) {
+        await connection.execute(`SET TRANSACTION ISOLATION LEVEL ${this.formatIsolationLevel(options.isolationLevel)}`);
+      }
+      
+      // 开始事务
+      await connection.execute('START TRANSACTION');
+      
+      return {
+        async commit(): Promise<void> {
+          try {
+            await connection.execute('COMMIT');
+          } finally {
+            connection.release(); // 归还连接到池
+          }
+        },
+        
+        async rollback(): Promise<void> {
+          try {
+            await connection.execute('ROLLBACK');
+          } finally {
+            connection.release(); // 归还连接到池
+          }
+        },
+        
+        async query<T = any>(sql: string, params?: any[]): Promise<T> {
+          const [rows] = await connection.execute(sql, params);
+          return rows as T;
+        }
+      };
+    } else {
+      // 单连接模式
+      const dialect = this;
+      
+      // 设置隔离级别
+      if (options?.isolationLevel) {
+        await this.query(`SET TRANSACTION ISOLATION LEVEL ${this.formatIsolationLevel(options.isolationLevel)}`);
+      }
+      
+      // 开始事务
+      await this.query('START TRANSACTION');
+      
+      return {
+        async commit(): Promise<void> {
+          await dialect.query('COMMIT');
+        },
+        
+        async rollback(): Promise<void> {
+          await dialect.query('ROLLBACK');
+        },
+        
+        async query<T = any>(sql: string, params?: any[]): Promise<T> {
+          return dialect.query<T>(sql, params);
+        }
+      };
+    }
   }
 }
-
-Registry.register('mysql', (config: MySQLDialectConfig, definitions?: Database.Definitions<Record<string, object>>) => {
-  return new RelatedDatabase(new MySQLDialect(config), definitions);
-});
+export class MySQL<S extends Record<string, object> = Record<string, object>> extends RelatedDatabase<MySQLDialectConfig, S> {
+  constructor(config: MySQLDialectConfig, definitions?: Database.DefinitionObj<S>) {
+    super(new MySQLDialect<S>(config), definitions);
+  }
+}
+Registry.register('mysql', MySQL);

package/src/dialects/pg.ts

@@ -1,29 +1,51 @@
-import {Dialect} from '../base';
-import {RelatedDatabase} from "../type/related/database";
-import {Database} from "../base";
-import {Registry} from "../registry";
-import type { ClientConfig } from 'pg';
-import {Column} from "../types";
+import {Dialect} from '../base/index.js';
+import {RelatedDatabase} from "../type/related/database.js";
+import {Database} from "../base/index.js";
+import {Registry} from "../registry.js";
+import type { ClientConfig, PoolConfig as PgPoolConfig } from 'pg';
+import {Column, Transaction, TransactionOptions, PoolConfig} from "../types.js";
 
-export interface PostgreSQLDialectConfig extends ClientConfig {}
+export interface PostgreSQLDialectConfig extends ClientConfig {
+  /**
+   * 连接池配置
+   * 如果提供此选项，将使用连接池而不是单连接
+   */
+  pool?: PoolConfig;
+}
 
-export class PostgreSQLDialect extends Dialect<PostgreSQLDialectConfig, string> {
+export class PostgreSQLDialect<S extends Record<string, object> = Record<string, object>> extends Dialect<PostgreSQLDialectConfig, S, string> {
   private connection: any = null;
+  private pool: any = null;
+  private usePool: boolean = false;
 
   constructor(config: PostgreSQLDialectConfig) {
     super('pg', config);
+    this.usePool = !!config.pool;
   }
 
   // Connection management
   isConnected(): boolean {
-    return this.connection !== null;
+    return this.usePool ? this.pool !== null : this.connection !== null;
   }
 
   async connect(): Promise<void> {
     try {
+      if (this.usePool) {
+        const { Pool } = await import('pg');
+        const poolConfig: PgPoolConfig = {
+          ...this.config,
+          max: this.config.pool?.max ?? 10,
+          min: this.config.pool?.min ?? 2,
+          idleTimeoutMillis: this.config.pool?.idleTimeoutMillis ?? 30000,
+          connectionTimeoutMillis: this.config.pool?.acquireTimeoutMillis ?? 10000,
+        };
+        this.pool = new Pool(poolConfig);
+        console.log(`PostgreSQL 连接池已创建 (max: ${poolConfig.max})`);
+      } else {
       const { Client } = await import('pg');
       this.connection = new Client(this.config);
       await this.connection.connect();
+      }
     } catch (error) {
       console.error('forgot install pg ?');
       throw new Error(`PostgreSQL 连接失败: ${error}`);
@@ -31,23 +53,50 @@ export class PostgreSQLDialect extends Dialect<PostgreSQLDialectConfig, string>
   }
 
   async disconnect(): Promise<void> {
+    if (this.usePool && this.pool) {
+      await this.pool.end();
+      this.pool = null;
+      console.log('PostgreSQL 连接池已关闭');
+    } else if (this.connection) {
+      await this.connection.end();
     this.connection = null;
+    }
   }
 
   async healthCheck(): Promise<boolean> {
-    return this.isConnected();
+    if (!this.isConnected()) return false;
+    try {
+      await this.query('SELECT 1');
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   async query<U = any>(sql: string, params?: any[]): Promise<U> {
+    if (this.usePool) {
+      const result = await this.pool.query(sql, params);
+      return result.rows as U;
+    } else {
     const result = await this.connection.query(sql, params);
     return result.rows as U;
+    }
   }
 
   async dispose(): Promise<void> {
-    if (this.connection) {
-      await this.connection.end();
-      this.connection = null;
-    }
+    await this.disconnect();
+  }
+  
+  /**
+   * 获取连接池统计信息（仅在使用连接池时有效）
+   */
+  getPoolStats(): { total: number; idle: number; waiting: number } | null {
+    if (!this.usePool || !this.pool) return null;
+    return {
+      total: this.pool.totalCount ?? 0,
+      idle: this.pool.idleCount ?? 0,
+      waiting: this.pool.waitingCount ?? 0,
+    };
   }
 
   // SQL generation methods
@@ -119,8 +168,8 @@ export class PostgreSQLDialect extends Dialect<PostgreSQLDialectConfig, string>
     return `LIMIT ${limit} OFFSET ${offset}`;
   }
   
-  formatCreateTable(tableName: string, columns: string[]): string {
-    return `CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(tableName)} (${columns.join(', ')})`;
+  formatCreateTable<T extends keyof S>(tableName: T, columns: string[]): string {
+    return `CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(String(tableName))} (${columns.join(', ')})`;
   }
   
   formatColumnDefinition(field: string, column: Column<any>): string {
@@ -137,21 +186,99 @@ export class PostgreSQLDialect extends Dialect<PostgreSQLDialectConfig, string>
     return `${name} ${type}${length}${primary}${unique}${nullable}${defaultVal}`;
   }
   
-  formatAlterTable(tableName: string, alterations: string[]): string {
-    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ${alterations.join(', ')}`;
+  formatAlterTable<T extends keyof S>(tableName: T, alterations: string[]): string {
+    return `ALTER TABLE ${this.quoteIdentifier(String(tableName))} ${alterations.join(', ')}`;
   }
   
-  formatDropTable(tableName: string, ifExists?: boolean): string {
+  formatDropTable<T extends keyof S>(tableName: T, ifExists?: boolean): string {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
-    return `DROP TABLE ${ifExistsClause}${this.quoteIdentifier(tableName)}`;
+    return `DROP TABLE ${ifExistsClause}${this.quoteIdentifier(String(tableName))}`;
   }
   
-  formatDropIndex(indexName: string, tableName: string, ifExists?: boolean): string {
+  formatDropIndex<T extends keyof S>(indexName: string, tableName: T, ifExists?: boolean): string {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
     return `DROP INDEX ${ifExistsClause}${this.quoteIdentifier(indexName)}`;
   }
+  
+  // ============================================================================
+  // Transaction Support
+  // ============================================================================
+  
+  /**
+   * PostgreSQL 支持事务
+   */
+  supportsTransactions(): boolean {
+    return true;
+  }
+  
+  /**
+   * 开始事务
+   * 在连接池模式下，会获取一个专用连接用于事务
+   */
+  async beginTransaction(options?: TransactionOptions): Promise<Transaction> {
+    if (this.usePool) {
+      // 从连接池获取一个连接用于事务
+      const client = await this.pool.connect();
+      
+      // 开始事务（可以带隔离级别）
+      let beginSql = 'BEGIN';
+      if (options?.isolationLevel) {
+        beginSql = `BEGIN ISOLATION LEVEL ${this.formatIsolationLevel(options.isolationLevel)}`;
+      }
+      await client.query(beginSql);
+      
+      return {
+        async commit(): Promise<void> {
+          try {
+            await client.query('COMMIT');
+          } finally {
+            client.release(); // 归还连接到池
+          }
+        },
+        
+        async rollback(): Promise<void> {
+          try {
+            await client.query('ROLLBACK');
+          } finally {
+            client.release(); // 归还连接到池
+          }
+        },
+        
+        async query<T = any>(sql: string, params?: any[]): Promise<T> {
+          const result = await client.query(sql, params);
+          return result.rows as T;
+        }
+      };
+    } else {
+      // 单连接模式
+      const dialect = this;
+      
+      // 开始事务（可以带隔离级别）
+      let beginSql = 'BEGIN';
+      if (options?.isolationLevel) {
+        beginSql = `BEGIN ISOLATION LEVEL ${this.formatIsolationLevel(options.isolationLevel)}`;
+      }
+      await this.query(beginSql);
+      
+      return {
+        async commit(): Promise<void> {
+          await dialect.query('COMMIT');
+        },
+        
+        async rollback(): Promise<void> {
+          await dialect.query('ROLLBACK');
+        },
+        
+        async query<T = any>(sql: string, params?: any[]): Promise<T> {
+          return dialect.query<T>(sql, params);
+        }
+      };
+    }
+  }
 }
-
-Registry.register('pg', (config: PostgreSQLDialectConfig, definitions?: Database.Definitions<Record<string, object>>) => {
-  return new RelatedDatabase(new PostgreSQLDialect(config), definitions);
-});
+export class PG<S extends Record<string, object> = Record<string, object>> extends RelatedDatabase<PostgreSQLDialectConfig, S> {
+  constructor(config: PostgreSQLDialectConfig, definitions?: Database.DefinitionObj<S>) {
+    super(new PostgreSQLDialect<S>(config), definitions);
+  }
+}
+Registry.register('pg', PG);

package/src/dialects/redis.ts

@@ -1,7 +1,7 @@
-import {Dialect} from "../base";
-import {KeyValueDatabase} from "../type/keyvalue/database";
-import {Registry} from "../registry";
-import {Database} from "../base";
+import {Dialect} from "../base/index.js";
+import {KeyValueDatabase} from "../type/keyvalue/database.js";
+import {Registry} from "../registry.js";
+import {Database} from "../base/index.js";
 import type { RedisClientOptions } from 'redis';
 import { 
   BuildQueryResult, 
@@ -16,10 +16,10 @@ import {
   AlterQueryParams,
   DropTableQueryParams,
   DropIndexQueryParams
-} from "../types";
+} from "../types.js";
 
 export interface RedisDialectConfig extends RedisClientOptions {}
-export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResult> {
+export class RedisDialect<S extends Record<string, object> = Record<string, object>> extends Dialect<RedisDialectConfig, S, KeyValueQueryResult> {
   private client: any = null;
 
   constructor(config: RedisDialectConfig) {
@@ -164,24 +164,24 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
   /**
    * 构建查询
    */
-  buildQuery<U extends object = any>(params: QueryParams<U>): BuildQueryResult<KeyValueQueryResult> {
+  buildQuery<T extends keyof S>(params: QueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     switch (params.type) {
       case 'create':
-        return this.buildCreateQuery(params as CreateQueryParams<U>);
+        return this.buildCreateQuery(params as CreateQueryParams<S, T>);
       case 'select':
-        return this.buildSelectQuery(params as SelectQueryParams<U>);
+        return this.buildSelectQuery(params as SelectQueryParams<S, T>);
       case 'insert':
-        return this.buildInsertQuery(params as InsertQueryParams<U>);
+        return this.buildInsertQuery(params as InsertQueryParams<S, T>);
       case 'update':
-        return this.buildUpdateQuery(params as UpdateQueryParams<U>);
+        return this.buildUpdateQuery(params as UpdateQueryParams<S, T>);
       case 'delete':
-        return this.buildDeleteQuery(params as DeleteQueryParams<U>);
+        return this.buildDeleteQuery(params as DeleteQueryParams<S, T>);
       case 'alter':
-        return this.buildAlterQuery(params as AlterQueryParams<U>);
+        return this.buildAlterQuery(params as AlterQueryParams<S, T>);
       case 'drop_table':
-        return this.buildDropTableQuery(params as DropTableQueryParams<U>);
+        return this.buildDropTableQuery(params as DropTableQueryParams<S, T>);
       case 'drop_index':
-        return this.buildDropIndexQuery(params as DropIndexQueryParams);
+        return this.buildDropIndexQuery(params as DropIndexQueryParams<S, T>);
       default:
         throw new Error(`不支持的查询类型: ${(params as any).type}`);
     }
@@ -236,36 +236,36 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
     return `${limit},${offset}`;
   }
 
-  formatCreateTable(tableName: string, columns: string[]): string {
-    return `CREATE TABLE ${tableName} (${columns.join(',')})`;
+  formatCreateTable(tableName: keyof S, columns: string[]): string {
+    return `CREATE TABLE ${String(tableName)} (${columns.join(',')})`;
   }
 
-  formatAlterTable(tableName: string, alterations: string[]): string {
-    return `ALTER TABLE ${tableName} ${alterations.join(',')}`;
+  formatAlterTable(tableName: keyof S, alterations: string[]): string {
+    return `ALTER TABLE ${String(tableName)} ${alterations.join(',')}`;
   }
 
-  formatDropTable(tableName: string, ifExists?: boolean): string {
-    return `DROP TABLE ${tableName} ${ifExists ? 'IF EXISTS' : ''}`;
+  formatDropTable(tableName: keyof S, ifExists?: boolean): string {
+    return `DROP TABLE ${String(tableName)} ${ifExists ? 'IF EXISTS' : ''}`;
   }
 
-  formatDropIndex(indexName: string, tableName: string, ifExists?: boolean): string {
-    return `DROP INDEX ${indexName} ON ${tableName} ${ifExists ? 'IF EXISTS' : ''}`;
+  formatDropIndex(indexName: string, tableName: keyof S, ifExists?: boolean): string {
+    return `DROP INDEX ${indexName} ON ${String(tableName)} ${ifExists ? 'IF EXISTS' : ''}`;
   }
 
   // Redis 特定的查询构建方法
-  private buildCreateQuery<T extends object>(params: CreateQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildCreateQuery<T extends keyof S>(params: CreateQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     return {
       query: {
-        bucket: params.tableName,
+        bucket: String(params.tableName),
         operation: 'keys'
       },
       params: []
     };
   }
 
-  private buildSelectQuery<T extends object>(params: SelectQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildSelectQuery<T extends keyof S>(params: SelectQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     const query: KeyValueQueryResult = {
-      bucket: params.tableName,
+      bucket: params.tableName as string,
       operation: 'keys'
     };
 
@@ -284,12 +284,12 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
     };
   }
 
-  private buildInsertQuery<T extends object>(params: InsertQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildInsertQuery<T extends keyof S>(params: InsertQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     const key = this.extractKeyFromData(params.data);
     
     return {
       query: {
-        bucket: params.tableName,
+        bucket: params.tableName as string,
         operation: 'set',
         key: key || 'default',
         value: params.data
@@ -298,12 +298,12 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
     };
   }
 
-  private buildUpdateQuery<T extends object>(params: UpdateQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildUpdateQuery<T extends keyof S>(params: UpdateQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     const key = this.extractKeyFromCondition(params.conditions);
     
     return {
       query: {
-        bucket: params.tableName,
+        bucket: params.tableName as string,
         operation: 'set',
         key: key || 'default',
         value: params.update
@@ -312,12 +312,12 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
     };
   }
 
-  private buildDeleteQuery<T extends object>(params: DeleteQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildDeleteQuery<T extends keyof S>(params: DeleteQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     const key = this.extractKeyFromCondition(params.conditions);
     
     return {
       query: {
-        bucket: params.tableName,
+        bucket: params.tableName as string,
         operation: 'delete',
         key: key || 'default'
       },
@@ -325,30 +325,30 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
     };
   }
 
-  private buildAlterQuery<T extends object>(params: AlterQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildAlterQuery<T extends keyof S>(params: AlterQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     return {
       query: {
-        bucket: params.tableName,
+        bucket: params.tableName as string,
         operation: 'keys'
       },
       params: [params.alterations]
     };
   }
 
-  private buildDropTableQuery<T extends object>(params: DropTableQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+  private buildDropTableQuery<T extends keyof S>(params: DropTableQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     return {
       query: {
-        bucket: params.tableName,
+        bucket: params.tableName as string,
         operation: 'clear'
       },
       params: []
     };
   }
 
-  private buildDropIndexQuery(params: DropIndexQueryParams): BuildQueryResult<KeyValueQueryResult> {
+  private buildDropIndexQuery<T extends keyof S>(params: DropIndexQueryParams<S, T>): BuildQueryResult<KeyValueQueryResult> {
     return {
       query: {
-        bucket: params.tableName,
+        bucket: params.tableName as string,
         operation: 'keys'
       },
       params: [params.indexName]
@@ -592,7 +592,9 @@ export class RedisDialect extends Dialect<RedisDialectConfig, KeyValueQueryResul
     };
   }
 }
-
-Registry.register('redis', (config: RedisDialectConfig, definitions?: Database.Definitions<Record<string, object>>) => {
-  return new KeyValueDatabase(new RedisDialect(config), definitions);
-});
+export class Redis<S extends Record<string, object> = Record<string, object>> extends KeyValueDatabase<RedisDialectConfig, S> {
+  constructor(config: RedisDialectConfig, definitions?: Database.DefinitionObj<S>) {
+    super(new RedisDialect<S>(config), definitions);
+  }
+}
+Registry.register('redis', Redis);