vona-module-a-orm 5.0.84 → 5.0.86

package/cli/databaseDialect/boilerplate/{{sceneName}}.{{beanName}}.ts_

@@ -1,4 +1,7 @@
+import type { IDecoratorDatabaseDialectOptions } from 'vona-module-a-orm';
 import { BeanDatabaseDialectBase, DatabaseDialect } from 'vona-module-a-orm';
 
-@DatabaseDialect()
+export interface IDatabaseDialectOptions<%=argv.beanNameCapitalize%> extends IDecoratorDatabaseDialectOptions {}
+
+@DatabaseDialect<IDatabaseDialectOptions<%=argv.beanNameCapitalize%>>()
 export class DatabaseDialect<%=argv.beanNameCapitalize%> extends BeanDatabaseDialectBase {}

package/dist/bean/bean.database.d.ts

@@ -1,12 +1,14 @@
 import type { FunctionAsync } from 'vona';
 import type { ConfigDatabaseClient } from '../types/config.ts';
-import type { IDatabaseClientRecord, IDbInfo } from '../types/database.ts';
+import type { IDatabaseClientDialectRecord, IDatabaseClientRecord, IDbInfo } from '../types/database.ts';
+import type { BeanDatabaseDialectBase } from './bean.databaseDialectBase.ts';
 import { BeanBase } from 'vona';
 import { ServiceDatabaseClient } from '../service/databaseClient_.ts';
 export declare class BeanDatabase extends BeanBase {
     get current(): import("vona-module-a-orm").ServiceDb;
     getClient(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient): ServiceDatabaseClient;
     getDb(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient): import("vona-module-a-orm").ServiceDb;
+    getDialect(client: keyof IDatabaseClientDialectRecord): BeanDatabaseDialectBase;
     switchDbIsolate<RESULT>(fn: FunctionAsync<RESULT>, dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): Promise<RESULT>;
     switchDb<RESULT>(fn: FunctionAsync<RESULT>, dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): Promise<RESULT>;
 }

package/dist/bean/bean.databaseDialectBase.d.ts

@@ -2,18 +2,25 @@ import type { Knex } from 'knex';
 import type { TableIdentity } from 'table-identity';
 import type { ITableColumn } from '../types/columns.ts';
 import type { ConfigDatabaseClient } from '../types/config.ts';
-import type { IFetchDatabasesResultItem, IFetchIndexesResultItem } from '../types/dialect.ts';
+import type { IDatabaseDialectCapabilities, IFetchDatabasesResultItem, IFetchIndexesResultItem, TypeDatabaseDialectTableColumnsFn } from '../types/dialect.ts';
 import { BeanBase } from 'vona';
 export declare class BeanDatabaseDialectBase extends BeanBase {
-    getConfigBase(): ConfigDatabaseClient | undefined;
+    protected _capabilities?: IDatabaseDialectCapabilities;
+    protected _configBase?: Partial<ConfigDatabaseClient>;
+    get capabilities(): IDatabaseDialectCapabilities;
+    get configBase(): Partial<ConfigDatabaseClient> | undefined;
     fetchDatabases(_schemaBuilder: Knex.SchemaBuilder, _databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
-    createDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<void>;
+    createDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<string>;
     dropDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<void>;
     fetchIndexes(_schemaBuilder: Knex.SchemaBuilder, _tableName: string): Promise<IFetchIndexesResultItem[]>;
     insert(_builder: Knex.QueryBuilder, _datas: any[]): Promise<TableIdentity[]>;
+    select(_builder: Knex.QueryBuilder, datas: any[], _fn: TypeDatabaseDialectTableColumnsFn): Promise<any[]>;
     query(_result: any): void;
     viewDependents(_builder: Knex.QueryBuilder, _viewName: string): Promise<string[]>;
     coerceColumn(column: Knex.ColumnInfo): ITableColumn;
+    protected selectAsSqlite3(_builder: Knex.QueryBuilder, datas: any[], fn: TypeDatabaseDialectTableColumnsFn): Promise<any[]>;
+    protected insertAsMysql(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]>;
+    protected insertAsPg(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]>;
     protected _coerceColumnValue(type: string, value: any): any;
     protected _safeNumber(value: any): number | undefined;
     protected _columnTypePrefixes(type: string, prefixes: string[]): boolean;

package/dist/common/buildWhere.d.ts

@@ -1,3 +1,4 @@
 import type { Knex } from 'knex';
+import type { ServiceDb } from '../service/db_.ts';
 import type { TypeModelWhere } from '../types/modelWhere.ts';
-export declare function buildWhere<TRecord>(knex: Knex, builder: Knex.QueryBuilder, wheres: TypeModelWhere<TRecord>, having?: boolean): void;
+export declare function buildWhere<TRecord>(db: ServiceDb, builder: Knex.QueryBuilder, wheres: TypeModelWhere<TRecord>, having?: boolean): void;

package/dist/config/config.d.ts

@@ -1,9 +1,8 @@
 import type { TableIdentityType } from 'table-identity';
-import type { TypeBeanRecordGeneralSelectorKeys, VonaApplication } from 'vona';
+import type { VonaApplication } from 'vona';
 import type { IOnionOptionsMeta } from 'vona-module-a-onion';
 import type { TSummerCachePreset } from 'vona-module-a-summer';
-import type { IDatabaseClientDialectRecord } from '../types/database.ts';
-export type TypeDataBaseConfigDialects = Record<keyof IDatabaseClientDialectRecord, TypeBeanRecordGeneralSelectorKeys<'databaseDialect'>>;
+import type { IDataBaseConfigDialects } from '../types/config.ts';
 export declare function config(_app: VonaApplication): {
     sharding: {
         cache: {
@@ -34,7 +33,7 @@ export declare function config(_app: VonaApplication): {
         enable: boolean;
         expired: number;
     };
-    dialects: TypeDataBaseConfigDialects;
+    dialects: IDataBaseConfigDialects;
     summer: {
         enable: boolean;
         meta: IOnionOptionsMeta;

package/dist/extend/schemaBuilder.d.ts

@@ -5,7 +5,7 @@ declare module 'knex' {
     namespace Knex {
         interface SchemaBuilder {
             fetchDatabases(databasePrefix: string): Promise<IFetchDatabasesResultItem[]>;
-            createDatabase(databaseName: string): Promise<void>;
+            createDatabase(databaseName: string): Promise<string>;
             dropDatabase(databaseName: string): Promise<void>;
             fetchIndexes(tableName: string): Promise<IFetchIndexesResultItem[]>;
         }

package/dist/index.js

@@ -1,5 +1,5 @@
 import BigNumber from 'bignumber.js';
-import { BeanInfo, BeanAopMethodBase, BeanBase, deepExtend, appResource, Virtual, beanFullNameFromOnionName, cast, useApp, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class } from 'vona';
+import { BeanInfo, BeanAopMethodBase, BeanBase, deepExtend, appResource, beanFullNameFromOnionName, Virtual, cast, useApp, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class } from 'vona';
 import { AopMethod } from 'vona-module-a-aspect';
 import { Service, Bean, Scope } from 'vona-module-a-bean';
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
@@ -190,27 +190,20 @@ let ServiceDatabase = (_dec$r = Service(), _dec2$r = BeanInfo({
   get configDatabase() {
     return this.app.config.database;
   }
-  getDialect(client) {
-    if (!client) throw new Error('database dialect not specified');
-    const beanFullName = this.scope.config.dialects[client];
-    const dialect = this.app.bean._getBean(beanFullName);
-    if (!dialect) throw new Error(`database dialect not found: ${client}`);
-    return dialect;
-  }
-  getClientConfig(clientName, original = false) {
+  getClientConfig(clientName, clientConfig, original) {
     // clientConfig
-    let clientConfig = this.configDatabase.clients[clientName];
-    if (original) return clientConfig;
+    if (!clientConfig) {
+      clientConfig = this.configDatabase.clients[clientName];
+    }
     // check
     if (!clientConfig) {
       throw new Error(`database config not found: ${clientName}`);
     }
+    if (original) return clientConfig;
     // configBaseClient
-    const dialect = this.scope.service.database.getDialect(clientConfig.client);
-    const configBaseClient = dialect.getConfigBase();
+    const dialect = this.bean.database.getDialect(clientConfig.client);
     // combine
-    const configBase = this.configDatabase.base;
-    clientConfig = deepExtend({}, configBase, configBaseClient, clientConfig);
+    clientConfig = deepExtend({}, this.configDatabase.base, dialect.configBase, clientConfig);
     // ready
     return clientConfig;
   }
@@ -235,7 +228,9 @@ let ServiceDatabase = (_dec$r = Service(), _dec2$r = BeanInfo({
       clientName
     };
   }
-  prepareClientNameSelector(dbInfo) {
+  prepareClientNameSelector(dbInfo, dialect) {
+    const dialect2 = typeof dialect === 'string' ? this.bean.database.getDialect(dialect) : dialect;
+    if (!dialect2.capabilities.level) return dbInfo.clientName;
     // combine
     return dbInfo.level === 0 ? dbInfo.clientName : `${dbInfo.clientName}:${dbInfo.level}`;
   }
@@ -390,18 +385,18 @@ let ServiceTransactionState = (_dec$o = Service(), _dec2$o = BeanInfo({
   get serviceDatabase() {
     return this.bean._getBean(ServiceDatabase);
   }
-  get(dbInfo) {
-    const selector = this.serviceDatabase.prepareClientNameSelector(dbInfo);
+  get(db) {
+    const selector = this.serviceDatabase.prepareClientNameSelector(db.info, db.dialect);
     return this._fibers[selector];
   }
-  add(dbInfo, connection) {
-    const selector = this.serviceDatabase.prepareClientNameSelector(dbInfo);
+  add(db, connection) {
+    const selector = this.serviceDatabase.prepareClientNameSelector(db.info, db.dialect);
     const fiber = this.bean._newBean(ServiceTransactionFiber, connection);
     this._fibers[selector] = fiber;
     return fiber;
   }
-  remove(dbInfo) {
-    const selector = this.serviceDatabase.prepareClientNameSelector(dbInfo);
+  remove(db) {
+    const selector = this.serviceDatabase.prepareClientNameSelector(db.info, db.dialect);
     delete this._fibers[selector];
   }
 }) || _class$o) || _class$o);
@@ -447,7 +442,7 @@ let ServiceTransaction = (_dec$m = Service(), _dec2$m = BeanInfo({
     return this.bean._getBean(ServiceTransactionAsyncLocalStorage).transactionState;
   }
   get transactionFiber() {
-    return this.transactionState.get(this._db.info);
+    return this.transactionState.get(this._db);
   }
   get inTransaction() {
     return !!this.transactionFiber;
@@ -528,7 +523,7 @@ let ServiceTransaction = (_dec$m = Service(), _dec2$m = BeanInfo({
     if (!this.inTransaction) {
       const connection = this._db.client.connection;
       const transactionConnection = await connection.transaction(_translateTransactionOptions(options));
-      fiber = this.transactionState.add(this._db.info, transactionConnection);
+      fiber = this.transactionState.add(this._db, transactionConnection);
     }
     // fn
     try {
@@ -536,19 +531,19 @@ let ServiceTransaction = (_dec$m = Service(), _dec2$m = BeanInfo({
     } catch (err) {
       if (fiber) {
         await fiber.doRollback();
-        this.transactionState.remove(this._db.info);
+        this.transactionState.remove(this._db);
       }
       throw err;
     }
     try {
       if (fiber) {
         await fiber.doCommit();
-        this.transactionState.remove(this._db.info);
+        this.transactionState.remove(this._db);
       }
     } catch (err) {
       if (fiber) {
         await fiber.doRollback();
-        this.transactionState.remove(this._db.info);
+        this.transactionState.remove(this._db);
       }
       throw err;
     }
@@ -613,7 +608,7 @@ let ServiceDb = (_dec$l = Service(), _dec2$l = BeanInfo({
     return this.client.clientConfig.client;
   }
   get dialect() {
-    return this.scope.service.database.getDialect(this.dialectName);
+    return this.bean.database.getDialect(this.dialectName);
   }
   async commit(cb, options) {
     return await this.transaction.commit(cb, options);
@@ -680,8 +675,8 @@ let ServiceDatabaseClient = (_dec$k = Service(), _dec2$k = BeanInfo({
     const dbInfo = this.scope.service.database.parseClientNameSelector(clientNameSelector);
     this.level = dbInfo.level;
     this.clientName = dbInfo.clientName;
-    // config
-    this.clientConfig = clientConfig ? deepExtend({}, clientConfig) : this.scope.service.database.getClientConfig(this.clientName);
+    // config: inited by bean.database.getClient
+    this.clientConfig = clientConfig;
     // knex
     this._knex = knex(this.clientConfig);
   }
@@ -694,8 +689,9 @@ let ServiceDatabaseClient = (_dec$k = Service(), _dec2$k = BeanInfo({
     }
   }
   async reload(clientConfig) {
+    const clientConfigReal = this.scope.service.database.getClientConfig(this.clientName, clientConfig);
     await this.__close();
-    this.__load(this.clientNameSelector, clientConfig);
+    this.__load(this.clientNameSelector, clientConfigReal);
   }
   getDatabaseName() {
     const connection = this.clientConfig.connection;
@@ -704,9 +700,9 @@ let ServiceDatabaseClient = (_dec$k = Service(), _dec2$k = BeanInfo({
   _prepareDatabaseName(databaseName) {
     const result = {};
     const connection = this.clientConfig.connection;
-    if (connection.database) {
+    if (connection.database !== undefined) {
       result.database = databaseName;
-    } else if (connection.filename) {
+    } else if (connection.filename !== undefined) {
       result.filename = databaseName;
     }
     return result;
@@ -718,7 +714,7 @@ let ServiceDatabaseClient = (_dec$k = Service(), _dec2$k = BeanInfo({
     const connDatabaseName = this._prepareDatabaseName(databaseName);
     // set config
     //   * should not use this.clientConfig.connection, because password is hidden
-    const config = this.scope.service.database.getClientConfig(this.clientName, true);
+    const config = this.scope.service.database.getClientConfig(this.clientName, undefined, true);
     config.connection = Object.assign({}, config.connection, connDatabaseName);
     // only used by startup, so no consider that workers broadcast
     this.configDatabase.clients[this.clientName] = config;
@@ -737,16 +733,26 @@ let BeanDatabase = (_dec$j = Bean(), _dec2$j = BeanInfo({
   }
   getClient(dbInfoOrClientName, clientConfig) {
     const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
-    const selector = this.scope.service.database.prepareClientNameSelector(dbInfo);
-    return this.app.bean._getBeanSelector(ServiceDatabaseClient, selector, clientConfig);
+    const clientConfigReal = this.scope.service.database.getClientConfig(dbInfo.clientName, clientConfig);
+    const selector = this.scope.service.database.prepareClientNameSelector(dbInfo, clientConfigReal.client);
+    return this.app.bean._getBeanSelector(ServiceDatabaseClient, selector, clientConfigReal);
   }
   getDb(dbInfoOrClientName, clientConfig) {
     return this.getClient(dbInfoOrClientName, clientConfig).db;
   }
+  getDialect(client) {
+    if (!client) throw new Error('database dialect not specified');
+    const beanFullName = beanFullNameFromOnionName(this.scope.config.dialects[client], 'databaseDialect');
+    const dialect = this.app.bean._getBean(beanFullName);
+    if (!dialect) throw new Error(`database dialect not found: ${client}`);
+    return dialect;
+  }
   async switchDbIsolate(fn, dbInfoOrClientName) {
     const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    // const level = this.app.config.database.defaultClient === 'sqlite3' ? dbInfo.level : dbInfo.level + 1;
+    const level = dbInfo.level + 1;
     return this.switchDb(fn, {
-      level: dbInfo.level + 1,
+      level,
       clientName: dbInfo.clientName
     });
   }
@@ -767,8 +773,17 @@ var _dec$i, _dec2$i, _dec3$7, _class$i;
 let BeanDatabaseDialectBase = (_dec$i = Bean(), _dec2$i = Virtual(), _dec3$7 = BeanInfo({
   module: "a-orm"
 }), _dec$i(_class$i = _dec2$i(_class$i = _dec3$7(_class$i = class BeanDatabaseDialectBase extends BeanBase {
-  getConfigBase() {
-    return undefined;
+  constructor(...args) {
+    super(...args);
+    this._capabilities = void 0;
+    this._configBase = void 0;
+  }
+  get capabilities() {
+    if (!this._capabilities) throw new Error('Should provide dialect capabilities');
+    return this._capabilities;
+  }
+  get configBase() {
+    return this._configBase;
   }
   async fetchDatabases(_schemaBuilder, _databasePrefix) {
     throw new Error('Not Implemented');
@@ -785,6 +800,9 @@ let BeanDatabaseDialectBase = (_dec$i = Bean(), _dec2$i = Virtual(), _dec3$7 = B
   async insert(_builder, _datas) {
     throw new Error('Not Implemented');
   }
+  async select(_builder, datas, _fn) {
+    return datas;
+  }
   query(_result) {
     throw new Error('Not Implemented');
   }
@@ -801,6 +819,51 @@ let BeanDatabaseDialectBase = (_dec$i = Bean(), _dec2$i = Virtual(), _dec3$7 = B
     // ok
     return result;
   }
+  async selectAsSqlite3(_builder, datas, fn) {
+    const columns = await fn();
+    // data
+    for (const data of datas) {
+      for (const columnName in columns) {
+        const column = columns[columnName];
+        if (Object.prototype.hasOwnProperty.call(data, columnName)) {
+          const value = data[columnName];
+          if (column.type === 'json' && value !== undefined && typeof value === 'string') {
+            data[columnName] = JSON.parse(value);
+          }
+        }
+      }
+    }
+    return datas;
+  }
+  async insertAsMysql(builder, datas) {
+    if (datas.length === 0) return [];
+    if (isNil(datas[0].id)) {
+      const ids = [];
+      for (const data of datas) {
+        const builder2 = builder.clone();
+        builder2.insert(data);
+        const items = await builder2;
+        ids.push(items[0]);
+      }
+      return ids;
+    } else {
+      builder.insert(datas);
+      await builder;
+      return datas.map(item => item.id);
+    }
+  }
+  async insertAsPg(builder, datas) {
+    if (datas.length === 0) return [];
+    if (isNil(datas[0].id)) {
+      builder.insert(datas).returning('id');
+      const items = await builder;
+      return items.map(item => item.id);
+    } else {
+      builder.insert(datas);
+      await builder;
+      return datas.map(item => item.id);
+    }
+  }
   _coerceColumnValue(type, value) {
     // null
     if (isNil(value)) return undefined;
@@ -934,10 +997,10 @@ function getClassEntityFromClassModel(modelClass) {
 //   return arr;
 // }
 
-function buildWhere(knex, builder, wheres, having = false) {
-  _buildWhereInner(having, knex, builder, wheres);
+function buildWhere(db, builder, wheres, having = false) {
+  _buildWhereInner(having, db, builder, wheres);
 }
-function _buildWhereInner(having, knex, builder, wheres, column) {
+function _buildWhereInner(having, db, builder, wheres, column) {
   // skip
   if (wheres === Op.skip) {
     return;
@@ -952,22 +1015,22 @@ function _buildWhereInner(having, knex, builder, wheres, column) {
     const value = wheres[key];
     if (key[0] !== '_') {
       // columns
-      _buildWhereColumn(having, knex, builder, key, value);
+      _buildWhereColumn(having, db, builder, key, value);
     } else if (OpNormalValues.includes(key)) {
       // op: normal
       if (column) {
-        _buildWhereColumn(having, knex, builder, column, value, key);
+        _buildWhereColumn(having, db, builder, column, value, key);
       }
     } else {
       const op = _checkOpJoint(key);
       if (op) {
         // op: joint
-        _buildWhereOpJoint(having, knex, builder, column, value, op);
+        _buildWhereOpJoint(having, db, builder, column, value, op);
       }
     }
   }
 }
-function _buildWhereOpJoint(having, knex, builder, column, wheres, op) {
+function _buildWhereOpJoint(having, db, builder, column, wheres, op) {
   // skip
   if (wheres === Op.skip) {
     return;
@@ -977,7 +1040,7 @@ function _buildWhereOpJoint(having, knex, builder, column, wheres, op) {
     builder[having ? 'having' : 'where'](builder => {
       for (const key in wheres) {
         builder.andWhere(builder => {
-          _buildWhereInner(false, knex, builder, {
+          _buildWhereInner(false, db, builder, {
             [key]: wheres[key]
           }, column);
         });
@@ -990,7 +1053,7 @@ function _buildWhereOpJoint(having, knex, builder, column, wheres, op) {
     builder[having ? 'having' : 'where'](builder => {
       for (const key in wheres) {
         builder.orWhere(builder => {
-          _buildWhereInner(false, knex, builder, {
+          _buildWhereInner(false, db, builder, {
             [key]: wheres[key]
           }, column);
         });
@@ -1001,7 +1064,7 @@ function _buildWhereOpJoint(having, knex, builder, column, wheres, op) {
   // not
   if (op === Op.not) {
     builder[having ? 'havingNot' : 'whereNot'](builder => {
-      _buildWhereInner(false, knex, builder, wheres, column);
+      _buildWhereInner(false, db, builder, wheres, column);
     });
     return;
   }
@@ -1015,59 +1078,52 @@ function _buildWhereOpJoint(having, knex, builder, column, wheres, op) {
     builder[having ? 'havingNotExists' : 'whereNotExists'](wheres);
   }
 }
-function _buildWhereColumn(having, knex, builder, column, value, op) {
+function _buildWhereColumn(having, db, builder, column, value, op) {
   // skip
   if (value === Op.skip) {
     return;
   }
   // raw
   if (isRaw(value) || isRef(value)) {
-    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.eq);
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
     return;
   }
   // null/undefined
   if (isNil(value)) {
-    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.is);
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.is);
     return;
   }
   // array
   if (Array.isArray(value)) {
-    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.in);
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.in);
     return;
   }
   // date
   if (value instanceof Date) {
-    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.eq);
+    _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
     return;
   }
   // object
   if (typeof value === 'object') {
     builder[having ? 'having' : 'where'](builder => {
-      _buildWhereInner(false, knex, builder, value, column);
+      _buildWhereInner(false, db, builder, value, column);
     });
     return;
   }
   // column
-  _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.eq);
+  _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
 }
-function _buildWhereColumnOpNormal(having, knex, builder, column, value, op) {
-  column = _checkHavingColumn(knex, column);
-  if (_shouldPatchLike(knex)) {
-    if (op === Op.startsWith) op = Op.startsWithI;
-    if (op === Op.endsWith) op = Op.endsWithI;
-    if (op === Op.includes) op = Op.includesI;
-    if (op === Op.eqI) op = Op.eq;
-    if (op === Op.notEqI) op = Op.notEq;
-  }
+function _buildWhereColumnOpNormal(having, db, builder, column, value, op) {
+  column = _checkHavingColumn(db, column);
   if (op === Op.eq) {
     builder[having ? 'having' : 'where'](column, '=', value);
   } else if (op === Op.notEq) {
     builder[having ? 'having' : 'where'](column, '<>', value);
   } else if (op === Op.eqI) {
-    builder[having ? 'havingILike' : 'whereILike'](column, value);
+    builder[_getOpILikeReal(having, db)](column, value);
   } else if (op === Op.notEqI) {
     builder[having ? 'havingNot' : 'whereNot'](builder => {
-      builder[having ? 'havingILike' : 'whereILike'](column, value);
+      builder[_getOpILikeReal(having, db)](column, value);
     });
   } else if (op === Op.gt) {
     builder[having ? 'having' : 'where'](column, '>', value);
@@ -1096,27 +1152,23 @@ function _buildWhereColumnOpNormal(having, knex, builder, column, value, op) {
   } else if (op === Op.includes) {
     builder[having ? 'havingLike' : 'whereLike'](column, `%${value}%`);
   } else if (op === Op.startsWithI) {
-    builder[having ? 'havingILike' : 'whereILike'](column, `${value}%`);
+    builder[_getOpILikeReal(having, db)](column, `${value}%`);
   } else if (op === Op.endsWithI) {
-    builder[having ? 'havingILike' : 'whereILike'](column, `%${value}`);
+    builder[_getOpILikeReal(having, db)](column, `%${value}`);
   } else if (op === Op.includesI) {
-    builder[having ? 'havingILike' : 'whereILike'](column, `%${value}%`);
+    builder[_getOpILikeReal(having, db)](column, `%${value}%`);
   } else if (op === Op.ref) {
-    builder[having ? 'having' : 'where'](column, '=', knex.ref(value));
+    builder[having ? 'having' : 'where'](column, '=', db.connection.ref(value));
   }
 }
-function _shouldPatchLike(knex) {
-  const dialectName = _getDialectName(knex);
-  return dialectName === 'mysql' || dialectName === 'mysql2';
-}
-function _getDialectName(knex) {
-  return knex.client.config.client;
+function _getOpILikeReal(having, db) {
+  return db.dialect.capabilities.ilike ? having ? 'havingILike' : 'whereILike' : having ? 'havingLike' : 'whereLike';
 }
-function _checkHavingColumn(knex, column) {
+function _checkHavingColumn(db, column) {
   let [aggr, name] = cast(column).split('_');
   if (!OpAggrs.includes(aggr) || !name) return column;
   if (aggr === 'count' && name === 'all') name = '*';
-  return knex.raw(`${_safeOp(aggr)}(${_safeColumn(name)})`);
+  return db.connection.raw(`${_safeOp(aggr)}(${_safeColumn(name)})`);
 }
 function _checkOpJoint(op) {
   for (const item of OpJointValues) {
@@ -1589,7 +1641,7 @@ class BeanModelUtils extends BeanModelMeta {
 
   buildWhere(builder, wheres) {
     if (!wheres) return;
-    return buildWhere(this.connection, builder, wheres);
+    return buildWhere(this.db, builder, wheres);
   }
   buildJoin(builder, join) {
     if (!join) return;
@@ -1677,7 +1729,7 @@ class BeanModelUtils extends BeanModelMeta {
     this.buildHaving(builder, having);
   }
   buildHaving(builder, having) {
-    return buildWhere(this.connection, builder, having, true);
+    return buildWhere(this.db, builder, having, true);
   }
   prepareWhere(builder, table, where, options) {
     // table
@@ -1958,7 +2010,9 @@ class BeanModelCrudInner extends BeanModelView {
     builder = builder ?? this._select_buildParams(table, params, options);
     // ready
     this.$loggerChild('model').debug(() => `model.select: ${builder.toQuery()}`);
-    return await builder;
+    // datas
+    const datas = await builder;
+    return await this.dialect.select(builder, datas, () => this.columns(table));
   }
   _select_buildParams(table, params, options) {
     // builder
@@ -3718,9 +3772,10 @@ function config(_app) {
       expired: 14 * 24 * 3600 * 1000
     },
     dialects: {
-      mysql: 'a-ormdialect.databaseDialect.mysql',
-      mysql2: 'a-ormdialect.databaseDialect.mysql3',
-      pg: 'a-ormdialect.databaseDialect.pg'
+      'better-sqlite3': 'a-ormdialect:betterSqlite3',
+      'mysql': 'a-ormdialect:mysql',
+      'mysql2': 'a-ormdialect:mysql3',
+      'pg': 'a-ormdialect:pg'
     },
     summer: {
       enable: true,
@@ -3763,7 +3818,7 @@ function ExtendSchemaBuilder(app) {
   ['fetchDatabases', 'createDatabase', 'dropDatabase', 'fetchIndexes'].forEach(method => {
     knex.SchemaBuilder.extend(method, async function (...args) {
       const client = cast(cast(this).client).config.client;
-      const dialect = app.scope('a-orm').service.database.getDialect(client);
+      const dialect = app.bean.database.getDialect(client);
       return await dialect[method](this, ...args);
     });
   });
@@ -3911,8 +3966,8 @@ function $locale(key) {
 }
 /** scope: end */
 
-function DatabaseDialect() {
-  return createBeanDecorator('databaseDialect');
+function DatabaseDialect(options) {
+  return createBeanDecorator('databaseDialect', options);
 }
 
 function DtoAggregate(modelLike, aggrs) {

package/dist/lib/databaseDialect.d.ts

@@ -1 +1,2 @@
-export declare function DatabaseDialect(): ClassDecorator;
+import type { IDecoratorDatabaseDialectOptions } from '../types/index.ts';
+export declare function DatabaseDialect<T extends IDecoratorDatabaseDialectOptions>(options?: T): ClassDecorator;

package/dist/service/database.d.ts

@@ -4,10 +4,9 @@ import type { IDatabaseClientDialectRecord, IDatabaseClientRecord, IDbInfo } fro
 import { BeanBase } from 'vona';
 export declare class ServiceDatabase extends BeanBase {
     get configDatabase(): import("../types/config.ts").ConfigDatabase;
-    getDialect(client: keyof IDatabaseClientDialectRecord): BeanDatabaseDialectBase;
-    getClientConfig(clientName: keyof IDatabaseClientRecord, original?: boolean): ConfigDatabaseClient;
+    getClientConfig(clientName: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient, original?: boolean): ConfigDatabaseClient;
     prepareDbInfo(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): IDbInfo;
-    prepareClientNameSelector(dbInfo: IDbInfo): string;
+    prepareClientNameSelector(dbInfo: IDbInfo, dialect: BeanDatabaseDialectBase | keyof IDatabaseClientDialectRecord): string;
     parseClientNameSelector(clientNameSelector: string): IDbInfo;
     prepareClientName(clientName?: keyof IDatabaseClientRecord): keyof IDatabaseClientRecord;
     getDefaultClientName(): keyof IDatabaseClientRecord;

package/dist/service/transactionState_.d.ts

@@ -1,11 +1,11 @@
 import type knex from 'knex';
-import type { IDbInfo } from '../types/index.ts';
+import type { ServiceDb } from './db_.ts';
 import { BeanBase } from 'vona';
 import { ServiceTransactionFiber } from './transactionFiber_.ts';
 export declare class ServiceTransactionState extends BeanBase {
     private _fibers;
     private get serviceDatabase();
-    get(dbInfo: IDbInfo): ServiceTransactionFiber | undefined;
-    add(dbInfo: IDbInfo, connection: knex.Knex.Transaction): ServiceTransactionFiber;
-    remove(dbInfo: IDbInfo): void;
+    get(db: ServiceDb): ServiceTransactionFiber | undefined;
+    add(db: ServiceDb, connection: knex.Knex.Transaction): ServiceTransactionFiber;
+    remove(db: ServiceDb): void;
 }

package/dist/types/config.d.ts

@@ -1,6 +1,7 @@
 import type { Knex } from 'knex';
 import type { VonaContext } from 'vona';
 import type { IDatabaseClientDialectRecord, IDatabaseClientRecord } from './database.ts';
+import type { IDatabaseDialectRecord } from './onion/databaseDialect.ts';
 export type TypeDefaultClientNameFn = (ctx?: VonaContext) => keyof IDatabaseClientRecord;
 export type TypeDefaultClientName = TypeDefaultClientNameFn | keyof IDatabaseClientRecord;
 export interface ConfigDatabaseClient extends Omit<Knex.Config, 'client'> {
@@ -12,3 +13,6 @@ export interface ConfigDatabase {
     clients: Record<keyof IDatabaseClientRecord, ConfigDatabaseClient>;
     base: ConfigDatabaseClient;
 }
+export type IDataBaseConfigDialects = {
+    [KEY in keyof IDatabaseClientDialectRecord]: keyof IDatabaseDialectRecord;
+};

package/dist/types/database.d.ts

@@ -8,13 +8,15 @@ export interface IDbInfo {
 }
 export interface IDatabaseClientRecord {
     default: never;
+    sqlite3: never;
     pg: never;
     mysql: never;
 }
 export interface IDatabaseClientDialectRecord {
-    pg: never;
-    mysql: never;
-    mysql2: never;
+    'better-sqlite3': never;
+    'pg': never;
+    'mysql': never;
+    'mysql2': never;
 }
 export interface IDatabaseSwitchOptions {
     clientName?: keyof IDatabaseClientRecord;
@@ -33,6 +35,8 @@ declare module 'vona' {
     }
     interface VonaConfigEnv {
         DATABASE_DEFAULT_CLIENT: string | undefined;
+        DATABASE_CLIENT_SQLITE3_FILENAME: string | undefined;
+        DATABASE_CLIENT_SQLITE3_NATIVEBINDING: string | undefined;
         DATABASE_CLIENT_PG_HOST: string | undefined;
         DATABASE_CLIENT_PG_PORT: string | undefined;
         DATABASE_CLIENT_PG_USER: string | undefined;

package/dist/types/dialect.d.ts

@@ -1,6 +1,12 @@
+import type { ITableColumns } from './columns.ts';
 export interface IFetchDatabasesResultItem {
     name: string;
 }
 export interface IFetchIndexesResultItem {
     indexName: string;
 }
+export type TypeDatabaseDialectTableColumnsFn = () => Promise<ITableColumns>;
+export interface IDatabaseDialectCapabilities {
+    ilike: boolean;
+    level: boolean;
+}

package/dist/types/onion/databaseDialect.d.ts

@@ -1,3 +1,4 @@
+import type { OmitNever } from 'vona';
 import type { ServiceOnion } from 'vona-module-a-onion';
 export interface IDatabaseDialectRecord {
 }
@@ -10,6 +11,7 @@ declare module 'vona-module-a-onion' {
 }
 declare module 'vona' {
     interface ConfigOnions {
+        databaseDialect: OmitNever<IDatabaseDialectRecord>;
     }
     interface IBeanSceneRecord {
         databaseDialect: never;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-orm",
   "type": "module",
-  "version": "5.0.84",
+  "version": "5.0.86",
   "title": "a-orm",
   "vonaModule": {
     "capabilities": {
@@ -33,6 +33,8 @@
       },
       "databaseDialect": {
         "beanGeneral": true,
+        "optionsGlobalInterfaceName": "IDecoratorDatabaseDialectOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-orm",
         "boilerplate": "cli/databaseDialect/boilerplate"
       }
     }