vona-module-a-orm 5.1.8 → 5.1.12

package/dist/index.js

@@ -1,17 +1,16 @@
 import BigNumber from 'bignumber.js';
-import { BeanInfo, BeanAopMethodBase, BeanBase, deepExtend, appResource, beanFullNameFromOnionName, Virtual, cast, useApp, $makeLocaleMagic, disposeInstance, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class } from 'vona';
+import { BeanInfo, BeanAopMethodBase, BeanBase, deepExtend, appResource, beanFullNameFromOnionName, cast, useApp, $makeLocaleMagic, Virtual, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class, disposeInstance } from 'vona';
 import { __decorate, __metadata } from 'tslib';
 import { AopMethod } from 'vona-module-a-aspect';
 import { Service, Bean, Scope } from 'vona-module-a-bean';
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
-import { isNil, catchError, safeBoolean, ensureArray, hashkey } from '@cabloy/utils';
+import { isNil, catchError, ensureArray, safeBoolean, hashkey } from '@cabloy/utils';
 import knex from 'knex';
 import { BeanMutateBase } from 'vona-module-a-beanmutate';
 import { swapDeps } from '@cabloy/deps';
 import { $tableNameFromEntity, $tableDefaults, $columnsAll } from 'vona-module-a-ormutils';
 import { prepareClassType, Api, v, schemaRenderVisible, getSchemaDynamic, SymbolSchemaDynamicRefId, addSchemaDynamic, mergeDtoFieldsOpenapiMetadata } from 'vona-module-a-openapiutils';
 import z from 'zod';
-import { parseFirstWord, toLowerCaseFirstChar } from '@cabloy/word-utils';
 import { Broadcast, BeanBroadcastBase } from 'vona-module-a-broadcast';
 import { Event, BeanEventBase } from 'vona-module-a-event';
 import { Hmr } from 'vona-module-a-hmrbase';
@@ -20,6 +19,7 @@ import { Schedule } from 'vona-module-a-schedule';
 import { configAll, configRedis } from 'vona-module-a-summer';
 import { ServiceDatabaseAsyncLocalStorage as ServiceDatabaseAsyncLocalStorage$1, ServiceTransactionConsistency‌ as ServiceTransactionConsistency_ } from 'vona-module-a-orm';
 import { mutate } from 'mutate-on-copy';
+import { parseFirstWord, toLowerCaseFirstChar } from '@cabloy/word-utils';
 
 let AopMethodTransaction = class AopMethodTransaction extends BeanAopMethodBase {
   execute(options, _args, next, _receiver, _prop) {
@@ -769,131 +769,6 @@ BeanDatabase = __decorate([Bean(), BeanInfo({
   module: "a-orm"
 })], BeanDatabase);
 
-let BeanDatabaseDialectBase = class BeanDatabaseDialectBase extends BeanBase {
-  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');
-  }
-  async createDatabase(_schemaBuilder, _databaseName) {
-    throw new Error('Not Implemented');
-  }
-  async dropDatabase(_schemaBuilder, _databaseName) {
-    throw new Error('Not Implemented');
-  }
-  async fetchIndexes(_schemaBuilder, _tableName) {
-    throw new Error('Not Implemented');
-  }
-  async insert(_builder, _datas) {
-    throw new Error('Not Implemented');
-  }
-  async select(_builder, datas, _fn) {
-    return datas;
-  }
-  query(_result) {
-    throw new Error('Not Implemented');
-  }
-  async viewDependents(_builder, _viewName) {
-    throw new Error('Not Implemented');
-  }
-  coerceColumn(column) {
-    // result
-    const result = {
-      type: column.type
-    };
-    // coerce
-    result.default = this._coerceColumnValue(column.type, column.defaultValue);
-    // 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' && !isNil(value) && typeof value === 'string') {
-            data[columnName] = JSON.parse(value);
-          } else if (column.type === 'datetime' && !isNil(value)) {
-            data[columnName] = new Date(value);
-          }
-        }
-      }
-    }
-    return datas;
-  }
-  async insertAsMysql(builder, datas) {
-    if (datas.length === 0) return [[], builder];
-    if (isNil(datas[0].id)) {
-      let builderFirst = undefined;
-      const ids = [];
-      for (const data of datas) {
-        const builder2 = builder.clone();
-        builder2.insert(data);
-        const items = await builder2;
-        ids.push(items[0]);
-        if (!builderFirst) builderFirst = builder2;
-      }
-      return [ids, builderFirst ?? builder];
-    } else {
-      builder.insert(datas);
-      await builder;
-      return [datas.map(item => item.id), builder];
-    }
-  }
-  async insertAsPg(builder, datas) {
-    if (datas.length === 0) return [[], builder];
-    if (isNil(datas[0].id)) {
-      builder.insert(datas).returning('id');
-      const items = await builder;
-      return [items.map(item => item.id), builder];
-    } else {
-      builder.insert(datas);
-      await builder;
-      return [datas.map(item => item.id), builder];
-    }
-  }
-  _coerceColumnValue(type, value) {
-    // null
-    if (isNil(value)) return undefined;
-    // type
-    if (['bit', 'bool', 'boolean'].includes(type)) return safeBoolean(value);
-    if (['int'].includes(type)) return this._safeNumber(value);
-    if (this._columnTypePrefixes(type, ['timestamp']) && value === 'CURRENT_TIMESTAMP') return undefined; // new Date();
-    if (this._columnTypePrefixes(type, ['float', 'double'])) return this._safeNumber(value);
-    if (this._columnTypePrefixes(type, ['tinyint', 'smallint', 'mediumint', 'bigint', 'numeric', 'integer'])) {
-      return this._safeNumber(value);
-    }
-    // pg: NULL::character varying
-    if (value.indexOf('NULL::') === 0) return undefined;
-    // others
-    return value;
-  }
-  // pg: nextval
-  _safeNumber(value) {
-    const num = Number(value);
-    return Number.isNaN(num) ? undefined : num;
-  }
-  _columnTypePrefixes(type, prefixes) {
-    return prefixes.some(prefix => type.includes(prefix));
-  }
-};
-BeanDatabaseDialectBase = __decorate([Bean(), Virtual(), BeanInfo({
-  module: "a-orm"
-})], BeanDatabaseDialectBase);
-
 const OpAggrs = ['count', 'sum', 'avg', 'max', 'min'];
 const OpJoint = {
   and: '_and_',
@@ -926,7 +801,7 @@ const OpNormal = {
   ref: '_ref_'
 };
 const Op = {
-  skip: '_skip_',
+  omit: undefined,
   ...OpJoint,
   ...OpNormal
 };
@@ -994,8 +869,8 @@ function buildWhere(db, builder, wheres, having = false) {
   _buildWhereInner(having, db, builder, wheres);
 }
 function _buildWhereInner(having, db, builder, wheres, column) {
-  // skip
-  if (wheres === Op.skip) {
+  // omit
+  if (wheres === Op.omit) {
     return;
   }
   // raw
@@ -1024,8 +899,8 @@ function _buildWhereInner(having, db, builder, wheres, column) {
   }
 }
 function _buildWhereOpJoint(having, db, builder, column, wheres, op) {
-  // skip
-  if (wheres === Op.skip) {
+  // omit
+  if (wheres === Op.omit) {
     return;
   }
   // and/or
@@ -1072,8 +947,8 @@ function _buildWhereOpJoint(having, db, builder, column, wheres, op) {
   }
 }
 function _buildWhereColumn(having, db, builder, column, value, op) {
-  // skip
-  if (value === Op.skip) {
+  // omit condition
+  if (value === Op.omit) {
     return;
   }
   // raw
@@ -1081,8 +956,8 @@ function _buildWhereColumn(having, db, builder, column, value, op) {
     _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.eq);
     return;
   }
-  // null/undefined
-  if (isNil(value)) {
+  // null
+  if (value === null) {
     _buildWhereColumnOpNormal(having, db, builder, column, value, op ?? Op.is);
     return;
   }
@@ -2273,6 +2148,165 @@ ServiceCacheQuery = __decorate([Service(), BeanInfo({
   module: "a-orm"
 })], ServiceCacheQuery);
 
+const BOOLEAN_COLUMN_TYPES = ['bit', 'bool', 'boolean'];
+const NUMBER_COLUMN_TYPES = ['int'];
+const TIMESTAMP_COLUMN_TYPE_PREFIXES = ['timestamp'];
+const FLOAT_COLUMN_TYPE_PREFIXES = ['float', 'double'];
+const INTEGER_COLUMN_TYPE_PREFIXES = ['tinyint', 'smallint', 'mediumint', 'bigint', 'numeric', 'integer'];
+let ServiceDatabaseDialectBase = class ServiceDatabaseDialectBase extends BeanBase {
+  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');
+  }
+  async createDatabase(_schemaBuilder, _databaseName) {
+    throw new Error('Not Implemented');
+  }
+  async dropDatabase(_schemaBuilder, _databaseName) {
+    throw new Error('Not Implemented');
+  }
+  async fetchIndexes(_schemaBuilder, _tableName) {
+    throw new Error('Not Implemented');
+  }
+  async insert(_builder, _datas) {
+    throw new Error('Not Implemented');
+  }
+  async select(_builder, datas, _fn) {
+    return datas;
+  }
+  query(_result) {
+    throw new Error('Not Implemented');
+  }
+  async viewDependents(_builder, _viewName) {
+    throw new Error('Not Implemented');
+  }
+  coerceColumn(column) {
+    const result = {
+      type: column.type
+    };
+    result.default = this._coerceColumnValue(column.type, column.defaultValue);
+    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' && !isNil(value) && typeof value === 'string') {
+            data[columnName] = JSON.parse(value);
+          } else if (column.type === 'datetime' && !isNil(value)) {
+            data[columnName] = new Date(value);
+          }
+        }
+      }
+    }
+    return datas;
+  }
+  async insertAsMysql(builder, datas) {
+    if (datas.length === 0) return [[], builder];
+    if (!isNil(datas[0].id)) {
+      builder.insert(datas);
+      await builder;
+      return [datas.map(item => item.id), builder];
+    }
+    let builderFirst = undefined;
+    const ids = [];
+    for (const data of datas) {
+      const builder2 = builder.clone();
+      builder2.insert(data);
+      const items = await builder2;
+      ids.push(items[0]);
+      if (!builderFirst) builderFirst = builder2;
+    }
+    return [ids, builderFirst ?? builder];
+  }
+  async insertAsPg(builder, datas) {
+    if (datas.length === 0) return [[], builder];
+    if (!isNil(datas[0].id)) {
+      builder.insert(datas);
+      await builder;
+      return [datas.map(item => item.id), builder];
+    }
+    builder.insert(datas).returning('id');
+    const items = await builder;
+    return [items.map(item => item.id), builder];
+  }
+  _coerceColumnValue(type, value) {
+    if (isNil(value)) return undefined;
+    if (BOOLEAN_COLUMN_TYPES.includes(type)) return safeBoolean(value);
+    if (NUMBER_COLUMN_TYPES.includes(type)) return this._safeNumber(value);
+    if (this._columnTypePrefixes(type, TIMESTAMP_COLUMN_TYPE_PREFIXES) && value === 'CURRENT_TIMESTAMP') {
+      return undefined; // new Date();
+    }
+    if (this._columnTypePrefixes(type, FLOAT_COLUMN_TYPE_PREFIXES)) return this._safeNumber(value);
+    if (this._columnTypePrefixes(type, INTEGER_COLUMN_TYPE_PREFIXES)) return this._safeNumber(value);
+    // pg: NULL::character varying
+    if (value.indexOf('NULL::') === 0) return undefined;
+    return value;
+  }
+  // pg: nextval
+  _safeNumber(value) {
+    const num = Number(value);
+    return Number.isNaN(num) ? undefined : num;
+  }
+  _columnTypePrefixes(type, prefixes) {
+    return prefixes.some(prefix => type.includes(prefix));
+  }
+};
+ServiceDatabaseDialectBase = __decorate([Service(), Virtual(), BeanInfo({
+  module: "a-orm"
+})], ServiceDatabaseDialectBase);
+
+const SymbolModuleScope$1 = Symbol('SymbolModuleScope');
+let ServiceEntityResolver = class ServiceEntityResolver extends BeanBase {
+  constructor(moduleScope) {
+    super();
+    this[SymbolModuleScope$1] = void 0;
+    this.__instances = {};
+    this[SymbolModuleScope$1] = moduleScope;
+  }
+  __get__(prop) {
+    if (!this.__instances[prop]) {
+      const beanFullName = `${this[SymbolModuleScope$1]}.entity.${prop}`;
+      const beanOptions = appResource.getBean(beanFullName);
+      this.__instances[prop] = $columnsAll(beanOptions.beanClass, true, true);
+    }
+    return this.__instances[prop];
+  }
+};
+ServiceEntityResolver = __decorate([Service(), __metadata("design:paramtypes", [String]), BeanInfo({
+  module: "a-orm"
+})], ServiceEntityResolver);
+
+const SymbolModuleScope = Symbol('SymbolModuleScope');
+let ServiceModelResolver = class ServiceModelResolver extends BeanBase {
+  constructor(moduleScope) {
+    super();
+    this[SymbolModuleScope] = void 0;
+    this[SymbolModuleScope] = moduleScope;
+  }
+  __get__(prop) {
+    const beanFullName = `${this[SymbolModuleScope]}.model.${prop}`;
+    return this.bean._getBean(beanFullName);
+  }
+};
+ServiceModelResolver = __decorate([Service(), __metadata("design:paramtypes", [String]), BeanInfo({
+  module: "a-orm"
+})], ServiceModelResolver);
+
 function handleRelationsCollection(relationsStatic, includeWrapper) {
   // collect
   const relations = [];
@@ -2856,1379 +2890,1347 @@ ServiceRelations = __decorate([Service(), BeanInfo({
   module: "a-orm"
 })], ServiceRelations);
 
-class BeanModelCrud extends BeanModelCrudInner {
-  async mget(ids, options) {
-    return await this._mget(undefined, ids, options);
-  }
-  async select(params, options) {
-    return await this._select(undefined, params, options);
-  }
-  async get(where, options) {
-    return await this._get(undefined, where, options);
-  }
-  async count(params, options) {
-    return await this._count(undefined, params, options);
-  }
-  async insert(data, options) {
-    return await this._insertBulk(undefined, data, options);
+let BroadcastColumnsClear = class BroadcastColumnsClear extends BeanBroadcastBase {
+  async execute(data, isEmitter) {
+    const {
+      clientName,
+      tableName
+    } = data;
+    if (!isEmitter) {
+      await cast(this.scope.service.database).columnsClearWorker(clientName, tableName);
+    }
   }
-  async insertBulk(data, options) {
-    return await this._insertBulk(undefined, data, options);
-  }
-  async update(data, options) {
-    return await this._update(undefined, data, options);
-  }
-  async delete(where, options) {
-    return await this._delete(undefined, where, options);
+};
+BroadcastColumnsClear = __decorate([Broadcast(), BeanInfo({
+  module: "a-orm"
+})], BroadcastColumnsClear);
+
+let EventClientNameReal = class EventClientNameReal extends BeanEventBase {};
+EventClientNameReal = __decorate([Event(), BeanInfo({
+  module: "a-orm"
+})], EventClientNameReal);
+
+let EventColumnsClear = class EventColumnsClear extends BeanEventBase {};
+EventColumnsClear = __decorate([Event(), BeanInfo({
+  module: "a-orm"
+})], EventColumnsClear);
+
+let HmrEntity = class HmrEntity extends BeanBase {
+  async reload(_beanOptions) {
+    this.app.bean.worker.reload();
   }
-}
+};
+HmrEntity = __decorate([Hmr(), BeanInfo({
+  module: "a-orm"
+})], HmrEntity);
 
-class BeanModelCache extends BeanModelCrud {
-  constructor(...args) {
-    super(...args);
-    this.cacheQuery = void 0;
-    this.cacheEntity = void 0;
-    this.relations = void 0;
+// import { clearAllCacheModelsClear, clearCacheModelCacheInstance } from '../lib/const.ts';
+let HmrModel = class HmrModel extends BeanBase {
+  async reload(_beanOptions) {
+    // more deps: dto/model
+    this.app.bean.worker.reload();
+    // clearAllCacheModelsClear(this.app);
+    // await clearCacheModelCacheInstance(this.app, beanOptions.beanFullName);
   }
-  __init__(clientName, table) {
-    super.__init__(clientName, table);
-    this.cacheQuery = this.bean._newBean(ServiceCacheQuery, this);
-    this.cacheEntity = this.bean._newBean(ServiceCacheEntity, this);
-    this.relations = this.bean._newBean(ServiceRelations, this);
+};
+HmrModel = __decorate([Hmr(), BeanInfo({
+  module: "a-orm"
+})], HmrModel);
+
+let QueueDoubleDelete = class QueueDoubleDelete extends BeanQueueBase {
+  async execute(data, _options) {
+    const beanInstance = this.app.bean._newBean(data.beanFullName, data.clientName, data.table);
+    await beanInstance[data.method](...data.args);
   }
-  async __dispose__() {
-    await disposeInstance(this.cacheQuery);
-    await disposeInstance(this.cacheEntity);
+};
+QueueDoubleDelete = __decorate([Queue({
+  options: {
+    job: {
+      delay: 3 * 1000
+    }
   }
-  async insert(data, options) {
-    if (!data) data = {};
-    const items = await this.insertBulk([data], options);
-    return items[0];
+}), BeanInfo({
+  module: "a-orm"
+})], QueueDoubleDelete);
+
+let ScheduleSoftDeletionPrune = class ScheduleSoftDeletionPrune extends BeanBase {
+  async execute() {
+    const onionSlices = this.bean.onion.model.getOnionsEnabledCached();
+    for (const onionSlice of onionSlices) {
+      if (onionSlice.beanOptions.options?.disableDeleted) continue;
+      let softDeletionPrune = onionSlice.beanOptions.options?.softDeletionPrune ?? this.scope.config.softDeletionPrune.enable;
+      if (!softDeletionPrune) continue;
+      if (softDeletionPrune === true) softDeletionPrune = {};
+      await this._modulePrune(onionSlice, softDeletionPrune);
+    }
   }
-  async insertBulk(items, options) {
-    const itemsResult = await this.__insertBulk_raw(undefined, items, options);
-    const itemsNew = items.map((item, index) => {
-      return Object.assign({}, item, {
-        id: cast(itemsResult[index]).id
+  async _modulePrune(onionSlice, softDeletionPrune) {
+    const handler = softDeletionPrune.handler;
+    const expired = softDeletionPrune.expired ?? this.scope.config.softDeletionPrune.expired;
+    const modelTarget = this.bean._getBean(onionSlice.beanOptions.beanFullName);
+    if (handler) {
+      await handler(this.ctx, modelTarget, {
+        expired
       });
-    });
-    return await this.relations.handleRelationsMutate(itemsResult, itemsNew, options, options);
-  }
-  async __insertBulk_raw(table, items, options) {
-    if (items.length === 0) return [];
-    // table
-    table = table || this.getTable(items[0]);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // insert
-    const res = await this._insertBulk(table, items, options);
-    // delete cache
-    const ids = res.map(item => cast(item).id);
-    await this.cacheEntityDel(ids, table);
-    return res;
-  }
-  async mutate(data, options) {
-    if (!data) data = {};
-    const items = await this.mutateBulk([data], options);
-    return items[0];
-  }
-  async mutateBulk(items, options) {
-    return await this.__mutateBulk_raw(undefined, items, options);
-  }
-  async __mutateBulk_raw(table, items, options) {
-    // table
-    table = table || this.getTable(items[0]);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check
-    const indexesInsert = [];
-    const indexesUpdate = [];
-    const itemsInsert = [];
-    const itemsUpdate = [];
-    const itemsDelete = [];
-    for (let index = 0; index < items.length; index++) {
-      const item = items[index];
-      if (cast(item).deleted) {
-        if (!isNil(cast(item).id)) {
-          itemsDelete.push(item);
+    } else {
+      const expiredTime = new Date(Date.now() - expired);
+      await modelTarget.delete({
+        deleted: true,
+        updatedAt: {
+          _lt_: expiredTime
         }
-      } else if (!isNil(cast(item).id)) {
-        itemsUpdate.push(item);
-        indexesUpdate.push(index);
-      } else {
-        itemsInsert.push(item);
-        indexesInsert.push(index);
-      }
-    }
-    // insert/update
-    const itemsInsertNew = await this.__insertBulk_raw(table, itemsInsert, options);
-    await this.__updateBulk_raw(table, itemsUpdate, options);
-    const itemsMutate = itemsInsert.map((item, index) => {
-      return Object.assign({}, item, {
-        id: cast(itemsInsertNew[index]).id
+      }, {
+        disableDeleted: true
       });
-    }).concat(itemsUpdate);
-    let itemsMutateResult = itemsInsertNew.concat(itemsUpdate);
-    const indexesMutate = indexesInsert.concat(indexesUpdate);
-    itemsMutateResult = await this.relations.handleRelationsMutate(itemsMutateResult, itemsMutate, options, options);
-    let result = [];
-    for (let index = 0; index < indexesMutate.length; index++) {
-      result[indexesMutate[index]] = itemsMutateResult[index];
     }
-    result = result.filter(item => !!item); // fitler deleted items
-    // delete
-    const idsDelete = itemsDelete.map(item => cast(item).id);
-    await this.__deleteBulk_raw_with_relations(table, idsDelete, options);
-    // ok
-    return result;
   }
-  async mget(ids, options) {
-    if (ids.length === 0) return [];
-    const relations = this.relations.handleRelationsCollection(options);
-    const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
-    let items = await this.__mget_raw(undefined, ids, options2);
-    if (items.length === 0) return items;
-    items = await this.relations.handleRelationsMany(relations, items, options, options);
-    if (refKeys) {
-      for (const item of items) {
-        for (const refKey of refKeys) {
-          delete item[refKey];
+};
+ScheduleSoftDeletionPrune = __decorate([Schedule({
+  repeat: {
+    every: 24 * 3600 * 1000
+  }
+}), BeanInfo({
+  module: "a-orm"
+})], ScheduleSoftDeletionPrune);
+
+function config(_app) {
+  return {
+    sharding: {
+      cache: {
+        doubleDelete: true
+      }
+    },
+    rest: {
+      query: {
+        pageSize: {
+          default: 20,
+          max: 100
+        },
+        orders: {
+          default: 'createdAt,desc'
         }
       }
-    }
-    return items;
-  }
-  async __mget_raw(table, ids, options) {
-    // table
-    table = table || this.getTable(undefined);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check if cache
-    if (this._checkDisableCacheEntityByOptions(options)) {
-      return await super._mget(table, ids, options);
-    }
-    // cache
-    const cache = this.cacheEntity.getInstance(table);
-    let items = await cache.mget(ids, {
-      mget: async ids => {
-        return await super._mget_original(table, ids, {
-          disableDeleted: true
-        });
+    },
+    table: {
+      identityType: 'bigint'
+    },
+    model: {
+      disableDeleted: false,
+      disableInstance: false,
+      disableCreateTime: false,
+      disableUpdateTime: false
+    },
+    softDeletionPrune: {
+      enable: true,
+      expired: 14 * 24 * 3600 * 1000
+    },
+    dialects: {
+      'better-sqlite3': 'a-ormdialect:betterSqlite3',
+      'mysql': 'a-ormdialect:mysql',
+      'mysql2': 'a-ormdialect:mysql3',
+      'pg': 'a-ormdialect:pg'
+    },
+    summer: {
+      enable: true,
+      meta: {},
+      presetDefault: 'redis',
+      preset: {
+        redis: configRedis,
+        all: configAll
       },
-      db: this.db
-    });
-    // filter disableDeleted
-    items = items.filter(item => {
-      if (!item) return false;
-      if (!this._checkIfEntityValidByDeleted(item, options)) return false;
-      return true;
-    });
-    return this.__filterMGetColumns(items, options?.columns);
-  }
-  async count(params, options, _modelJoins) {
-    const column = params?.column ?? '*';
-    const params2 = Object.assign({}, params, {
-      aggrs: {
-        count: column
-      },
-      column: undefined
-    });
-    const item = await this.aggregate(params2, options);
-    return this.extractFirstValue(item);
-  }
-  async increment(params, options, _modelJoins) {
-    return await this.__increment_raw(undefined, params, options);
-  }
-  async decrement(params, options, _modelJoins) {
-    const columns = {};
-    for (const key in params.columns) {
-      columns[key] = -params.columns[key];
+      redis: {
+        client: 'model'
+      }
+    },
+    logger: {
+      maxLength: 256
     }
-    const params2 = Object.assign({}, params, {
-      columns
+  };
+}
+
+const errors = {
+  ShouldSpecifyTable: 1001
+};
+
+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.bean.database.getDialect(client);
+      return await dialect[method](this, ...args);
     });
-    return await this.__increment_raw(undefined, params2, options);
-  }
-  async __increment_raw(table, params, options) {
-    // table
-    table = table || this.getTable(params?.where);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check if cache
-    if (this._checkDisableCacheEntityByOptions(options)) {
-      return await super._increment(table, params, options);
-    }
-    const where = params?.where;
-    const items = await this.__select_raw(table, {
-      where,
-      columns: ['id']
-    }, options);
-    if (items.length === 0) {
-      // donothing
-      return 0;
+  });
+}
+
+const __ThisModule__ = 'a-orm';
+
+function ExtendTableBuilder(app) {
+  const scope = app.scope(__ThisModule__);
+  function _basicFields(options, identityType) {
+    options = options || {};
+    if (options.id !== false) {
+      const _identityType = identityType ?? scope.config.table.identityType;
+      if (_identityType === 'bigint') {
+        this.bigIncrements();
+      } else if (_identityType === 'number') {
+        this.increments();
+      } else {
+        throw new Error('Should create column id by yourself');
+      }
     }
-    let id;
-    if (items.length === 1) {
-      id = cast(items[0]).id;
+    if (options.timestamps !== false) this.timestamps(true, true, true);
+    if (options.deleted !== false) this.boolean('deleted').defaultTo(false);
+    if (options.iid !== false) this.integer('iid').defaultTo(0);
+    return this;
+  }
+  knex.TableBuilder.extend('basicFields', function (options) {
+    _basicFields.call(this, options, undefined);
+    return this;
+  });
+  knex.TableBuilder.extend('basicFieldsSimple', function (options) {
+    _basicFields.call(this, options, 'number');
+    return this;
+  });
+  knex.TableBuilder.extend('tableIdentity', function (columnName) {
+    const _identityType = scope.config.table.identityType;
+    if (_identityType === 'bigint') {
+      return this.bigInteger(columnName); // default value is null
+    } else if (_identityType === 'number') {
+      return this.integer(columnName); // default value is null
     } else {
-      id = items.map(item => cast(item).id);
+      throw new Error(`Should create column ${columnName} by yourself`);
     }
-    // update by id/ids
-    params = Object.assign({}, params, {
-      where: {
-        id
-      }
+  });
+  knex.TableBuilder.extend('userId', function (columnName) {
+    return this.tableIdentity(columnName ?? 'userId');
+  });
+  knex.TableBuilder.extend('int0', function (columnName) {
+    return this.integer(columnName).defaultTo(0);
+  });
+  knex.TableBuilder.extend('int1', function (columnName) {
+    return this.integer(columnName).defaultTo(1);
+  });
+  ['description'].forEach(method => {
+    knex.TableBuilder.extend(method, function (length = 255) {
+      return this.string(method, length);
     });
-    const res = await this._increment(table, params, options);
-    // delete cache
-    await this.cacheEntityDel(id, table);
-    return res;
-  }
-  async aggregate(params, options, _modelJoins) {
-    const items = await this.__aggregate_raw(undefined, params, options);
-    return items[0];
-  }
-  async __aggregate_raw(table, params, options) {
-    // table
-    table = table || this.getTable(params?.where);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    const items = await this.__select_cache(table, params, options);
-    return items;
-  }
-  async group(params, options, _modelJoins) {
-    return await this.__group_raw(undefined, params, options);
-  }
-  async __group_raw(table, params, options) {
-    // table
-    table = table || this.getTable(params?.where);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    const items = await this.__select_cache(table, params, options);
-    return items;
-  }
-  async selectAndCount(params, options, modelJoins) {
-    // pageNo/pageSize
-    const pageSize = params?.limit ?? this.scopeOrm.config.rest.query.pageSize.default;
-    const pageNo = Math.floor((params?.offset ?? 0) / pageSize) + 1;
-    // count
-    const paramsCount = Object.assign({}, params, {
-      columns: undefined,
-      orders: undefined,
-      limit: undefined,
-      offset: undefined
+  });
+  ['content'].forEach(method => {
+    knex.TableBuilder.extend(method, function (useText) {
+      return useText ? this.text(method) : this.json(method);
     });
-    let count = await this.count(paramsCount, options, modelJoins);
-    if (!count) count = '0';
-    // list
-    let list;
-    if (count === '0') {
-      list = [];
-    } else {
-      list = await this.select(params, options, modelJoins);
-    }
-    // pageNo/pageSize/pageCount
-    const pageCount = Math.ceil(BigNumber(count).div(pageSize).toNumber());
-    // ok
-    return {
-      list,
-      total: count,
-      pageCount,
-      pageSize,
-      pageNo
-    };
+  });
+}
+
+function ExtendKnex(app) {
+  ExtendSchemaBuilder(app);
+  ExtendTableBuilder(app);
+}
+
+const SymbolTransactionConsistency = Symbol('SymbolTransactionConsistency');
+class Main extends BeanSimple {
+  async moduleLoading() {
+    // config
+    const _configDefault = await combineConfigDefault(this.app, configDefault, configDev, configProd, configTest);
+    this.app.config.database = deepExtend({}, _configDefault, this.app.config.database);
   }
-  async select(params, options, _modelJoins) {
-    const relations = this.relations.handleRelationsCollection(params);
-    const [params2, refKeys] = this.relations.prepareColumnsByRelations(relations, params);
-    let items = await this.__select_raw(undefined, params2, options);
-    if (items.length === 0) return items;
-    items = await this.relations.handleRelationsMany(relations, items, params, options);
-    if (refKeys) {
-      for (const item of items) {
-        for (const refKey of refKeys) {
-          delete item[refKey];
-        }
+  async moduleLoaded() {
+    // ExtendKnex
+    ExtendKnex(this.app);
+    // db
+    Object.defineProperty(this.app.context, 'db', {
+      enumerable: false,
+      get() {
+        return this.app.bean._getBean(ServiceDatabaseAsyncLocalStorage$1).current;
       }
-    }
-    return items;
-  }
-  async __select_raw(table, params, options) {
-    // table
-    table = table || this.getTable(params?.where);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check if cache
-    if (this._checkDisableCacheEntityByOptions(options)) {
-      return await this.__select_cache(table, params, options);
-    }
-    // 1: select id
-    const columnId = `${table}.id`;
-    const params2 = Object.assign({}, params, {
-      columns: [columnId]
     });
-    const items = await this.__select_cache(table, params2, options);
-    if (items.length === 0) {
-      // donothing
-      return [];
-    }
-    // 1: special check
-    if (params?.columns) {
-      const columnsTarget = Array.isArray(params?.columns) ? params?.columns : [params?.columns];
-      if (this.__checkIfOnlyKey(columnsTarget, table)) {
-        // just return
-        return items;
+    // transactionConsistency
+    Object.defineProperty(this.app.context, 'transactionConsistency', {
+      enumerable: false,
+      get() {
+        if (!this[SymbolTransactionConsistency]) {
+          this[SymbolTransactionConsistency] = this.app.bean._newBean(ServiceTransactionConsistency_);
+        }
+        return this[SymbolTransactionConsistency];
       }
-    }
-    // 2: mget
-    const ids = items.map(item => cast(item).id);
-    const options3 = params?.columns ? Object.assign({}, options, {
-      columns: params?.columns
-    }) : options;
-    return await this.__mget_raw(table, ids, options3);
-  }
-  async __select_cache(table, params, options) {
-    // check if cache
-    if (this._checkDisableCacheQueryByOptions(options)) {
-      return await super._select(table, params, options);
-    }
-    // builder
-    const builder = this._select_buildParams(table, params, options);
-    const sql = builder.toQuery();
-    const key = {
-      sql
-    };
-    // cache
-    const cache = this.cacheQuery.getInstance(table);
-    const items = await cache.get(key, {
-      ...options?.cache,
-      get: async () => {
-        return await super._select(table, params, options, builder);
-      },
-      db: this.db
     });
-    return items;
-  }
-  async get(where, options) {
-    const relations = this.relations.handleRelationsCollection(options);
-    const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
-    let item = await this.__get_raw(undefined, where, options2);
-    if (!item) return item;
-    item = await this.relations.handleRelationsOne(relations, item, options, options);
-    if (refKeys) {
-      for (const refKey of refKeys) {
-        delete item[refKey];
-      }
-    }
-    return item;
-  }
-  async __get_raw(table, where, options) {
-    // table
-    table = table || this.getTable(where);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check if cache
-    if (this._checkDisableCacheEntityByOptions(options)) {
-      return await super._get(table, where, options);
-    }
-    const id = this.__checkCacheKeyValid(where, table);
-    if (isNil(id)) {
-      // not key
-      if (this._checkDisableCacheQueryByOptions(options)) {
-        return await super._get(table, where, options);
+    // commit
+    Object.defineProperty(this.app.context, 'commit', {
+      enumerable: false,
+      get() {
+        return function (cb) {
+          if (this.ctxCaller) {
+            this.ctxCaller.commit(cb);
+          } else {
+            cast(this).transactionConsistency.commit(cb);
+          }
+        };
       }
-      // by cache query
-      // params
-      const params = {
-        where
-      };
-      if (options?.columns) {
-        params.columns = options?.columns;
+    });
+    Object.defineProperty(this.app.context, 'commitsDone', {
+      enumerable: false,
+      get() {
+        return function () {
+          return cast(this).transactionConsistency.commitsDone();
+        };
       }
-      // select
-      const options2 = deepExtend({}, options, {
-        columns: undefined
-      });
-      const items = await this.__select_raw(table, params, options2);
-      return items[0];
+    });
+  }
+  async configLoaded(_config) {}
+}
+async function configDefault(_app) {
+  return {};
+}
+async function configDev(_app) {
+  return {};
+}
+async function configProd(_app) {
+  return {};
+}
+async function configTest(_app) {
+  return {};
+}
+
+let ScopeModuleAOrm = class ScopeModuleAOrm extends BeanScopeBase {};
+ScopeModuleAOrm = __decorate([Scope(), BeanInfo({
+  module: "a-orm"
+})], ScopeModuleAOrm);
+/** scope: end */
+
+function DatabaseDialect(options) {
+  return createBeanDecorator('databaseDialect', options);
+}
+
+function DtoAggregate(modelLike, aggrs) {
+  return _DtoAggregate_raw(modelLike, aggrs);
+}
+function _DtoAggregate_raw(modelLike, aggrs) {
+  class TargetClass {}
+  return _DtoAggregate_inner(TargetClass, modelLike, aggrs);
+}
+function _DtoAggregate_inner(classTarget, _modelLike, aggrs) {
+  for (const key in aggrs) {
+    const columns = ensureArray(aggrs[key]);
+    if (!columns) continue;
+    for (const column of columns) {
+      const column2 = `${key}_${column === '*' ? 'all' : column}`;
+      Api.field(v.optional(), z.string())(classTarget.prototype, column2);
     }
-    // key
-    return this.__filterGetColumns(await this.__get_key(id, table, where, options), options?.columns);
   }
-  async update(data, options) {
-    const ids = await this.__update_raw(undefined, data, options);
-    if (!ids || ids.length !== 1) return data;
-    // only support =1
-    const dataNew = [Object.assign({}, data, {
-      id: ids[0]
-    })];
-    const items = await this.relations.handleRelationsMutate(dataNew, dataNew, options, options);
-    return items[0];
+  return classTarget;
+}
+
+function DtoGroup(modelLike, groups, aggrs, columns) {
+  return _DtoGroup_raw(modelLike, groups, aggrs, columns);
+}
+function _DtoGroup_raw(modelLike, groups, aggrs, columns) {
+  class TargetClass {}
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  const entityClass = getClassEntityFromClassModel(modelClass);
+  // columns/groups
+  const displays = ensureArray(columns ?? groups);
+  if (displays) {
+    PickClassInner(TargetClass, entityClass, displays);
   }
-  async updateBulk(items, options) {
-    await this.__updateBulk_raw(undefined, items, options);
-    return await this.relations.handleRelationsMutate(items, items, options, options);
+  // aggrs
+  if (aggrs) {
+    _DtoAggregate_inner(TargetClass, modelLike, aggrs);
   }
-  async __updateBulk_raw(table, items, options) {
-    if (items.length === 0) return;
-    for (const item of items) {
-      await this.__update_raw(table, item, options);
-    }
+  // ok
+  return TargetClass;
+}
+
+function DtoGet(modelLike, params) {
+  return _DtoGet_raw(modelLike, params);
+}
+function _DtoGet_raw(modelLike, params) {
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  let entityClass = getClassEntityFromClassModel(modelClass);
+  // columns
+  const columns = prepareColumns(params?.columns);
+  // always create a new class, no matter if columns empty
+  entityClass = $Class.pick(entityClass, columns);
+  // relations
+  _DtoGet_relations(modelClass, entityClass, params);
+  return entityClass;
+}
+function _DtoGet_relations(modelClass, entityClass, includeWrapper, mutateTypeTopLevel) {
+  // relations
+  const relations = _DtoGet_relations_collection(modelClass, includeWrapper);
+  if (!relations) return;
+  for (const relation of relations) {
+    _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel);
   }
-  async __update_raw(table, data, options) {
-    // table
-    table = table || this.getTable(data);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check if cache
-    if (this._checkDisableCacheEntityByOptions(options)) {
-      await super._update(table, data, options);
+}
+function _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel) {
+  const [relationName, relationReal, includeReal, withReal, autoload] = relation;
+  const {
+    type,
+    model,
+    options
+  } = relationReal;
+  const modelTarget = prepareClassModel(model);
+  const optionsReal = Object.assign({}, options, {
+    include: includeReal,
+    with: withReal
+  });
+  if (mutateTypeTopLevel) {
+    if (type === 'belongsTo') {
+      // donot mutate
       return;
     }
-    // check where and get id
-    let id = this.__checkCacheKeyValid(data, table, true);
-    if (!options?.where) {
-      if (isNil(id)) {
-        throw new Error('id should be specified for update method');
-      }
-      if (Array.isArray(id) && id.length === 0) return;
-      const id2 = this.__checkCacheKeyValid(data, table, false);
-      if (!isNil(id2)) {
-        // donothing
-        return;
-      }
+    let schema;
+    if (type === 'belongsToMany') {
+      schema = v.array(z.object({
+        id: v.tableIdentity()(),
+        deleted: z.boolean().optional()
+      }));
+    } else if (type === 'hasOne') {
+      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
+      schema = v.lazy(schemaRenderVisible(false), schemaLazy);
+      // optional = true;
     } else {
-      const id2 = this.__checkCacheKeyValid(options?.where, table, false);
-      if (id2) {
-        id = id2;
+      // hasMany
+      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
+      schema = v.array(v.lazy(schemaLazy));
+    }
+    Api.field(v.optional(), schema)(entityClass.prototype, relationName);
+  } else {
+    const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
+    let schema;
+    let optional = false;
+    if (type === 'hasOne' || type === 'belongsTo') {
+      schema = v.lazy(schemaRenderVisible(false), schemaLazy);
+      optional = true;
+    } else {
+      if (optionsReal.groups) {
+        schema = v.array(v.lazy(schemaLazy));
+      } else if (optionsReal.aggrs) {
+        schema = v.lazy(schemaLazy);
+        optional = true;
       } else {
-        const where = !isNil(id) ? Object.assign({}, options?.where, {
-          id
-        }) : options?.where;
-        const options2 = deepExtend({}, options, {
-          where: undefined
-        });
-        const items = await this.__select_raw(table, {
-          where,
-          columns: ['id']
-        }, options2);
-        if (items.length === 0) {
-          // donothing
-          return;
-        }
-        if (items.length === 1) {
-          id = cast(items[0]).id;
-        } else {
-          id = items.map(item => cast(item).id);
-        }
-        // update by id/ids
-        options = Object.assign({}, options, {
-          where: {
-            id
-          }
-        });
+        schema = v.array(v.lazy(schemaLazy));
       }
     }
-    await super._update(table, data, options);
-    // delete cache
-    await this.cacheEntityDel(id, table);
-    // id
-    return Array.isArray(id) ? id : [id];
-  }
-  async delete(where, options) {
-    const ids = await this.__delete_raw(undefined, where, options);
-    if (!isNil(ids)) {
-      await this.relations.handleRelationsDelete(ids, options, options);
+    if (optional) {
+      Api.field(v.optional(), schema)(entityClass.prototype, relationName);
+    } else {
+      Api.field(schema)(entityClass.prototype, relationName);
     }
   }
-  async deleteBulk(ids, options) {
-    return await this.__deleteBulk_raw_with_relations(undefined, ids, options);
-  }
-  async __deleteBulk_raw_with_relations(table, ids, options) {
-    if (ids.length === 0) return;
-    await this.__delete_raw(table, {
-      id: ids
-    }, options);
-    await this.relations.handleRelationsDelete(ids, options, options);
-  }
-  async __delete_raw(table, where, options) {
-    // table
-    table = table || this.getTable(where);
-    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
-    // check if cache
-    if (this._checkDisableCacheEntityByOptions(options)) {
-      return await super._delete(table, where, options);
+}
+function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation) {
+  return () => {
+    if (!autoload) {
+      return _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
     }
-    // id
-    let id = this.__checkCacheKeyValid(where, table);
-    if (isNil(id)) {
-      // check where and get id
-      const items = await this.__select_raw(table, {
-        where,
-        columns: ['id']
-      }, options);
-      if (items.length === 0) {
-        // donothing
-        return;
-      }
-      if (items.length === 1) {
-        id = cast(items[0]).id;
+    // dynamic
+    const entityClass = getClassEntityFromClassModel(modelTarget);
+    const beanFullName = appResource.getBeanFullName(entityClass);
+    const _hashkey = _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLevel);
+    const dynamicName = `${beanFullName}_${_hashkey}`;
+    let entityTarget = getSchemaDynamic(dynamicName);
+    if (!entityTarget) {
+      entityTarget = _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
+      entityTarget[SymbolSchemaDynamicRefId] = dynamicName;
+      addSchemaDynamic(dynamicName, entityTarget);
+    }
+    return entityTarget;
+  };
+}
+function _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation) {
+  if (mutateTypeTopLevel) {
+    return _DtoMutate_raw(modelTarget, optionsReal, mutateTypeTopLevel, undefined, false, relation); // columnsOmitDefault: undefined
+  } else {
+    if (optionsReal.groups) {
+      return DtoGroup(modelTarget, optionsReal.groups, optionsReal.aggrs, optionsReal.columns);
+    } else if (optionsReal.aggrs) {
+      return DtoAggregate(modelTarget, optionsReal.aggrs);
+    } else {
+      return _DtoGet_raw(modelTarget, optionsReal);
+    }
+  }
+}
+function _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLevel) {
+  const columns = prepareColumns(optionsReal.columns);
+  const aggrs = ensureArray(optionsReal.aggrs);
+  const groups = ensureArray(optionsReal.groups);
+  return columns || aggrs || groups || mutateTypeTopLevel ? hashkey({
+    columns,
+    aggrs,
+    groups,
+    mutate: mutateTypeTopLevel
+  }) : 'none';
+}
+function _DtoGet_relations_collection(modelClass, includeWrapper) {
+  const beanOptions = appResource.getBean(modelClass);
+  const options = beanOptions?.options;
+  return handleRelationsCollection(options?.relations, includeWrapper);
+}
+
+function _DtoMutate_raw(modelLike, params, mutateTypeTopLevel, columnsOmitDefault, topLevel, relation) {
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  let entityClass = getClassEntityFromClassModel(modelClass);
+  // columns
+  let columns = prepareColumns(params?.columns);
+  if (columns) {
+    if (!topLevel) {
+      if (mutateTypeTopLevel === 'create') {
+        for (const key of ['deleted', 'id']) {
+          const index = columns.indexOf(key);
+          if (index > -1) {
+            columns = mutate(columns, copyState => {
+              copyState.splice(index, 1);
+            });
+          }
+        }
       } else {
-        id = items.map(item => cast(item).id);
+        for (const key of ['deleted', 'id']) {
+          if (!columns.includes(key)) {
+            columns = mutate(columns, copyState => {
+              copyState.unshift(key);
+            });
+          }
+        }
       }
     }
-    if (Array.isArray(id) && id.length === 0) return;
-    // delete by id/ids
-    await super._delete(table, {
-      id
-    }, options);
-    // delete cache
-    await this.cacheEntityDel(id, table);
-    // id
-    return Array.isArray(id) ? id : [id];
-  }
-  async __get_key(id, table, where, options) {
-    // cache
-    const cache = this.cacheEntity.getInstance(table);
-    const item = await cache.get(id, {
-      get: async () => {
-        // where: maybe contain aux key
-        return await super._get(table, where, {
-          disableDeleted: true
-        });
-      },
-      db: this.db
-    });
-    if (!item || !this._checkIfEntityValidByDeleted(item, options)) return undefined;
-    return item;
+    entityClass = $Class.pick(entityClass, columns);
+  } else {
+    const columns = columnsOmitDefault ?? (mutateTypeTopLevel === 'create' ? ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] : ['iid', 'createdAt', 'updatedAt']);
+    entityClass = $Class.omit(entityClass, prepareColumns(columns));
   }
-  __filterMGetColumns(items, columns) {
-    if (items.length === 0 || !columns) return items;
-    return items.map(item => {
-      return this.__filterGetColumns(item, columns);
-    });
+  if (!topLevel && mutateTypeTopLevel !== 'create') {
+    entityClass = $Class.partial(entityClass, ['id', 'deleted']);
   }
-  __filterGetColumns(data, columns) {
-    if (!data || !columns) return data;
-    if (!Array.isArray(columns)) columns = cast(columns).split(',');
-    const data2 = {};
-    for (let column of cast(columns)) {
-      column = getTargetColumnName(column);
-      if (column === '*') return data;
-      if (data[column] !== undefined) {
-        data2[column] = data[column];
-      }
+  if (!topLevel && relation) {
+    const [_relationName, relationReal] = relation;
+    const {
+      type,
+      key
+    } = relationReal;
+    if (type === 'hasOne' || type === 'hasMany') {
+      entityClass = $Class.omit(entityClass, key);
     }
-    return data2;
   }
-  async cacheEntityDel(id, table) {
-    await this.cacheEntityDelInner(id, table);
-    this.db.commit(async () => {
-      await this.cacheEntityDelInner(id, table);
-    }, {
-      ignoreIfNotInTransaction: true
+  // relations
+  _DtoGet_relations(modelClass, entityClass, params, mutateTypeTopLevel);
+  return entityClass;
+}
+
+function DtoCreate(modelLike, params) {
+  return _DtoMutate_raw(modelLike, params, 'create', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true, undefined);
+}
+
+function DtoListAndCount(classRef) {
+  class TargetClass {}
+  Api.field(v.array(classRef))(TargetClass.prototype, 'list');
+  Api.field(z.string())(TargetClass.prototype, 'total');
+  Api.field(z.number())(TargetClass.prototype, 'pageCount');
+  Api.field(z.number())(TargetClass.prototype, 'pageSize');
+  Api.field(z.number())(TargetClass.prototype, 'pageNo');
+  return TargetClass;
+}
+
+function DtoQuery(classRef, keys) {
+  return $Class.mixin(DtoQueryBase, $Class.partial($Class.pick(classRef, keys)));
+}
+
+function DtoQueryPage(classRef, keys) {
+  return $Class.mixin(DtoQueryPageBase, $Class.partial($Class.pick(classRef, keys)));
+}
+
+function DtoSelectAndCount(modelLike, params) {
+  const DtoGetResult = DtoGet(modelLike, params);
+  return DtoListAndCount(DtoGetResult);
+}
+
+function DtoUpdate(modelLike, params) {
+  return _DtoMutate_raw(modelLike, params, 'update', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true, undefined);
+}
+// not use Partial/$Class.partial, for form render at frontend
+
+const $Dto = {
+  create: DtoCreate,
+  update: DtoUpdate,
+  get: DtoGet,
+  aggregate: DtoAggregate,
+  group: DtoGroup,
+  query: DtoQuery,
+  queryPage: DtoQueryPage,
+  selectAndCount: DtoSelectAndCount,
+  listAndCount: DtoListAndCount
+};
+
+function Entity(table, options) {
+  if (typeof table === 'string') {
+    options = Object.assign({}, options, {
+      table
     });
-    this._shardingCacheDoubleDelete({
-      beanFullName: this.$beanFullName,
-      clientName: this.db.clientName,
-      table,
-      method: 'cacheEntityDelInner',
-      args: [id, table]
-    });
-  }
-  async cacheEntityDelInner(id, table) {
-    await this.cacheEntity.del(id, table);
-    await this.cacheQueryClearInner(table);
+  } else {
+    options = table || {};
   }
-  async cacheEntityClear(table) {
-    await this.cacheEntityClearInner(table);
-    this.db.commit(async () => {
-      await this.cacheEntityClearInner(table);
-    }, {
-      ignoreIfNotInTransaction: true
-    });
-    this._shardingCacheDoubleDelete({
-      beanFullName: this.$beanFullName,
-      clientName: this.db.clientName,
-      table,
-      method: 'cacheEntityClearInner',
-      args: [table]
-    });
+  // // tableName
+  // const tableName = options.table;
+  // if (__tableNames.has(tableName)) {
+  //   throw new Error(`entity table exists: ${tableName}`);
+  // }
+  // __tableNames.add(tableName);
+  return createBeanDecorator('entity', options, false, target => {
+    mergeDtoFieldsOpenapiMetadata(target);
+  });
+}
+
+function Model(options) {
+  return createBeanDecorator('model', options);
+}
+
+class BeanModelCrud extends BeanModelCrudInner {
+  async mget(ids, options) {
+    return await this._mget(undefined, ids, options);
   }
-  async cacheEntityClearInner(table) {
-    await this.cacheEntity.clear(table);
-    await this.cacheQueryClearInner(table);
+  async select(params, options) {
+    return await this._select(undefined, params, options);
   }
-  async cacheQueryClear(table) {
-    await this.cacheQueryClearInner(table);
-    this.db.commit(async () => {
-      await this.cacheQueryClearInner(table);
-    }, {
-      ignoreIfNotInTransaction: true
-    });
-    this._shardingCacheDoubleDelete({
-      beanFullName: this.$beanFullName,
-      clientName: this.db.clientName,
-      table,
-      method: 'cacheQueryClearInner',
-      args: [table]
-    });
+  async get(where, options) {
+    return await this._get(undefined, where, options);
   }
-  async cacheQueryClearInner(table) {
-    await this.cacheQuery.clear(table);
-    await this._cacheQueryClearModelsClear();
+  async count(params, options) {
+    return await this._count(undefined, params, options);
   }
-  _shardingCacheDoubleDelete(jobData) {
-    const doubleDelete = this.scopeOrm.config.sharding.cache.doubleDelete;
-    if (!doubleDelete) return;
-    this.db.commit(() => {
-      this.scopeOrm.queue.doubleDelete.push(jobData);
-    });
+  async insert(data, options) {
+    return await this._insertBulk(undefined, data, options);
   }
-  async _cacheQueryClearModelsClear() {
-    const modelsClear = this._getModelsClear();
-    if (!modelsClear || modelsClear.length === 0) return;
-    for (const modelClear of modelsClear) {
-      const modelTarget = this.newInstanceTarget(modelClear);
-      const modelsClearedByFn = modelTarget.options.cache?.modelsClearedByFn;
-      if (modelsClearedByFn) {
-        await modelsClearedByFn(this.ctx, modelTarget, this);
-      } else {
-        await modelTarget.cacheQueryClearInner();
-      }
-    }
+  async insertBulk(data, options) {
+    return await this._insertBulk(undefined, data, options);
   }
-  _getModelsClear(modelName) {
-    const modelsClearAll = getCacheModelsClear(this.app);
-    return modelsClearAll[modelName ?? this.$onionName];
+  async update(data, options) {
+    return await this._update(undefined, data, options);
   }
-  _checkDisableCacheQueryByOptions(options) {
-    if (options?.disableCacheQuery === true || options?.disableCacheQuery === false) {
-      return options?.disableCacheQuery;
-    }
-    return !(options?.cache?.enable ?? this.cacheQuery.enabled);
+  async delete(where, options) {
+    return await this._delete(undefined, where, options);
   }
-  _checkDisableCacheEntityByOptions(options) {
-    if (options?.disableCacheEntity === true || options?.disableCacheEntity === false) {
-      return options?.disableCacheEntity;
-    }
-    return !(options?.cache?.enable ?? this.cacheEntity.enabled);
+}
+
+class BeanModelCache extends BeanModelCrud {
+  constructor(...args) {
+    super(...args);
+    this.cacheQuery = void 0;
+    this.cacheEntity = void 0;
+    this.relations = void 0;
   }
-  __checkIfOnlyKey(keys, table, noCheckLength) {
-    const columnId = `${table}.id`;
-    if (!noCheckLength) {
-      const keysAux = this.cacheEntity.keysAux;
-      if (keysAux) {
-        const keysAux2 = Array.isArray(keysAux) ? keysAux : [keysAux];
-        keys = keys.filter(item => !keysAux2.includes(String(item)));
-      }
-      if (keys.length !== 1) return false;
-      if (keys[0] === 'id') return 'id';
-      if (keys[0] === columnId) return columnId;
-      return false;
-    } else {
-      if (keys.includes('id')) return 'id';
-      if (keys.includes(columnId)) return columnId;
-      return false;
-    }
+  __init__(clientName, table) {
+    super.__init__(clientName, table);
+    this.cacheQuery = this.bean._newBean(ServiceCacheQuery, this);
+    this.cacheEntity = this.bean._newBean(ServiceCacheEntity, this);
+    this.relations = this.bean._newBean(ServiceRelations, this);
   }
-  __checkCacheKeyValid(where, table, noCheckLength) {
-    if (!where) return undefined;
-    const columnId = this.__checkIfOnlyKey(Object.keys(where), table, noCheckLength);
-    if (!columnId) return undefined;
-    return ['number', 'string', 'bigint', 'array'].includes(typeof where[columnId]) ? where[columnId] : undefined;
+  async __dispose__() {
+    await disposeInstance(this.cacheQuery);
+    await disposeInstance(this.cacheEntity);
   }
-  __get__(prop) {
-    if (prop.startsWith('getBy')) {
-      const [fieldName, op] = __parseMagicField(prop.substring('getBy'.length));
-      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
-      return (fieldValue, options) => {
-        const where = __combineMagicWhere(fieldName, op, fieldValue);
-        return this.get(where, options);
-      };
-    } else if (prop.startsWith('selectBy')) {
-      const [fieldName, op] = __parseMagicField(prop.substring('selectBy'.length));
-      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
-      return (fieldValue, params, options, modelJoins) => {
-        const where = __combineMagicWhere(fieldName, op, fieldValue);
-        const params2 = params ? deepExtend({}, params, {
-          where
-        }) : {
-          where
-        };
-        return this.select(params2, options, modelJoins);
-      };
-    } else if (prop.startsWith('updateBy')) {
-      const [fieldName, op] = __parseMagicField(prop.substring('updateBy'.length));
-      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
-      return (fieldValue, data, options) => {
-        const where = __combineMagicWhere(fieldName, op, fieldValue);
-        if (fieldName === 'id') {
-          data = Object.assign({}, data, where);
-        } else {
-          options = deepExtend({}, options, {
-            where
-          });
-        }
-        return this.update(data, options);
-      };
-    } else if (prop.startsWith('deleteBy')) {
-      const [fieldName, op] = __parseMagicField(prop.substring('deleteBy'.length));
-      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
-      return (fieldValue, options) => {
-        const where = __combineMagicWhere(fieldName, op, fieldValue);
-        return this.delete(where, options);
-      };
-    }
+  async insert(data, options) {
+    if (!data) data = {};
+    const items = await this.insertBulk([data], options);
+    return items[0];
   }
-}
-function __combineMagicWhere(fieldName, op, fieldValue) {
-  return {
-    [fieldName]: fieldValue === undefined ? undefined : op === 'eq' ? fieldValue : {
-      [`_${op}_`]: fieldValue
-    }
-  };
-}
-function __parseMagicField(str) {
-  const fieldName = parseFirstWord(str, true);
-  if (!fieldName) return [fieldName, undefined];
-  const op = toLowerCaseFirstChar(str.substring(fieldName.length)) || 'eq';
-  return [fieldName, op];
-}
-
-let BeanModelBase = class BeanModelBase extends BeanModelCache {};
-BeanModelBase = __decorate([Bean(), Virtual(), BeanInfo({
-  module: "a-orm"
-})], BeanModelBase);
-
-const SymbolModuleScope$1 = Symbol('SymbolModuleScope');
-let ServiceEntityResolver = class ServiceEntityResolver extends BeanBase {
-  constructor(moduleScope) {
-    super();
-    this[SymbolModuleScope$1] = void 0;
-    this.__instances = {};
-    this[SymbolModuleScope$1] = moduleScope;
+  async insertBulk(items, options) {
+    const itemsResult = await this.__insertBulk_raw(undefined, items, options);
+    const itemsNew = items.map((item, index) => {
+      return Object.assign({}, item, {
+        id: cast(itemsResult[index]).id
+      });
+    });
+    return await this.relations.handleRelationsMutate(itemsResult, itemsNew, options, options);
   }
-  __get__(prop) {
-    if (!this.__instances[prop]) {
-      const beanFullName = `${this[SymbolModuleScope$1]}.entity.${prop}`;
-      const beanOptions = appResource.getBean(beanFullName);
-      this.__instances[prop] = $columnsAll(beanOptions.beanClass, true, true);
-    }
-    return this.__instances[prop];
+  async __insertBulk_raw(table, items, options) {
+    if (items.length === 0) return [];
+    // table
+    table = table || this.getTable(items[0]);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // insert
+    const res = await this._insertBulk(table, items, options);
+    // delete cache
+    const ids = res.map(item => cast(item).id);
+    await this.cacheEntityDel(ids, table);
+    return res;
   }
-};
-ServiceEntityResolver = __decorate([Service(), __metadata("design:paramtypes", [String]), BeanInfo({
-  module: "a-orm"
-})], ServiceEntityResolver);
-
-const SymbolModuleScope = Symbol('SymbolModuleScope');
-let ServiceModelResolver = class ServiceModelResolver extends BeanBase {
-  constructor(moduleScope) {
-    super();
-    this[SymbolModuleScope] = void 0;
-    this[SymbolModuleScope] = moduleScope;
+  async mutate(data, options) {
+    if (!data) data = {};
+    const items = await this.mutateBulk([data], options);
+    return items[0];
   }
-  __get__(prop) {
-    const beanFullName = `${this[SymbolModuleScope]}.model.${prop}`;
-    return this.bean._getBean(beanFullName);
+  async mutateBulk(items, options) {
+    return await this.__mutateBulk_raw(undefined, items, options);
   }
-};
-ServiceModelResolver = __decorate([Service(), __metadata("design:paramtypes", [String]), BeanInfo({
-  module: "a-orm"
-})], ServiceModelResolver);
-
-let BroadcastColumnsClear = class BroadcastColumnsClear extends BeanBroadcastBase {
-  async execute(data, isEmitter) {
-    const {
-      clientName,
-      tableName
-    } = data;
-    if (!isEmitter) {
-      await cast(this.scope.service.database).columnsClearWorker(clientName, tableName);
+  async __mutateBulk_raw(table, items, options) {
+    // table
+    table = table || this.getTable(items[0]);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check
+    const indexesInsert = [];
+    const indexesUpdate = [];
+    const itemsInsert = [];
+    const itemsUpdate = [];
+    const itemsDelete = [];
+    for (let index = 0; index < items.length; index++) {
+      const item = items[index];
+      if (cast(item).deleted) {
+        if (!isNil(cast(item).id)) {
+          itemsDelete.push(item);
+        }
+      } else if (!isNil(cast(item).id)) {
+        itemsUpdate.push(item);
+        indexesUpdate.push(index);
+      } else {
+        itemsInsert.push(item);
+        indexesInsert.push(index);
+      }
+    }
+    // insert/update
+    const itemsInsertNew = await this.__insertBulk_raw(table, itemsInsert, options);
+    await this.__updateBulk_raw(table, itemsUpdate, options);
+    const itemsMutate = itemsInsert.map((item, index) => {
+      return Object.assign({}, item, {
+        id: cast(itemsInsertNew[index]).id
+      });
+    }).concat(itemsUpdate);
+    let itemsMutateResult = itemsInsertNew.concat(itemsUpdate);
+    const indexesMutate = indexesInsert.concat(indexesUpdate);
+    itemsMutateResult = await this.relations.handleRelationsMutate(itemsMutateResult, itemsMutate, options, options);
+    let result = [];
+    for (let index = 0; index < indexesMutate.length; index++) {
+      result[indexesMutate[index]] = itemsMutateResult[index];
     }
+    result = result.filter(item => !!item); // fitler deleted items
+    // delete
+    const idsDelete = itemsDelete.map(item => cast(item).id);
+    await this.__deleteBulk_raw_with_relations(table, idsDelete, options);
+    // ok
+    return result;
   }
-};
-BroadcastColumnsClear = __decorate([Broadcast(), BeanInfo({
-  module: "a-orm"
-})], BroadcastColumnsClear);
-
-let EventClientNameReal = class EventClientNameReal extends BeanEventBase {};
-EventClientNameReal = __decorate([Event(), BeanInfo({
-  module: "a-orm"
-})], EventClientNameReal);
-
-let EventColumnsClear = class EventColumnsClear extends BeanEventBase {};
-EventColumnsClear = __decorate([Event(), BeanInfo({
-  module: "a-orm"
-})], EventColumnsClear);
-
-let HmrEntity = class HmrEntity extends BeanBase {
-  async reload(_beanOptions) {
-    this.app.bean.worker.reload();
+  async mget(ids, options) {
+    if (ids.length === 0) return [];
+    const relations = this.relations.handleRelationsCollection(options);
+    const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
+    let items = await this.__mget_raw(undefined, ids, options2);
+    if (items.length === 0) return items;
+    items = await this.relations.handleRelationsMany(relations, items, options, options);
+    if (refKeys) {
+      for (const item of items) {
+        for (const refKey of refKeys) {
+          delete item[refKey];
+        }
+      }
+    }
+    return items;
   }
-};
-HmrEntity = __decorate([Hmr(), BeanInfo({
-  module: "a-orm"
-})], HmrEntity);
-
-// import { clearAllCacheModelsClear, clearCacheModelCacheInstance } from '../lib/const.ts';
-let HmrModel = class HmrModel extends BeanBase {
-  async reload(_beanOptions) {
-    // more deps: dto/model
-    this.app.bean.worker.reload();
-    // clearAllCacheModelsClear(this.app);
-    // await clearCacheModelCacheInstance(this.app, beanOptions.beanFullName);
+  async __mget_raw(table, ids, options) {
+    // table
+    table = table || this.getTable(undefined);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check if cache
+    if (this._checkDisableCacheEntityByOptions(options)) {
+      return await super._mget(table, ids, options);
+    }
+    // cache
+    const cache = this.cacheEntity.getInstance(table);
+    let items = await cache.mget(ids, {
+      mget: async ids => {
+        return await super._mget_original(table, ids, {
+          disableDeleted: true
+        });
+      },
+      db: this.db
+    });
+    // filter disableDeleted
+    items = items.filter(item => {
+      if (!item) return false;
+      if (!this._checkIfEntityValidByDeleted(item, options)) return false;
+      return true;
+    });
+    return this.__filterMGetColumns(items, options?.columns);
   }
-};
-HmrModel = __decorate([Hmr(), BeanInfo({
-  module: "a-orm"
-})], HmrModel);
-
-let QueueDoubleDelete = class QueueDoubleDelete extends BeanQueueBase {
-  async execute(data, _options) {
-    const beanInstance = this.app.bean._newBean(data.beanFullName, data.clientName, data.table);
-    await beanInstance[data.method](...data.args);
+  async count(params, options, _modelJoins) {
+    const column = params?.column ?? '*';
+    const params2 = Object.assign({}, params, {
+      aggrs: {
+        count: column
+      },
+      column: undefined
+    });
+    const item = await this.aggregate(params2, options);
+    return this.extractFirstValue(item);
   }
-};
-QueueDoubleDelete = __decorate([Queue({
-  options: {
-    job: {
-      delay: 3 * 1000
-    }
+  async increment(params, options, _modelJoins) {
+    return await this.__increment_raw(undefined, params, options);
   }
-}), BeanInfo({
-  module: "a-orm"
-})], QueueDoubleDelete);
-
-let ScheduleSoftDeletionPrune = class ScheduleSoftDeletionPrune extends BeanBase {
-  async execute() {
-    const onionSlices = this.bean.onion.model.getOnionsEnabledCached();
-    for (const onionSlice of onionSlices) {
-      if (onionSlice.beanOptions.options?.disableDeleted) continue;
-      let softDeletionPrune = onionSlice.beanOptions.options?.softDeletionPrune ?? this.scope.config.softDeletionPrune.enable;
-      if (!softDeletionPrune) continue;
-      if (softDeletionPrune === true) softDeletionPrune = {};
-      await this._modulePrune(onionSlice, softDeletionPrune);
+  async decrement(params, options, _modelJoins) {
+    const columns = {};
+    for (const key in params.columns) {
+      columns[key] = -params.columns[key];
     }
+    const params2 = Object.assign({}, params, {
+      columns
+    });
+    return await this.__increment_raw(undefined, params2, options);
   }
-  async _modulePrune(onionSlice, softDeletionPrune) {
-    const handler = softDeletionPrune.handler;
-    const expired = softDeletionPrune.expired ?? this.scope.config.softDeletionPrune.expired;
-    const modelTarget = this.bean._getBean(onionSlice.beanOptions.beanFullName);
-    if (handler) {
-      await handler(this.ctx, modelTarget, {
-        expired
-      });
+  async __increment_raw(table, params, options) {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check if cache
+    if (this._checkDisableCacheEntityByOptions(options)) {
+      return await super._increment(table, params, options);
+    }
+    const where = params?.where;
+    const items = await this.__select_raw(table, {
+      where,
+      columns: ['id']
+    }, options);
+    if (items.length === 0) {
+      // donothing
+      return 0;
+    }
+    let id;
+    if (items.length === 1) {
+      id = cast(items[0]).id;
     } else {
-      const expiredTime = new Date(Date.now() - expired);
-      await modelTarget.delete({
-        deleted: true,
-        updatedAt: {
-          _lt_: expiredTime
-        }
-      }, {
-        disableDeleted: true
-      });
+      id = items.map(item => cast(item).id);
     }
+    // update by id/ids
+    params = Object.assign({}, params, {
+      where: {
+        id
+      }
+    });
+    const res = await this._increment(table, params, options);
+    // delete cache
+    await this.cacheEntityDel(id, table);
+    return res;
   }
-};
-ScheduleSoftDeletionPrune = __decorate([Schedule({
-  repeat: {
-    every: 24 * 3600 * 1000
+  async aggregate(params, options, _modelJoins) {
+    const items = await this.__aggregate_raw(undefined, params, options);
+    return items[0];
   }
-}), BeanInfo({
-  module: "a-orm"
-})], ScheduleSoftDeletionPrune);
-
-function config(_app) {
-  return {
-    sharding: {
-      cache: {
-        doubleDelete: true
-      }
-    },
-    rest: {
-      query: {
-        pageSize: {
-          default: 20,
-          max: 100
-        },
-        orders: {
-          default: 'createdAt,desc'
-        }
-      }
-    },
-    table: {
-      identityType: 'bigint'
-    },
-    model: {
-      disableDeleted: false,
-      disableInstance: false,
-      disableCreateTime: false,
-      disableUpdateTime: false
-    },
-    softDeletionPrune: {
-      enable: true,
-      expired: 14 * 24 * 3600 * 1000
-    },
-    dialects: {
-      'better-sqlite3': 'a-ormdialect:betterSqlite3',
-      'mysql': 'a-ormdialect:mysql',
-      'mysql2': 'a-ormdialect:mysql3',
-      'pg': 'a-ormdialect:pg'
-    },
-    summer: {
-      enable: true,
-      meta: {},
-      presetDefault: 'redis',
-      preset: {
-        redis: configRedis,
-        all: configAll
-      },
-      redis: {
-        client: 'model'
+  async __aggregate_raw(table, params, options) {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    const items = await this.__select_cache(table, params, options);
+    return items;
+  }
+  async group(params, options, _modelJoins) {
+    return await this.__group_raw(undefined, params, options);
+  }
+  async __group_raw(table, params, options) {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    const items = await this.__select_cache(table, params, options);
+    return items;
+  }
+  async selectAndCount(params, options, modelJoins) {
+    // pageNo/pageSize
+    const pageSize = params?.limit ?? this.scopeOrm.config.rest.query.pageSize.default;
+    const pageNo = Math.floor((params?.offset ?? 0) / pageSize) + 1;
+    // count
+    const paramsCount = Object.assign({}, params, {
+      columns: undefined,
+      orders: undefined,
+      limit: undefined,
+      offset: undefined
+    });
+    let count = await this.count(paramsCount, options, modelJoins);
+    if (!count) count = '0';
+    // list
+    let list;
+    if (count === '0') {
+      list = [];
+    } else {
+      list = await this.select(params, options, modelJoins);
+    }
+    // pageNo/pageSize/pageCount
+    const pageCount = Math.ceil(BigNumber(count).div(pageSize).toNumber());
+    // ok
+    return {
+      list,
+      total: count,
+      pageCount,
+      pageSize,
+      pageNo
+    };
+  }
+  async select(params, options, _modelJoins) {
+    const relations = this.relations.handleRelationsCollection(params);
+    const [params2, refKeys] = this.relations.prepareColumnsByRelations(relations, params);
+    let items = await this.__select_raw(undefined, params2, options);
+    if (items.length === 0) return items;
+    items = await this.relations.handleRelationsMany(relations, items, params, options);
+    if (refKeys) {
+      for (const item of items) {
+        for (const refKey of refKeys) {
+          delete item[refKey];
+        }
       }
-    },
-    logger: {
-      maxLength: 256
     }
-  };
-}
-
-const errors = {
-  ShouldSpecifyTable: 1001
-};
-
-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.bean.database.getDialect(client);
-      return await dialect[method](this, ...args);
+    return items;
+  }
+  async __select_raw(table, params, options) {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check if cache
+    if (this._checkDisableCacheEntityByOptions(options)) {
+      return await this.__select_cache(table, params, options);
+    }
+    // 1: select id
+    const columnId = `${table}.id`;
+    const params2 = Object.assign({}, params, {
+      columns: [columnId]
     });
-  });
-}
-
-const __ThisModule__ = 'a-orm';
-
-function ExtendTableBuilder(app) {
-  const scope = app.scope(__ThisModule__);
-  function _basicFields(options, identityType) {
-    options = options || {};
-    if (options.id !== false) {
-      const _identityType = identityType ?? scope.config.table.identityType;
-      if (_identityType === 'bigint') {
-        this.bigIncrements();
-      } else if (_identityType === 'number') {
-        this.increments();
-      } else {
-        throw new Error('Should create column id by yourself');
+    const items = await this.__select_cache(table, params2, options);
+    if (items.length === 0) {
+      // donothing
+      return [];
+    }
+    // 1: special check
+    if (params?.columns) {
+      const columnsTarget = Array.isArray(params?.columns) ? params?.columns : [params?.columns];
+      if (this.__checkIfOnlyKey(columnsTarget, table)) {
+        // just return
+        return items;
       }
     }
-    if (options.timestamps !== false) this.timestamps(true, true, true);
-    if (options.deleted !== false) this.boolean('deleted').defaultTo(false);
-    if (options.iid !== false) this.integer('iid').defaultTo(0);
-    return this;
+    // 2: mget
+    const ids = items.map(item => cast(item).id);
+    const options3 = params?.columns ? Object.assign({}, options, {
+      columns: params?.columns
+    }) : options;
+    return await this.__mget_raw(table, ids, options3);
   }
-  knex.TableBuilder.extend('basicFields', function (options) {
-    _basicFields.call(this, options, undefined);
-    return this;
-  });
-  knex.TableBuilder.extend('basicFieldsSimple', function (options) {
-    _basicFields.call(this, options, 'number');
-    return this;
-  });
-  knex.TableBuilder.extend('tableIdentity', function (columnName) {
-    const _identityType = scope.config.table.identityType;
-    if (_identityType === 'bigint') {
-      return this.bigInteger(columnName); // default value is null
-    } else if (_identityType === 'number') {
-      return this.integer(columnName); // default value is null
-    } else {
-      throw new Error(`Should create column ${columnName} by yourself`);
+  async __select_cache(table, params, options) {
+    // check if cache
+    if (this._checkDisableCacheQueryByOptions(options)) {
+      return await super._select(table, params, options);
     }
-  });
-  knex.TableBuilder.extend('userId', function (columnName) {
-    return this.tableIdentity(columnName ?? 'userId');
-  });
-  knex.TableBuilder.extend('int0', function (columnName) {
-    return this.integer(columnName).defaultTo(0);
-  });
-  knex.TableBuilder.extend('int1', function (columnName) {
-    return this.integer(columnName).defaultTo(1);
-  });
-  ['description'].forEach(method => {
-    knex.TableBuilder.extend(method, function (length = 255) {
-      return this.string(method, length);
-    });
-  });
-  ['content'].forEach(method => {
-    knex.TableBuilder.extend(method, function (useText) {
-      return useText ? this.text(method) : this.json(method);
+    // builder
+    const builder = this._select_buildParams(table, params, options);
+    const sql = builder.toQuery();
+    const key = {
+      sql
+    };
+    // cache
+    const cache = this.cacheQuery.getInstance(table);
+    const items = await cache.get(key, {
+      ...options?.cache,
+      get: async () => {
+        return await super._select(table, params, options, builder);
+      },
+      db: this.db
     });
-  });
-}
-
-function ExtendKnex(app) {
-  ExtendSchemaBuilder(app);
-  ExtendTableBuilder(app);
-}
-
-const SymbolTransactionConsistency = Symbol('SymbolTransactionConsistency');
-class Main extends BeanSimple {
-  async moduleLoading() {
-    // config
-    const _configDefault = await combineConfigDefault(this.app, configDefault, configDev, configProd, configTest);
-    this.app.config.database = deepExtend({}, _configDefault, this.app.config.database);
+    return items;
+  }
+  async get(where, options) {
+    const relations = this.relations.handleRelationsCollection(options);
+    const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
+    let item = await this.__get_raw(undefined, where, options2);
+    if (!item) return item;
+    item = await this.relations.handleRelationsOne(relations, item, options, options);
+    if (refKeys) {
+      for (const refKey of refKeys) {
+        delete item[refKey];
+      }
+    }
+    return item;
+  }
+  async __get_raw(table, where, options) {
+    // table
+    table = table || this.getTable(where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check if cache
+    if (this._checkDisableCacheEntityByOptions(options)) {
+      return await super._get(table, where, options);
+    }
+    const id = this.__checkCacheKeyValid(where, table);
+    if (isNil(id)) {
+      // not key
+      if (this._checkDisableCacheQueryByOptions(options)) {
+        return await super._get(table, where, options);
+      }
+      // by cache query
+      // params
+      const params = {
+        where
+      };
+      if (options?.columns) {
+        params.columns = options?.columns;
+      }
+      // select
+      const options2 = deepExtend({}, options, {
+        columns: undefined
+      });
+      const items = await this.__select_raw(table, params, options2);
+      return items[0];
+    }
+    // key
+    return this.__filterGetColumns(await this.__get_key(id, table, where, options), options?.columns);
+  }
+  async update(data, options) {
+    const ids = await this.__update_raw(undefined, data, options);
+    if (!ids || ids.length !== 1) return data;
+    // only support =1
+    const dataNew = [Object.assign({}, data, {
+      id: ids[0]
+    })];
+    const items = await this.relations.handleRelationsMutate(dataNew, dataNew, options, options);
+    return items[0];
+  }
+  async updateBulk(items, options) {
+    await this.__updateBulk_raw(undefined, items, options);
+    return await this.relations.handleRelationsMutate(items, items, options, options);
+  }
+  async __updateBulk_raw(table, items, options) {
+    if (items.length === 0) return;
+    for (const item of items) {
+      await this.__update_raw(table, item, options);
+    }
+  }
+  async __update_raw(table, data, options) {
+    // table
+    table = table || this.getTable(data);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check if cache
+    if (this._checkDisableCacheEntityByOptions(options)) {
+      await super._update(table, data, options);
+      return;
+    }
+    // check where and get id
+    let id = this.__checkCacheKeyValid(data, table, true);
+    if (!options?.where) {
+      if (isNil(id)) {
+        throw new Error('id should be specified for update method');
+      }
+      if (Array.isArray(id) && id.length === 0) return;
+      const id2 = this.__checkCacheKeyValid(data, table, false);
+      if (!isNil(id2)) {
+        // donothing
+        return;
+      }
+    } else {
+      const id2 = this.__checkCacheKeyValid(options?.where, table, false);
+      if (id2) {
+        id = id2;
+      } else {
+        const where = !isNil(id) ? Object.assign({}, options?.where, {
+          id
+        }) : options?.where;
+        const options2 = deepExtend({}, options, {
+          where: undefined
+        });
+        const items = await this.__select_raw(table, {
+          where,
+          columns: ['id']
+        }, options2);
+        if (items.length === 0) {
+          // donothing
+          return;
+        }
+        if (items.length === 1) {
+          id = cast(items[0]).id;
+        } else {
+          id = items.map(item => cast(item).id);
+        }
+        // update by id/ids
+        options = Object.assign({}, options, {
+          where: {
+            id
+          }
+        });
+      }
+    }
+    await super._update(table, data, options);
+    // delete cache
+    await this.cacheEntityDel(id, table);
+    // id
+    return Array.isArray(id) ? id : [id];
+  }
+  async delete(where, options) {
+    const ids = await this.__delete_raw(undefined, where, options);
+    if (!isNil(ids)) {
+      await this.relations.handleRelationsDelete(ids, options, options);
+    }
+  }
+  async deleteBulk(ids, options) {
+    return await this.__deleteBulk_raw_with_relations(undefined, ids, options);
+  }
+  async __deleteBulk_raw_with_relations(table, ids, options) {
+    if (ids.length === 0) return;
+    await this.__delete_raw(table, {
+      id: ids
+    }, options);
+    await this.relations.handleRelationsDelete(ids, options, options);
+  }
+  async __delete_raw(table, where, options) {
+    // table
+    table = table || this.getTable(where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // check if cache
+    if (this._checkDisableCacheEntityByOptions(options)) {
+      return await super._delete(table, where, options);
+    }
+    // id
+    let id = this.__checkCacheKeyValid(where, table);
+    if (isNil(id)) {
+      // check where and get id
+      const items = await this.__select_raw(table, {
+        where,
+        columns: ['id']
+      }, options);
+      if (items.length === 0) {
+        // donothing
+        return;
+      }
+      if (items.length === 1) {
+        id = cast(items[0]).id;
+      } else {
+        id = items.map(item => cast(item).id);
+      }
+    }
+    if (Array.isArray(id) && id.length === 0) return;
+    // delete by id/ids
+    await super._delete(table, {
+      id
+    }, options);
+    // delete cache
+    await this.cacheEntityDel(id, table);
+    // id
+    return Array.isArray(id) ? id : [id];
   }
-  async moduleLoaded() {
-    // ExtendKnex
-    ExtendKnex(this.app);
-    // db
-    Object.defineProperty(this.app.context, 'db', {
-      enumerable: false,
-      get() {
-        return this.app.bean._getBean(ServiceDatabaseAsyncLocalStorage$1).current;
-      }
+  async __get_key(id, table, where, options) {
+    // cache
+    const cache = this.cacheEntity.getInstance(table);
+    const item = await cache.get(id, {
+      get: async () => {
+        // where: maybe contain aux key
+        return await super._get(table, where, {
+          disableDeleted: true
+        });
+      },
+      db: this.db
     });
-    // transactionConsistency
-    Object.defineProperty(this.app.context, 'transactionConsistency', {
-      enumerable: false,
-      get() {
-        if (!this[SymbolTransactionConsistency]) {
-          this[SymbolTransactionConsistency] = this.app.bean._newBean(ServiceTransactionConsistency_);
-        }
-        return this[SymbolTransactionConsistency];
-      }
+    if (!item || !this._checkIfEntityValidByDeleted(item, options)) return undefined;
+    return item;
+  }
+  __filterMGetColumns(items, columns) {
+    if (items.length === 0 || !columns) return items;
+    return items.map(item => {
+      return this.__filterGetColumns(item, columns);
     });
-    // commit
-    Object.defineProperty(this.app.context, 'commit', {
-      enumerable: false,
-      get() {
-        return function (cb) {
-          if (this.ctxCaller) {
-            this.ctxCaller.commit(cb);
-          } else {
-            cast(this).transactionConsistency.commit(cb);
-          }
-        };
+  }
+  __filterGetColumns(data, columns) {
+    if (!data || !columns) return data;
+    if (!Array.isArray(columns)) columns = cast(columns).split(',');
+    const data2 = {};
+    for (let column of cast(columns)) {
+      column = getTargetColumnName(column);
+      if (column === '*') return data;
+      if (data[column] !== undefined) {
+        data2[column] = data[column];
       }
+    }
+    return data2;
+  }
+  async cacheEntityDel(id, table) {
+    await this.cacheEntityDelInner(id, table);
+    this.db.commit(async () => {
+      await this.cacheEntityDelInner(id, table);
+    }, {
+      ignoreIfNotInTransaction: true
     });
-    Object.defineProperty(this.app.context, 'commitsDone', {
-      enumerable: false,
-      get() {
-        return function () {
-          return cast(this).transactionConsistency.commitsDone();
-        };
-      }
+    this._shardingCacheDoubleDelete({
+      beanFullName: this.$beanFullName,
+      clientName: this.db.clientName,
+      table,
+      method: 'cacheEntityDelInner',
+      args: [id, table]
     });
   }
-  async configLoaded(_config) {}
-}
-async function configDefault(_app) {
-  return {};
-}
-async function configDev(_app) {
-  return {};
-}
-async function configProd(_app) {
-  return {};
-}
-async function configTest(_app) {
-  return {};
-}
-
-let ScopeModuleAOrm = class ScopeModuleAOrm extends BeanScopeBase {};
-ScopeModuleAOrm = __decorate([Scope(), BeanInfo({
-  module: "a-orm"
-})], ScopeModuleAOrm);
-/** scope: end */
-
-function DatabaseDialect(options) {
-  return createBeanDecorator('databaseDialect', options);
-}
-
-function DtoAggregate(modelLike, aggrs) {
-  return _DtoAggregate_raw(modelLike, aggrs);
-}
-function _DtoAggregate_raw(modelLike, aggrs) {
-  class TargetClass {}
-  return _DtoAggregate_inner(TargetClass, modelLike, aggrs);
-}
-function _DtoAggregate_inner(classTarget, _modelLike, aggrs) {
-  for (const key in aggrs) {
-    const columns = ensureArray(aggrs[key]);
-    if (!columns) continue;
-    for (const column of columns) {
-      const column2 = `${key}_${column === '*' ? 'all' : column}`;
-      Api.field(v.optional(), z.string())(classTarget.prototype, column2);
-    }
+  async cacheEntityDelInner(id, table) {
+    await this.cacheEntity.del(id, table);
+    await this.cacheQueryClearInner(table);
   }
-  return classTarget;
-}
-
-function DtoGroup(modelLike, groups, aggrs, columns) {
-  return _DtoGroup_raw(modelLike, groups, aggrs, columns);
-}
-function _DtoGroup_raw(modelLike, groups, aggrs, columns) {
-  class TargetClass {}
-  // model
-  const modelClass = prepareClassModel(modelLike);
-  // entity
-  const entityClass = getClassEntityFromClassModel(modelClass);
-  // columns/groups
-  const displays = ensureArray(columns ?? groups);
-  if (displays) {
-    PickClassInner(TargetClass, entityClass, displays);
+  async cacheEntityClear(table) {
+    await this.cacheEntityClearInner(table);
+    this.db.commit(async () => {
+      await this.cacheEntityClearInner(table);
+    }, {
+      ignoreIfNotInTransaction: true
+    });
+    this._shardingCacheDoubleDelete({
+      beanFullName: this.$beanFullName,
+      clientName: this.db.clientName,
+      table,
+      method: 'cacheEntityClearInner',
+      args: [table]
+    });
   }
-  // aggrs
-  if (aggrs) {
-    _DtoAggregate_inner(TargetClass, modelLike, aggrs);
+  async cacheEntityClearInner(table) {
+    await this.cacheEntity.clear(table);
+    await this.cacheQueryClearInner(table);
   }
-  // ok
-  return TargetClass;
-}
-
-function DtoGet(modelLike, params) {
-  return _DtoGet_raw(modelLike, params);
-}
-function _DtoGet_raw(modelLike, params) {
-  // model
-  const modelClass = prepareClassModel(modelLike);
-  // entity
-  let entityClass = getClassEntityFromClassModel(modelClass);
-  // columns
-  const columns = prepareColumns(params?.columns);
-  // always create a new class, no matter if columns empty
-  entityClass = $Class.pick(entityClass, columns);
-  // relations
-  _DtoGet_relations(modelClass, entityClass, params);
-  return entityClass;
-}
-function _DtoGet_relations(modelClass, entityClass, includeWrapper, mutateTypeTopLevel) {
-  // relations
-  const relations = _DtoGet_relations_collection(modelClass, includeWrapper);
-  if (!relations) return;
-  for (const relation of relations) {
-    _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel);
+  async cacheQueryClear(table) {
+    await this.cacheQueryClearInner(table);
+    this.db.commit(async () => {
+      await this.cacheQueryClearInner(table);
+    }, {
+      ignoreIfNotInTransaction: true
+    });
+    this._shardingCacheDoubleDelete({
+      beanFullName: this.$beanFullName,
+      clientName: this.db.clientName,
+      table,
+      method: 'cacheQueryClearInner',
+      args: [table]
+    });
   }
-}
-function _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel) {
-  const [relationName, relationReal, includeReal, withReal, autoload] = relation;
-  const {
-    type,
-    model,
-    options
-  } = relationReal;
-  const modelTarget = prepareClassModel(model);
-  const optionsReal = Object.assign({}, options, {
-    include: includeReal,
-    with: withReal
-  });
-  if (mutateTypeTopLevel) {
-    if (type === 'belongsTo') {
-      // donot mutate
-      return;
-    }
-    let schema;
-    if (type === 'belongsToMany') {
-      schema = v.array(z.object({
-        id: v.tableIdentity()(),
-        deleted: z.boolean().optional()
-      }));
-    } else if (type === 'hasOne') {
-      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
-      schema = v.lazy(schemaRenderVisible(false), schemaLazy);
-      // optional = true;
-    } else {
-      // hasMany
-      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
-      schema = v.array(v.lazy(schemaLazy));
-    }
-    Api.field(v.optional(), schema)(entityClass.prototype, relationName);
-  } else {
-    const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
-    let schema;
-    let optional = false;
-    if (type === 'hasOne' || type === 'belongsTo') {
-      schema = v.lazy(schemaRenderVisible(false), schemaLazy);
-      optional = true;
-    } else {
-      if (optionsReal.groups) {
-        schema = v.array(v.lazy(schemaLazy));
-      } else if (optionsReal.aggrs) {
-        schema = v.lazy(schemaLazy);
-        optional = true;
+  async cacheQueryClearInner(table) {
+    await this.cacheQuery.clear(table);
+    await this._cacheQueryClearModelsClear();
+  }
+  _shardingCacheDoubleDelete(jobData) {
+    const doubleDelete = this.scopeOrm.config.sharding.cache.doubleDelete;
+    if (!doubleDelete) return;
+    this.db.commit(() => {
+      this.scopeOrm.queue.doubleDelete.push(jobData);
+    });
+  }
+  async _cacheQueryClearModelsClear() {
+    const modelsClear = this._getModelsClear();
+    if (!modelsClear || modelsClear.length === 0) return;
+    for (const modelClear of modelsClear) {
+      const modelTarget = this.newInstanceTarget(modelClear);
+      const modelsClearedByFn = modelTarget.options.cache?.modelsClearedByFn;
+      if (modelsClearedByFn) {
+        await modelsClearedByFn(this.ctx, modelTarget, this);
       } else {
-        schema = v.array(v.lazy(schemaLazy));
+        await modelTarget.cacheQueryClearInner();
       }
     }
-    if (optional) {
-      Api.field(v.optional(), schema)(entityClass.prototype, relationName);
-    } else {
-      Api.field(schema)(entityClass.prototype, relationName);
-    }
   }
-}
-function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation) {
-  return () => {
-    if (!autoload) {
-      return _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
-    }
-    // dynamic
-    const entityClass = getClassEntityFromClassModel(modelTarget);
-    const beanFullName = appResource.getBeanFullName(entityClass);
-    const _hashkey = _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLevel);
-    const dynamicName = `${beanFullName}_${_hashkey}`;
-    let entityTarget = getSchemaDynamic(dynamicName);
-    if (!entityTarget) {
-      entityTarget = _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
-      entityTarget[SymbolSchemaDynamicRefId] = dynamicName;
-      addSchemaDynamic(dynamicName, entityTarget);
+  _getModelsClear(modelName) {
+    const modelsClearAll = getCacheModelsClear(this.app);
+    return modelsClearAll[modelName ?? this.$onionName];
+  }
+  _checkDisableCacheQueryByOptions(options) {
+    if (options?.disableCacheQuery === true || options?.disableCacheQuery === false) {
+      return options?.disableCacheQuery;
     }
-    return entityTarget;
-  };
-}
-function _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation) {
-  if (mutateTypeTopLevel) {
-    return _DtoMutate_raw(modelTarget, optionsReal, mutateTypeTopLevel, undefined, false, relation); // columnsOmitDefault: undefined
-  } else {
-    if (optionsReal.groups) {
-      return DtoGroup(modelTarget, optionsReal.groups, optionsReal.aggrs, optionsReal.columns);
-    } else if (optionsReal.aggrs) {
-      return DtoAggregate(modelTarget, optionsReal.aggrs);
-    } else {
-      return _DtoGet_raw(modelTarget, optionsReal);
+    return !(options?.cache?.enable ?? this.cacheQuery.enabled);
+  }
+  _checkDisableCacheEntityByOptions(options) {
+    if (options?.disableCacheEntity === true || options?.disableCacheEntity === false) {
+      return options?.disableCacheEntity;
     }
+    return !(options?.cache?.enable ?? this.cacheEntity.enabled);
   }
-}
-function _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLevel) {
-  const columns = prepareColumns(optionsReal.columns);
-  const aggrs = ensureArray(optionsReal.aggrs);
-  const groups = ensureArray(optionsReal.groups);
-  return columns || aggrs || groups || mutateTypeTopLevel ? hashkey({
-    columns,
-    aggrs,
-    groups,
-    mutate: mutateTypeTopLevel
-  }) : 'none';
-}
-function _DtoGet_relations_collection(modelClass, includeWrapper) {
-  const beanOptions = appResource.getBean(modelClass);
-  const options = beanOptions?.options;
-  return handleRelationsCollection(options?.relations, includeWrapper);
-}
-
-function _DtoMutate_raw(modelLike, params, mutateTypeTopLevel, columnsOmitDefault, topLevel, relation) {
-  // model
-  const modelClass = prepareClassModel(modelLike);
-  // entity
-  let entityClass = getClassEntityFromClassModel(modelClass);
-  // columns
-  let columns = prepareColumns(params?.columns);
-  if (columns) {
-    if (!topLevel) {
-      if (mutateTypeTopLevel === 'create') {
-        for (const key of ['deleted', 'id']) {
-          const index = columns.indexOf(key);
-          if (index > -1) {
-            columns = mutate(columns, copyState => {
-              copyState.splice(index, 1);
-            });
-          }
-        }
-      } else {
-        for (const key of ['deleted', 'id']) {
-          if (!columns.includes(key)) {
-            columns = mutate(columns, copyState => {
-              copyState.unshift(key);
-            });
-          }
-        }
+  __checkIfOnlyKey(keys, table, noCheckLength) {
+    const columnId = `${table}.id`;
+    if (!noCheckLength) {
+      const keysAux = this.cacheEntity.keysAux;
+      if (keysAux) {
+        const keysAux2 = Array.isArray(keysAux) ? keysAux : [keysAux];
+        keys = keys.filter(item => !keysAux2.includes(String(item)));
       }
+      if (keys.length !== 1) return false;
+      if (keys[0] === 'id') return 'id';
+      if (keys[0] === columnId) return columnId;
+      return false;
+    } else {
+      if (keys.includes('id')) return 'id';
+      if (keys.includes(columnId)) return columnId;
+      return false;
     }
-    entityClass = $Class.pick(entityClass, columns);
-  } else {
-    const columns = columnsOmitDefault ?? (mutateTypeTopLevel === 'create' ? ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] : ['iid', 'createdAt', 'updatedAt']);
-    entityClass = $Class.omit(entityClass, prepareColumns(columns));
   }
-  if (!topLevel && mutateTypeTopLevel !== 'create') {
-    entityClass = $Class.partial(entityClass, ['id', 'deleted']);
+  __checkCacheKeyValid(where, table, noCheckLength) {
+    if (!where) return undefined;
+    const columnId = this.__checkIfOnlyKey(Object.keys(where), table, noCheckLength);
+    if (!columnId) return undefined;
+    return ['number', 'string', 'bigint', 'array'].includes(typeof where[columnId]) ? where[columnId] : undefined;
   }
-  if (!topLevel && relation) {
-    const [_relationName, relationReal] = relation;
-    const {
-      type,
-      key
-    } = relationReal;
-    if (type === 'hasOne' || type === 'hasMany') {
-      entityClass = $Class.omit(entityClass, key);
+  __get__(prop) {
+    if (prop.startsWith('getBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('getBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, options) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        return this.get(where, options);
+      };
+    } else if (prop.startsWith('selectBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('selectBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, params, options, modelJoins) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        const params2 = params ? deepExtend({}, params, {
+          where
+        }) : {
+          where
+        };
+        return this.select(params2, options, modelJoins);
+      };
+    } else if (prop.startsWith('updateBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('updateBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, data, options) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        if (fieldName === 'id' && where.id !== null) {
+          data = Object.assign({}, data, where);
+        } else {
+          options = deepExtend({}, options, {
+            where
+          });
+        }
+        return this.update(data, options);
+      };
+    } else if (prop.startsWith('deleteBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('deleteBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, options) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        return this.delete(where, options);
+      };
     }
   }
-  // relations
-  _DtoGet_relations(modelClass, entityClass, params, mutateTypeTopLevel);
-  return entityClass;
-}
-
-function DtoCreate(modelLike, params) {
-  return _DtoMutate_raw(modelLike, params, 'create', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true, undefined);
-}
-
-function DtoListAndCount(classRef) {
-  class TargetClass {}
-  Api.field(v.array(classRef))(TargetClass.prototype, 'list');
-  Api.field(z.string())(TargetClass.prototype, 'total');
-  Api.field(z.number())(TargetClass.prototype, 'pageCount');
-  Api.field(z.number())(TargetClass.prototype, 'pageSize');
-  Api.field(z.number())(TargetClass.prototype, 'pageNo');
-  return TargetClass;
-}
-
-function DtoQuery(classRef, keys) {
-  return $Class.mixin(DtoQueryBase, $Class.partial($Class.pick(classRef, keys)));
-}
-
-function DtoQueryPage(classRef, keys) {
-  return $Class.mixin(DtoQueryPageBase, $Class.partial($Class.pick(classRef, keys)));
-}
-
-function DtoSelectAndCount(modelLike, params) {
-  const DtoGetResult = DtoGet(modelLike, params);
-  return DtoListAndCount(DtoGetResult);
-}
-
-function DtoUpdate(modelLike, params) {
-  return _DtoMutate_raw(modelLike, params, 'update', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true, undefined);
 }
-// not use Partial/$Class.partial, for form render at frontend
-
-const $Dto = {
-  create: DtoCreate,
-  update: DtoUpdate,
-  get: DtoGet,
-  aggregate: DtoAggregate,
-  group: DtoGroup,
-  query: DtoQuery,
-  queryPage: DtoQueryPage,
-  selectAndCount: DtoSelectAndCount,
-  listAndCount: DtoListAndCount
-};
-
-function Entity(table, options) {
-  if (typeof table === 'string') {
-    options = Object.assign({}, options, {
-      table
-    });
-  } else {
-    options = table || {};
+function __combineMagicWhere(fieldName, op, fieldValue) {
+  if (fieldValue === undefined) {
+    if (op === 'eq') {
+      return {
+        [fieldName]: null
+      };
+    }
+    throw new Error(`should specify the value for magic method: ${fieldName}/${op}`);
   }
-  // // tableName
-  // const tableName = options.table;
-  // if (__tableNames.has(tableName)) {
-  //   throw new Error(`entity table exists: ${tableName}`);
-  // }
-  // __tableNames.add(tableName);
-  return createBeanDecorator('entity', options, false, target => {
-    mergeDtoFieldsOpenapiMetadata(target);
-  });
+  return {
+    [fieldName]: op === 'eq' ? fieldValue : {
+      [`_${op}_`]: fieldValue
+    }
+  };
 }
-
-function Model(options) {
-  return createBeanDecorator('model', options);
+function __parseMagicField(str) {
+  const fieldName = parseFirstWord(str, true);
+  if (!fieldName) return [fieldName, undefined];
+  const op = toLowerCaseFirstChar(str.substring(fieldName.length)) || 'eq';
+  return [fieldName, op];
 }
 
+class BeanModelBase extends BeanModelCache {}
+
 function hasOne$2(classModel, key, options) {
   // :  IModelRelationHasOne<MODEL, AUTOLOAD, COLUMNS> {
   return {
@@ -4407,5 +4409,5 @@ const $relationMutate = {
   belongsToMany
 };
 
-export { $Dto, $locale, $relation, $relationDynamic, $relationMutate, AopMethodTransaction, BeanDatabase, BeanDatabaseDialectBase, BeanModel, BeanModelBase, BeanModelMeta, BroadcastColumnsClear, DatabaseDialect, DtoQueryBase, DtoQueryPageBase, Entity, EntityBase, EntityBaseEmpty, EntityBaseInner, EntityBaseSimple, EventClientNameReal, EventColumnsClear, ExtendKnex, ExtendSchemaBuilder, ExtendTableBuilder, HmrEntity, HmrModel, Main, Model, Op, OpAggrs, OpJoint, OpJointValues, OpNormal, OpNormalValues, OpValues, QueueDoubleDelete, ScheduleSoftDeletionPrune, ScopeModuleAOrm, ServiceCacheEntity, ServiceCacheQuery, ServiceColumns, ServiceColumnsCache, ServiceDatabase, ServiceDatabaseAsyncLocalStorage, ServiceDatabaseClient, ServiceDb, ServiceEntityResolver, ServiceModelResolver, ServiceRelations, ServiceTransaction, ServiceTransactionAsyncLocalStorage, ServiceTransactionConsistency‌, ServiceTransactionFiber, ServiceTransactionState, SymbolCacheModelCacheInstances, SymbolCacheModelsClear, SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyFieldsMore, SymbolKeyModelOptions, TransactionIsolationLevelsMap, buildWhere, clearAllCacheModelsClear, clearCacheModelCacheInstance, config, configDefault, errors, getCacheModelCacheInstances, getCacheModelsClear, getClassEntityFromClassModel, getTableOrTableAlias, getTargetColumnName, isRaw, isRef, locales, prepareClassModel, prepareColumns };
+export { $Dto, $locale, $relation, $relationDynamic, $relationMutate, AopMethodTransaction, BeanDatabase, BeanModel, BeanModelBase, BeanModelMeta, BroadcastColumnsClear, DatabaseDialect, DtoQueryBase, DtoQueryPageBase, Entity, EntityBase, EntityBaseEmpty, EntityBaseInner, EntityBaseSimple, EventClientNameReal, EventColumnsClear, ExtendKnex, ExtendSchemaBuilder, ExtendTableBuilder, HmrEntity, HmrModel, Main, Model, Op, OpAggrs, OpJoint, OpJointValues, OpNormal, OpNormalValues, OpValues, QueueDoubleDelete, ScheduleSoftDeletionPrune, ScopeModuleAOrm, ServiceCacheEntity, ServiceCacheQuery, ServiceColumns, ServiceColumnsCache, ServiceDatabase, ServiceDatabaseAsyncLocalStorage, ServiceDatabaseClient, ServiceDatabaseDialectBase, ServiceDb, ServiceEntityResolver, ServiceModelResolver, ServiceRelations, ServiceTransaction, ServiceTransactionAsyncLocalStorage, ServiceTransactionConsistency‌, ServiceTransactionFiber, ServiceTransactionState, SymbolCacheModelCacheInstances, SymbolCacheModelsClear, SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyFieldsMore, SymbolKeyModelOptions, TransactionIsolationLevelsMap, buildWhere, clearAllCacheModelsClear, clearCacheModelCacheInstance, config, configDefault, errors, getCacheModelCacheInstances, getCacheModelsClear, getClassEntityFromClassModel, getTableOrTableAlias, getTargetColumnName, isRaw, isRef, locales, prepareClassModel, prepareColumns };
 //# sourceMappingURL=index.js.map