@zhin.js/database 1.0.3 → 1.0.5

package/src/base/thenable.ts

@@ -3,17 +3,17 @@ import type { Dialect } from "./dialect.js";
 import { QueryParams } from "../types.js";
 
 
-export abstract class ThenableQuery<T = any,C=any,D=string>
-  implements PromiseLike<T>, AsyncIterable<T>
+export abstract class ThenableQuery<R,S extends Record<string, object>, T extends keyof S,C=any,D=string>
+  implements PromiseLike<R>, AsyncIterable<R>
 {
-  protected constructor(protected readonly database: Database<C,Record<string, object>,D>,protected readonly dialect: Dialect<C,D>) {}
+  protected constructor(protected readonly database: Database<C,S,D>,protected readonly dialect: Dialect<C,S,D>) {}
   
   // Abstract method to get query parameters
-  protected abstract getQueryParams(): QueryParams;
+  protected abstract getQueryParams(): QueryParams<S,T>;
   [Symbol.toStringTag] = 'ThenableQuery';
-  then<TResult1 = T, TResult2 = never>(
+  then<TResult1 = R, TResult2 = never>(
     onfulfilled?:
-      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | ((value: R) => TResult1 | PromiseLike<TResult1>)
       | undefined
       | null,
     onrejected?:
@@ -23,7 +23,8 @@ export abstract class ThenableQuery<T = any,C=any,D=string>
   ): Promise<TResult1 | TResult2> {
     const params = this.getQueryParams();
     const { query, params: queryParams } = this.database.buildQuery(params);
-    return this.dialect.query<T>(query, queryParams).then(onfulfilled, onrejected);
+    // 使用 database.query 以支持日志记录
+    return this.database.query<R>(query, queryParams).then(onfulfilled, onrejected);
   }
   
   catch<TResult = never>(
@@ -34,19 +35,19 @@ export abstract class ThenableQuery<T = any,C=any,D=string>
   ): Promise<any | TResult> {
     const params = this.getQueryParams();
     const { query, params: queryParams } = this.database.buildQuery(params);
-    return this.dialect.query(query, queryParams).catch(onrejected);
+    return this.database.query(query, queryParams).catch(onrejected);
   }
   
   finally(onfinally?: (() => void) | undefined | null): Promise<any> {
     const params = this.getQueryParams();
     const { query, params: queryParams } = this.database.buildQuery(params);
-    return this.dialect.query(query, queryParams).finally(onfinally);
+    return this.database.query(query, queryParams).finally(onfinally);
   }
   
-  async *[Symbol.asyncIterator](): AsyncIterator<T, void, unknown> {
+  async *[Symbol.asyncIterator](): AsyncIterator<R, void, unknown> {
     const params = this.getQueryParams();
     const { query, params: queryParams } = this.database.buildQuery(params);
-    const rows = await this.dialect.query(query, queryParams);
+    const rows = await this.database.query(query, queryParams);
     for (const row of Array.isArray(rows) ? rows : [rows]) {
       yield row;
     }

package/src/base/transaction.ts

@@ -0,0 +1,213 @@
+import { 
+  Transaction, 
+  TransactionContext, 
+  TransactionSelection, 
+  TransactionUpdation, 
+  TransactionDeletion,
+  Condition,
+  BuildQueryResult
+} from '../types.js';
+import type { Database } from './database.js';
+
+/**
+ * 事务查询选择器实现
+ */
+class TrxSelection<S extends Record<string, object>, T extends keyof S> implements TransactionSelection<S, T> {
+  private conditions: Condition<S[T]> = {};
+  private orderings: { field: keyof S[T]; direction: 'ASC' | 'DESC' }[] = [];
+  private limitCount?: number;
+  private offsetCount?: number;
+  
+  constructor(
+    private readonly db: Database<any, S, string>,
+    private readonly trx: Transaction,
+    private readonly tableName: T,
+    private readonly fields?: (keyof S[T])[]
+  ) {}
+  
+  where(condition: Condition<S[T]>): this {
+    this.conditions = { ...this.conditions, ...condition };
+    return this;
+  }
+  
+  orderBy(field: keyof S[T], direction: 'ASC' | 'DESC' = 'ASC'): this {
+    this.orderings.push({ field, direction });
+    return this;
+  }
+  
+  limit(count: number): this {
+    this.limitCount = count;
+    return this;
+  }
+  
+  offset(count: number): this {
+    this.offsetCount = count;
+    return this;
+  }
+  
+  then<R>(onfulfilled?: (value: S[T][]) => R | PromiseLike<R>): Promise<R> {
+    const { query, params } = this.db.buildQuery({
+      type: 'select',
+      tableName: this.tableName,
+      fields: this.fields,
+      conditions: this.conditions,
+      orderings: this.orderings,
+      limitCount: this.limitCount,
+      offsetCount: this.offsetCount
+    });
+    
+    return this.trx.query<S[T][]>(query, params).then(onfulfilled!);
+  }
+}
+
+/**
+ * 事务更新器实现
+ */
+class TrxUpdation<S extends Record<string, object>, T extends keyof S> implements TransactionUpdation<S, T> {
+  private conditions: Condition<S[T]> = {};
+  
+  constructor(
+    private readonly db: Database<any, S, string>,
+    private readonly trx: Transaction,
+    private readonly tableName: T,
+    private readonly data: Partial<S[T]>
+  ) {}
+  
+  where(condition: Condition<S[T]>): this {
+    this.conditions = { ...this.conditions, ...condition };
+    return this;
+  }
+  
+  then<R>(onfulfilled?: (value: number) => R | PromiseLike<R>): Promise<R> {
+    const { query, params } = this.db.buildQuery({
+      type: 'update',
+      tableName: this.tableName,
+      update: this.data,
+      conditions: this.conditions
+    });
+    
+    return this.trx.query<{ affectedRows?: number; changes?: number }>(query, params)
+      .then(result => {
+        const affected = result.affectedRows ?? result.changes ?? 0;
+        return onfulfilled ? onfulfilled(affected) : affected as any;
+      });
+  }
+}
+
+/**
+ * 事务删除器实现
+ */
+class TrxDeletion<S extends Record<string, object>, T extends keyof S> implements TransactionDeletion<S, T> {
+  private conditions: Condition<S[T]> = {};
+  
+  constructor(
+    private readonly db: Database<any, S, string>,
+    private readonly trx: Transaction,
+    private readonly tableName: T
+  ) {}
+  
+  where(condition: Condition<S[T]>): this {
+    this.conditions = { ...this.conditions, ...condition };
+    return this;
+  }
+  
+  then<R>(onfulfilled?: (value: number) => R | PromiseLike<R>): Promise<R> {
+    const { query, params } = this.db.buildQuery({
+      type: 'delete',
+      tableName: this.tableName,
+      conditions: this.conditions
+    });
+    
+    return this.trx.query<{ affectedRows?: number; changes?: number }>(query, params)
+      .then(result => {
+        const affected = result.affectedRows ?? result.changes ?? 0;
+        return onfulfilled ? onfulfilled(affected) : affected as any;
+      });
+  }
+}
+
+/**
+ * 增强的事务上下文实现
+ * 支持链式调用的事务操作
+ */
+export class TransactionContextImpl<S extends Record<string, object>> implements TransactionContext<S> {
+  constructor(
+    private readonly db: Database<any, S, string>,
+    private readonly trx: Transaction
+  ) {}
+  
+  /**
+   * 提交事务
+   */
+  async commit(): Promise<void> {
+    return this.trx.commit();
+  }
+  
+  /**
+   * 回滚事务
+   */
+  async rollback(): Promise<void> {
+    return this.trx.rollback();
+  }
+  
+  /**
+   * 执行原生 SQL
+   */
+  async query<T = any>(sql: string, params?: any[]): Promise<T> {
+    return this.trx.query<T>(sql, params);
+  }
+  
+  /**
+   * 插入单条数据
+   */
+  async insert<T extends keyof S>(tableName: T, data: S[T]): Promise<S[T]> {
+    const { query, params } = this.db.buildQuery({
+      type: 'insert',
+      tableName,
+      data
+    });
+    
+    await this.trx.query(query, params);
+    return data;
+  }
+  
+  /**
+   * 批量插入数据
+   */
+  async insertMany<T extends keyof S>(tableName: T, data: S[T][]): Promise<{ affectedRows: number }> {
+    if (!data.length) {
+      return { affectedRows: 0 };
+    }
+    
+    const { query, params } = this.db.buildQuery({
+      type: 'insert_many',
+      tableName,
+      data
+    });
+    
+    const result = await this.trx.query<{ affectedRows?: number; changes?: number }>(query, params);
+    return { affectedRows: result.affectedRows ?? result.changes ?? data.length };
+  }
+  
+  /**
+   * 查询数据 - 返回链式选择器
+   */
+  select<T extends keyof S>(tableName: T, fields?: (keyof S[T])[]): TransactionSelection<S, T> {
+    return new TrxSelection(this.db, this.trx, tableName, fields);
+  }
+  
+  /**
+   * 更新数据 - 返回链式更新器
+   */
+  update<T extends keyof S>(tableName: T, data: Partial<S[T]>): TransactionUpdation<S, T> {
+    return new TrxUpdation(this.db, this.trx, tableName, data);
+  }
+  
+  /**
+   * 删除数据 - 返回链式删除器
+   */
+  delete<T extends keyof S>(tableName: T): TransactionDeletion<S, T> {
+    return new TrxDeletion(this.db, this.trx, tableName);
+  }
+}
+

package/src/dialects/memory.ts

@@ -1,8 +1,6 @@
-import {Dialect} from '../base';
-import {MemoryConfig} from "../types";
-import {RelatedDatabase} from "../type/related/database";
-import {Registry} from "../registry";
-import {Database} from "../base";
+import {Dialect} from '../base/index.js';
+import {RelatedDatabase} from "../type/related/database.js";
+import {Registry} from "../registry.js";
 
 interface MemoryTable {
   name: string;
@@ -16,8 +14,8 @@ interface MemoryIndex {
   columns: string[];
   unique: boolean;
 }
-
-export class MemoryDialect extends Dialect<MemoryConfig,string> {
+export interface MemoryConfig{}
+export class MemoryDialect<S extends Record<string, object>> extends Dialect<MemoryConfig,S, string> {
   private connected = false;
   private tables: Map<string, MemoryTable> = new Map();
   private autoIncrementCounters: Map<string, Map<string, number>> = new Map();
@@ -96,8 +94,8 @@ export class MemoryDialect extends Dialect<MemoryConfig,string> {
     return typeMap[type.toLowerCase()] || 'TEXT';
   }
   
-  quoteIdentifier(identifier: string): string {
-    return `"${identifier}"`;
+  quoteIdentifier(identifier: string|symbol|number): string {
+    return `"${String(identifier)}"`;
   }
   
   getParameterPlaceholder(index: number): string {
@@ -152,20 +150,20 @@ export class MemoryDialect extends Dialect<MemoryConfig,string> {
     return `LIMIT ${limit} OFFSET ${offset}`;
   }
   
-  formatCreateTable(tableName: string, columns: string[]): string {
+  formatCreateTable(tableName: keyof S, columns: string[]): string {
     return `CREATE TABLE ${this.quoteIdentifier(tableName)} (${columns.join(', ')})`;
   }
   
-  formatAlterTable(tableName: string, alterations: string[]): string {
+  formatAlterTable(tableName: keyof S, alterations: string[]): string {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} ${alterations.join(', ')}`;
   }
   
-  formatDropTable(tableName: string, ifExists?: boolean): string {
+  formatDropTable(tableName: keyof S, ifExists?: boolean): string {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
     return `DROP TABLE ${ifExistsClause}${this.quoteIdentifier(tableName)}`;
   }
   
-  formatDropIndex(indexName: string, tableName: string, ifExists?: boolean): string {
+  formatDropIndex(indexName: string, tableName: keyof S, ifExists?: boolean): string {
     const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
     return `DROP INDEX ${ifExistsClause}${this.quoteIdentifier(indexName)} ON ${this.quoteIdentifier(tableName)}`;
   }
@@ -876,6 +874,9 @@ export class MemoryDialect extends Dialect<MemoryConfig,string> {
     });
   }
 }
-Registry.register('memory', (config, definitions?: Database.Definitions<Record<string, object>>) => {
-  return new RelatedDatabase(new MemoryDialect(config), definitions);
-});
+export class Memory<S extends Record<string, object>> extends RelatedDatabase<MemoryConfig, S> {
+  constructor(config: MemoryConfig = {}) {
+    super(new MemoryDialect<S>(config));
+  }
+}
+Registry.register('memory', Memory);

package/src/dialects/mongodb.ts

@@ -1,4 +1,4 @@
-import {Database, Dialect} from '../base';
+import {Database, Dialect} from '../base/index.js';
 import {
   AlterQueryParams,
   BuildQueryResult,
@@ -6,9 +6,9 @@ import {
   DocumentQueryResult, DropIndexQueryParams, DropTableQueryParams, InsertQueryParams,
   QueryParams,
   SelectQueryParams, UpdateQueryParams
-} from "../types";
-import {DocumentDatabase} from "../type/document/database";
-import {Registry} from "../registry";
+} from "../types.js";
+import {DocumentDatabase} from "../type/document/database.js";
+import {Registry} from "../registry.js";
 import type { MongoClientOptions } from 'mongodb';
 
 
@@ -16,7 +16,7 @@ export interface MongoDBDialectConfig extends MongoClientOptions {
   url: string;
   dbName: string;
 }
-export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryResult> {
+export class MongoDBDialect<S extends Record<string, object> = Record<string, object>> extends Dialect<MongoDBDialectConfig, S, DocumentQueryResult> {
   private client: any = null;
   private db: any = null;
 
@@ -139,24 +139,24 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
   /**
    * 构建查询
    */
-  buildQuery<U extends object = any>(params: QueryParams<U>): BuildQueryResult<DocumentQueryResult> {
+  buildQuery<T extends keyof S>(params: QueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     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}`);
     }
@@ -214,20 +214,20 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     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' : ''}`;
   } 
 
   quoteIdentifier(identifier: string): string {
@@ -243,10 +243,10 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
   }
 
   // MongoDB 特定的查询构建方法
-  private buildCreateQuery<T extends object>(params: CreateQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildCreateQuery<T extends keyof S>(params: CreateQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'createCollection',
         filter: {},
         projection: {}
@@ -255,7 +255,7 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildSelectQuery<T extends object>(params: SelectQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildSelectQuery<T extends keyof S>(params: SelectQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     const filter: Record<string, any> = {};
     
     // 转换条件为 MongoDB 查询格式
@@ -264,7 +264,7 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     }
 
     const query: DocumentQueryResult = {
-      collection: params.tableName,
+      collection: String(params.tableName),
       operation: 'find',
       filter
     };
@@ -297,10 +297,10 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildInsertQuery<T extends object>(params: InsertQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildInsertQuery<T extends keyof S>(params: InsertQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'insertOne',
         filter: {},
         projection: {}
@@ -309,7 +309,7 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildUpdateQuery<T extends object>(params: UpdateQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildUpdateQuery<T extends keyof S>(params: UpdateQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     const filter: Record<string, any> = {};
     
     if (params.conditions) {
@@ -318,7 +318,7 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
 
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'updateMany',
         filter,
         projection: {}
@@ -327,7 +327,7 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildDeleteQuery<T extends object>(params: DeleteQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildDeleteQuery<T extends keyof S>(params: DeleteQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     const filter: Record<string, any> = {};
     
     if (params.conditions) {
@@ -336,7 +336,7 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
 
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'deleteMany',
         filter,
         projection: {}
@@ -345,10 +345,10 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildAlterQuery<T extends object>(params: AlterQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildAlterQuery<T extends keyof S>(params: AlterQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'createIndex',
         filter: {},
         projection: {}
@@ -357,10 +357,10 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildDropTableQuery<T extends object>(params: DropTableQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+  private buildDropTableQuery<T extends keyof S>(params: DropTableQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'dropCollection',
         filter: {},
         projection: {}
@@ -369,10 +369,10 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 
-  private buildDropIndexQuery(params: DropIndexQueryParams): BuildQueryResult<DocumentQueryResult> {
+  private buildDropIndexQuery<T extends keyof S>(params: DropIndexQueryParams<S,T>): BuildQueryResult<DocumentQueryResult> {
     return {
       query: {
-        collection: params.tableName,
+        collection: String(params.tableName),
         operation: 'dropIndex',
         filter: {},
         projection: {}
@@ -527,7 +527,9 @@ export class MongoDBDialect extends Dialect<MongoDBDialectConfig, DocumentQueryR
     };
   }
 }
-
-Registry.register('mongodb', (config: MongoDBDialectConfig, definitions?: Database.Definitions<Record<string, object>>) => {
-  return new DocumentDatabase(new MongoDBDialect(config), definitions);
-});
+export class MongoDB<S extends Record<string, object> = Record<string, object>> extends DocumentDatabase<MongoDBDialectConfig, S> {
+  constructor(config: MongoDBDialectConfig, definitions?: Database.DefinitionObj<S>) {
+    super(new MongoDBDialect<S>(config), definitions);
+  }
+}
+Registry.register('mongodb', MongoDB);