vona-module-a-orm 5.0.37

package/dist/index.js

@@ -0,0 +1,4085 @@
+import { BigNumber } from 'bignumber.js';
+import { BeanInfo, BeanAopMethodBase, BeanBase, deepExtend, Virtual, appResource, beanFullNameFromOnionName, cast, appMetadata, useApp, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class } from 'vona';
+import { AopMethod, Aspect } from 'vona-module-a-aspect';
+import { Service, Bean, Scope } from 'vona-module-a-bean';
+import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
+import knex from 'knex';
+import { isNil, safeBoolean, isClass, ensureArray, hashkey } from '@cabloy/utils';
+import { swapDeps } from '@cabloy/deps';
+import { prepareClassType, getTargetDecoratorRules, Api, v, OrderMaxBase, OrderCoreBase, getSchemaDynamic, SymbolSchemaDynamicRefId, addSchemaDynamic, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapi';
+import { ZodMetadata } from '@cabloy/zod-query';
+import { SymbolDecoratorRuleColumn } from 'vona-module-a-openapiutils';
+export * from 'table-identity';
+import { Broadcast, BeanBroadcastBase } from 'vona-module-a-broadcast';
+import { Event, BeanEventBase } from 'vona-module-a-event';
+import { Schedule } from 'vona-module-a-schedule';
+import { configAllWithIgnoreNull, configAll, configRedisWithIgnoreNull, configRedis } from 'vona-module-a-summer';
+import { ServiceDatabaseAsyncLocalStorage as ServiceDatabaseAsyncLocalStorage$1, ServiceTransactionConsistency‌ as ServiceTransactionConsistency_ } from 'vona-module-a-orm';
+
+var _dec$u, _dec2$u, _class$u;
+let AopMethodTransaction = (_dec$u = AopMethod(), _dec2$u = BeanInfo({
+  module: "a-orm"
+}), _dec$u(_class$u = _dec2$u(_class$u = class AopMethodTransaction extends BeanAopMethodBase {
+  execute(options, _args, next, _receiver, _prop) {
+    return this.bean.database.current.transaction.begin(() => {
+      return next();
+    }, options);
+  }
+}) || _class$u) || _class$u);
+
+var _dec$t, _dec2$t, _class$t;
+let ServiceDatabaseAsyncLocalStorage = (_dec$t = Service(), _dec2$t = BeanInfo({
+  module: "a-orm"
+}), _dec$t(_class$t = _dec2$t(_class$t = class ServiceDatabaseAsyncLocalStorage extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this.dbStorage = void 0;
+  }
+  __init__() {
+    this.dbStorage = new AsyncLocalStorage();
+  }
+  get current() {
+    return this.dbStorage.getStore();
+  }
+  async run(store, fn) {
+    if (store === this.current) {
+      return fn();
+    }
+    return this.dbStorage.run(store, () => {
+      return fn();
+    });
+  }
+}) || _class$t) || _class$t);
+
+var _dec$s, _dec2$s, _class$s;
+const SymbolColumnsCache = Symbol('SymbolColumnsCache');
+const SymbolColumnsDefaultCache = Symbol('SymbolColumnsDefaultCache');
+let ServiceColumnsCache = (_dec$s = Service(), _dec2$s = BeanInfo({
+  module: "a-orm"
+}), _dec$s(_class$s = _dec2$s(_class$s = class ServiceColumnsCache extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this.clientName = void 0;
+    this[SymbolColumnsCache] = {};
+    this[SymbolColumnsDefaultCache] = {};
+    this._onColumnsClearCancel = void 0;
+  }
+  /** real client name */
+  __init__(clientName) {
+    this.clientName = clientName;
+    this._onColumnsClearCancel = this.scope.event.columnsClear.on(({
+      clientName,
+      tableName
+    }, next) => {
+      if (clientName === this.clientName) {
+        this.columnsClear(tableName);
+      }
+      next();
+    });
+  }
+  async __dispose__() {
+    this._onColumnsClearCancel?.();
+  }
+  getColumnsDefaultCache(table) {
+    return this[SymbolColumnsDefaultCache][table];
+  }
+  setColumnsDefaultCache(table, data) {
+    this[SymbolColumnsDefaultCache][table] = data;
+  }
+  deleteColumnsDefaultCache(table) {
+    delete this[SymbolColumnsDefaultCache][table];
+  }
+  getColumnsCache(table) {
+    return this[SymbolColumnsCache][table];
+  }
+  setColumnsCache(table, columns) {
+    this[SymbolColumnsCache][table] = columns;
+  }
+  deleteColumnsCache(table) {
+    delete this[SymbolColumnsCache][table];
+  }
+  columnsClear(tableName) {
+    if (tableName) {
+      const exists = this.getColumnsCache(tableName);
+      this.deleteColumnsCache(tableName);
+      this.deleteColumnsDefaultCache(tableName);
+      return exists;
+    } else {
+      const exists = Object.keys(this[SymbolColumnsCache]).length > 0;
+      this[SymbolColumnsCache] = {};
+      this[SymbolColumnsDefaultCache] = {};
+      return exists;
+    }
+  }
+}) || _class$s) || _class$s);
+
+var _dec$r, _dec2$r, _class$r;
+let ServiceColumns = (_dec$r = Service(), _dec2$r = BeanInfo({
+  module: "a-orm"
+}), _dec$r(_class$r = _dec2$r(_class$r = class ServiceColumns extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._db = void 0;
+    this._serviceColumnsCache = void 0;
+  }
+  __init__(db) {
+    this._db = db;
+  }
+  get db() {
+    return this._db;
+  }
+  get serviceColumnsCache() {
+    if (!this._serviceColumnsCache) {
+      const clientNameReal = this.scope.service.database.prepareClientNameReal(this.db.clientName);
+      this._serviceColumnsCache = this.bean._getBeanSelector(ServiceColumnsCache, clientNameReal);
+    }
+    return this._serviceColumnsCache;
+  }
+  async columns(tableName) {
+    if (!tableName) return {};
+    let columns = this.serviceColumnsCache.getColumnsCache(tableName);
+    if (!columns) {
+      const dialect = this.db.dialect;
+      const connection = this.db.connection;
+      const map = await connection(tableName).columnInfo();
+      columns = {};
+      for (const name in map) {
+        columns[name] = dialect.coerceColumn(map[name]);
+      }
+      this.serviceColumnsCache.setColumnsCache(tableName, columns);
+    }
+    return columns;
+  }
+  async defaultData(tableName) {
+    if (!tableName) return {};
+    let data = this.serviceColumnsCache.getColumnsDefaultCache(tableName);
+    if (!data) {
+      data = {};
+      // columns
+      const columns = await this.columns(tableName);
+      for (const columnName in columns) {
+        data[columnName] = columns[columnName].default;
+      }
+      this.serviceColumnsCache.setColumnsDefaultCache(tableName, data);
+    }
+    return data;
+  }
+  columnsClear(tableName) {
+    return this.scope.service.database.columnsClear(this.db.clientName, tableName);
+  }
+}) || _class$r) || _class$r);
+
+const TransactionIsolationLevelsMap = {
+  DEFAULT: undefined,
+  READ_UNCOMMITTED: 'read uncommitted',
+  READ_COMMITTED: 'read committed',
+  REPEATABLE_READ: 'repeatable read',
+  SERIALIZABLE: 'serializable',
+  SNAPSHOT: 'snapshot'
+};
+
+// export type TransactionPropagation=''
+
+var _dec$q, _dec2$q, _class$q;
+let ServiceDatabase = (_dec$q = Service(), _dec2$q = BeanInfo({
+  module: "a-orm"
+}), _dec$q(_class$q = _dec2$q(_class$q = class ServiceDatabase extends BeanBase {
+  getDialect(client) {
+    if (!client) throw new Error('database dialect not specified');
+    const beanFullName = this.scope.config.dialects[client];
+    const dialect = this.app.bean._getBean(beanFullName);
+    if (!dialect) throw new Error(`database dialect not found: ${client}`);
+    return dialect;
+  }
+  prepareDbInfo(dbInfoOrClientName) {
+    let level;
+    let clientName;
+    if (typeof dbInfoOrClientName === 'string') {
+      level = undefined;
+      clientName = dbInfoOrClientName;
+    } else {
+      level = dbInfoOrClientName?.level;
+      clientName = dbInfoOrClientName?.clientName;
+    }
+    // check if selector
+    if (clientName && clientName.includes(':')) return clientName;
+    // check if default
+    clientName = this.prepareClientName(clientName ?? this.bean.database.current?.clientName);
+    // level
+    level = level ?? this.bean.database.current?.level ?? 0;
+    return {
+      level,
+      clientName
+    };
+  }
+  prepareClientNameSelector(dbInfo) {
+    // combine
+    return dbInfo.level === 0 ? dbInfo.clientName : `${dbInfo.clientName}:${dbInfo.level}`;
+  }
+  parseClientNameSelector(clientNameSelector) {
+    if (isNil(clientNameSelector)) throw new Error('invalid clientNameSelector');
+    const [clientName, level] = clientNameSelector.split(':');
+    if (!clientName) throw new Error('clientName must be specified');
+    return {
+      level: Number(level ?? 0),
+      clientName: clientName
+    };
+  }
+  prepareClientName(clientName) {
+    return !clientName || clientName === 'default' ? this.getDefaultClientName() : clientName;
+  }
+  getDefaultClientName() {
+    let defaultClient = this.app.config.database.defaultClient;
+    if (typeof defaultClient === 'function') {
+      defaultClient = defaultClient(this.ctx);
+    }
+    return defaultClient;
+  }
+  prepareClientNameReal(clientName) {
+    return this.scope.event.clientNameReal.emitSync(this.prepareClientName(clientName), clientName => {
+      return clientName;
+    });
+  }
+  columnsClear(clientName, tableName) {
+    this.__columnsClearRaw(clientName, tableName);
+    this.scope.broadcast.columnsClear.emit({
+      clientName,
+      tableName
+    });
+  }
+  __columnsClearRaw(clientName, tableName) {
+    this.scope.event.columnsClear.emitSync({
+      clientName: this.prepareClientNameReal(clientName),
+      tableName
+    });
+  }
+  async reloadClients(clientName, clientConfig, extraData) {
+    await this.__reloadAllClientsRaw(clientName, clientConfig, extraData);
+    this.scope.broadcast.databaseClientReload.emit({
+      clientName,
+      clientConfig,
+      extraData
+    });
+  }
+  async __reloadAllClientsRaw(clientName, clientConfig, extraData) {
+    await this.scope.event.databaseClientReload.emit({
+      clientName: this.prepareClientName(clientName),
+      clientConfig,
+      extraData
+    });
+    this.__columnsClearRaw(clientName);
+  }
+}) || _class$q) || _class$q);
+
+var _dec$p, _dec2$p, _class$p;
+let ServiceTransactionConsistency‌ = (_dec$p = Service(), _dec2$p = BeanInfo({
+  module: "a-orm"
+}), _dec$p(_class$p = _dec2$p(_class$p = class ServiceTransactionConsistency‌ extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._commitCallbacks = [];
+    this._compensateCallbacks = [];
+  }
+  commit(cb) {
+    this._commitCallbacks.push(AsyncResource.bind(cb));
+  }
+  compensate(cb) {
+    this._compensateCallbacks.unshift(AsyncResource.bind(cb));
+  }
+  async commitDone() {
+    while (true) {
+      const cb = this._commitCallbacks.shift();
+      if (!cb) break;
+      await cb();
+    }
+    this._compensateCallbacks = [];
+  }
+  async compensateDone() {
+    while (true) {
+      const cb = this._compensateCallbacks.shift();
+      if (!cb) break;
+      await cb();
+    }
+    this._commitCallbacks = [];
+  }
+}) || _class$p) || _class$p);
+
+var _dec$o, _dec2$o, _class$o;
+let ServiceTransactionFiber = (_dec$o = Service(), _dec2$o = BeanInfo({
+  module: "a-orm"
+}), _dec$o(_class$o = _dec2$o(_class$o = class ServiceTransactionFiber extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._connection = void 0;
+    this._transactionConsistency = void 0;
+  }
+  __init__(connection) {
+    this._connection = connection;
+    this._transactionConsistency = this.app.bean._newBean(ServiceTransactionConsistency‌);
+  }
+  get connection() {
+    return this._connection;
+  }
+  commit(cb) {
+    this._transactionConsistency.commit(cb);
+  }
+  compensate(cb) {
+    this._transactionConsistency.compensate(cb);
+  }
+  async doCommit() {
+    await this._connection.commit();
+    await this._transactionConsistency.commitDone();
+    this._connection = undefined;
+  }
+  async doRollback() {
+    await this._connection.rollback();
+    await this._transactionConsistency.compensateDone();
+    this._connection = undefined;
+  }
+}) || _class$o) || _class$o);
+
+var _dec$n, _dec2$n, _class$n;
+let ServiceTransactionState = (_dec$n = Service(), _dec2$n = BeanInfo({
+  module: "a-orm"
+}), _dec$n(_class$n = _dec2$n(_class$n = class ServiceTransactionState extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._fibers = {};
+  }
+  get serviceDatabase() {
+    return this.bean._getBean(ServiceDatabase);
+  }
+  get(dbInfo) {
+    const selector = this.serviceDatabase.prepareClientNameSelector(dbInfo);
+    return this._fibers[selector];
+  }
+  add(dbInfo, connection) {
+    const selector = this.serviceDatabase.prepareClientNameSelector(dbInfo);
+    const fiber = this.bean._newBean(ServiceTransactionFiber, connection);
+    this._fibers[selector] = fiber;
+    return fiber;
+  }
+  remove(dbInfo) {
+    const selector = this.serviceDatabase.prepareClientNameSelector(dbInfo);
+    delete this._fibers[selector];
+  }
+}) || _class$n) || _class$n);
+
+var _dec$m, _dec2$m, _class$m;
+let ServiceTransactionAsyncLocalStorage = (_dec$m = Service(), _dec2$m = BeanInfo({
+  module: "a-orm"
+}), _dec$m(_class$m = _dec2$m(_class$m = class ServiceTransactionAsyncLocalStorage extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this.transactionStorage = void 0;
+  }
+  __init__() {
+    this.transactionStorage = new AsyncLocalStorage();
+  }
+  get transactionState() {
+    return this.transactionStorage.getStore();
+  }
+  async run(fn) {
+    // only once
+    if (this.transactionState) {
+      return fn();
+    }
+    const transactionState = this.bean._newBean(ServiceTransactionState);
+    return this.transactionStorage.run(transactionState, () => {
+      return fn();
+    });
+  }
+}) || _class$m) || _class$m);
+
+var _dec$l, _dec2$l, _class$l;
+let ServiceTransaction = (_dec$l = Service(), _dec2$l = BeanInfo({
+  module: "a-orm"
+}), _dec$l(_class$l = _dec2$l(_class$l = class ServiceTransaction extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._db = void 0;
+  }
+  __init__(db) {
+    this._db = db;
+  }
+  get transactionState() {
+    return this.bean._getBean(ServiceTransactionAsyncLocalStorage).transactionState;
+  }
+  get transactionFiber() {
+    return this.transactionState.get(this._db.info);
+  }
+  get inTransaction() {
+    return !!this.transactionFiber;
+  }
+  get connection() {
+    return this.transactionFiber?.connection;
+  }
+  commit(cb, options) {
+    if (options?.ctxPrefer) {
+      this.ctx?.commit(cb);
+      return;
+    }
+    const fiber = this.transactionFiber;
+    if (!fiber) {
+      this.ctx?.commit(cb);
+    } else {
+      fiber.commit(cb);
+    }
+  }
+  compensate(cb) {
+    const fiber = this.transactionFiber;
+    if (fiber) {
+      fiber.compensate(cb);
+    }
+  }
+  async begin(fn, options) {
+    // transactionOptions
+    const transactionOptions = Object.assign({}, options, {
+      propagation: undefined
+    });
+    // propagation
+    const propagation = options?.propagation ?? 'REQUIRED';
+    if (propagation === 'REQUIRED') {
+      // required
+      return this._isolationLevelRequired(fn, transactionOptions);
+    } else if (propagation === 'SUPPORTS') {
+      // supports
+      if (this.inTransaction) {
+        return this._isolationLevelRequired(fn, transactionOptions);
+      } else {
+        return fn();
+      }
+    } else if (propagation === 'MANDATORY') {
+      // mandatory
+      if (this.inTransaction) {
+        return this._isolationLevelRequired(fn, transactionOptions);
+      } else {
+        throw new Error('transaction error: EnumTransactionPropagation.MANDATORY');
+      }
+    } else if (propagation === 'REQUIRES_NEW') {
+      // requires_new
+      if (!this.inTransaction) {
+        return this._isolationLevelRequired(fn, transactionOptions);
+      } else {
+        return this.bean.database.switchDbIsolate(() => {
+          return this.bean.database.current.transaction.begin(() => {
+            return fn();
+          }, transactionOptions);
+        }, this._db.info);
+      }
+    } else if (propagation === 'NOT_SUPPORTED') {
+      if (!this.inTransaction) {
+        return fn();
+      } else {
+        return this.bean.database.switchDbIsolate(fn, this._db.info);
+      }
+    } else if (propagation === 'NEVER') {
+      if (!this.inTransaction) {
+        return fn();
+      } else {
+        throw new Error('transaction error: EnumTransactionPropagation.NEVER');
+      }
+    }
+    throw new Error('transaction error: unknown propagation');
+  }
+  async _isolationLevelRequired(fn, options) {
+    let res;
+    // begin
+    let fiber;
+    if (!this.inTransaction) {
+      const connection = this._db.client.connection;
+      const transactionConnection = await connection.transaction(_translateTransactionOptions(options));
+      fiber = this.transactionState.add(this._db.info, transactionConnection);
+    }
+    // fn
+    try {
+      res = await fn();
+    } catch (err) {
+      if (fiber) {
+        await fiber.doRollback();
+        this.transactionState.remove(this._db.info);
+      }
+      throw err;
+    }
+    try {
+      if (fiber) {
+        await fiber.doCommit();
+        this.transactionState.remove(this._db.info);
+      }
+    } catch (err) {
+      if (fiber) {
+        await fiber.doRollback();
+        this.transactionState.remove(this._db.info);
+      }
+      throw err;
+    }
+    return res;
+  }
+}) || _class$l) || _class$l);
+function _translateTransactionOptions(options) {
+  if (!options) return undefined;
+  return {
+    isolationLevel: TransactionIsolationLevelsMap[options.isolationLevel ?? 'DEFAULT'],
+    readOnly: options.readOnly
+  };
+}
+
+var _dec$k, _dec2$k, _class$k;
+let ServiceDb = (_dec$k = Service(), _dec2$k = BeanInfo({
+  module: "a-orm"
+}), _dec$k(_class$k = _dec2$k(_class$k = class ServiceDb extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._client = void 0;
+    this._columns = void 0;
+    this._transaction = void 0;
+  }
+  __init__(client) {
+    this._client = client;
+  }
+  get info() {
+    return {
+      level: this.level,
+      clientName: this.clientName
+    };
+  }
+  get level() {
+    return this._client.level;
+  }
+  get clientName() {
+    return this._client.clientName;
+  }
+  get client() {
+    return this._client;
+  }
+  get columns() {
+    if (!this._columns) {
+      this._columns = this.app.bean._newBean(ServiceColumns, this);
+    }
+    return this._columns;
+  }
+  get transaction() {
+    if (!this._transaction) {
+      this._transaction = this.app.bean._newBean(ServiceTransaction, this);
+    }
+    return this._transaction;
+  }
+  get inTransaction() {
+    return this.transaction.inTransaction;
+  }
+  get connection() {
+    return this.transaction.connection ?? this.client.connection;
+  }
+  get dialectName() {
+    return this.client.clientConfig.client;
+  }
+  get dialect() {
+    return this.scope.service.database.getDialect(this.dialectName);
+  }
+  commit(cb, options) {
+    return this.transaction.commit(cb, options);
+  }
+  compensate(cb) {
+    return this.transaction.compensate(cb);
+  }
+}) || _class$k) || _class$k);
+
+var _dec$j, _dec2$j, _class$j;
+let ServiceDatabaseClient = (_dec$j = Service(), _dec2$j = BeanInfo({
+  module: "a-orm"
+}), _dec$j(_class$j = _dec2$j(_class$j = class ServiceDatabaseClient extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this.level = void 0;
+    this.clientName = void 0;
+    this.clientNameSelector = void 0;
+    this.clientConfig = void 0;
+    this._knex = void 0;
+    this._db = void 0;
+    this._onDatabaseClientReloadCancel = void 0;
+  }
+  get configDatabase() {
+    return this.app.config.database;
+  }
+  get connection() {
+    return this._knex;
+  }
+  get db() {
+    return this._db;
+  }
+  __init__(clientNameSelector, clientConfig) {
+    // db
+    this._db = this.bean._newBean(ServiceDb, this);
+    // load
+    this.__load(clientNameSelector, clientConfig);
+    // event
+    this._onDatabaseClientReloadCancel = this.scope.event.databaseClientReload.on(async ({
+      clientName,
+      clientConfig
+    }, next) => {
+      if (clientName === this.clientName) {
+        await this.reload(clientConfig);
+      }
+      await next();
+    });
+  }
+  async __dispose__() {
+    this._db = undefined;
+    await this.__close();
+    this._onDatabaseClientReloadCancel?.();
+  }
+  __load(clientNameSelector, clientConfig) {
+    // name
+    this.clientNameSelector = clientNameSelector;
+    const dbInfo = this.scope.service.database.parseClientNameSelector(clientNameSelector);
+    this.level = dbInfo.level;
+    this.clientName = dbInfo.clientName;
+    // config
+    this.clientConfig = clientConfig ? deepExtend({}, clientConfig) : this.getClientConfig(this.clientName);
+    this.$loggerChild('database').debug('clientName: %s, clientConfig: %j', this.clientName, this.clientConfig);
+    // knex
+    this._knex = knex(this.clientConfig);
+  }
+  async __close() {
+    if (this._knex) {
+      await this._knex.destroy();
+      this._knex = undefined;
+    }
+  }
+  async reload(clientConfig) {
+    await this.__close();
+    this.__load(this.clientNameSelector, clientConfig);
+  }
+  getClientConfig(clientName, original = false) {
+    // clientConfig
+    let clientConfig = this.configDatabase.clients[clientName];
+    if (original) return clientConfig;
+    // check
+    if (!clientConfig) {
+      throw new Error(`database config not found: ${clientName}`);
+    }
+    // configBaseClient
+    const dialect = this.scope.service.database.getDialect(clientConfig.client);
+    const configBaseClient = dialect.getConfigBase();
+    // combine
+    const configBase = this.configDatabase.base;
+    clientConfig = deepExtend({}, configBase, configBaseClient, clientConfig);
+    // ready
+    return clientConfig;
+  }
+  getDatabaseName() {
+    const connection = this.clientConfig.connection;
+    return connection.database || connection.filename;
+  }
+  _prepareDatabaseName(databaseName) {
+    const result = {};
+    const connection = this.clientConfig.connection;
+    if (connection.database) {
+      result.database = databaseName;
+    } else if (connection.filename) {
+      result.filename = databaseName;
+    }
+    return result;
+  }
+  async changeConfigAndReload(databaseName) {
+    // set databaseName
+    const connDatabaseName = this._prepareDatabaseName(databaseName);
+    // set config
+    //   * should not use this.clientConfig.connection, because password is hidden
+    const config = this.getClientConfig(this.clientName, true);
+    config.connection = Object.assign({}, config.connection, connDatabaseName);
+    // only used by startup, so no consider that workders broadcast
+    this.configDatabase.clients[this.clientName] = config;
+    // reload
+    await this.reload(config);
+  }
+}) || _class$j) || _class$j);
+
+var _dec$i, _dec2$i, _class$i;
+let BeanDatabase = (_dec$i = Bean(), _dec2$i = BeanInfo({
+  module: "a-orm"
+}), _dec$i(_class$i = _dec2$i(_class$i = class BeanDatabase extends BeanBase {
+  get current() {
+    return this.bean._getBean(ServiceDatabaseAsyncLocalStorage).current;
+  }
+  getClient(dbInfoOrClientName, clientConfig) {
+    const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    const selector = this.scope.service.database.prepareClientNameSelector(dbInfo);
+    return this.app.bean._getBeanSelector(ServiceDatabaseClient, selector, clientConfig);
+  }
+  getDb(dbInfoOrClientName, clientConfig) {
+    return this.getClient(dbInfoOrClientName, clientConfig).db;
+  }
+  async switchDbIsolate(fn, dbInfoOrClientName) {
+    const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    return this.switchDb(fn, {
+      level: dbInfo.level + 1,
+      clientName: dbInfo.clientName
+    });
+  }
+  async switchDb(fn, dbInfoOrClientName) {
+    const current = this.bean.database.current;
+    const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    if (dbInfo.level === current?.level && dbInfo.clientName === current?.clientName) {
+      return fn();
+    }
+    const db = this.getDb(dbInfo);
+    return this.bean._getBean(ServiceDatabaseAsyncLocalStorage).run(db, () => {
+      return this.bean._getBean(ServiceTransactionAsyncLocalStorage).run(fn);
+    });
+  }
+}) || _class$i) || _class$i);
+
+var _dec$h, _dec2$h, _dec3$5, _class$h;
+let BeanDatabaseDialectBase = (_dec$h = Bean(), _dec2$h = Virtual(), _dec3$5 = BeanInfo({
+  module: "a-orm"
+}), _dec$h(_class$h = _dec2$h(_class$h = _dec3$5(_class$h = class BeanDatabaseDialectBase extends BeanBase {
+  getConfigBase() {
+    return undefined;
+  }
+  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) {
+    throw new Error('Not Implemented');
+  }
+  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;
+  }
+  _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));
+  }
+}) || _class$h) || _class$h) || _class$h);
+
+const OpAggrs = ['count', 'sum', 'avg', 'max', 'min'];
+const OpJoint = {
+  and: '_and_',
+  or: '_or_',
+  not: '_not_',
+  exists: '_exists_',
+  notExists: '_notExists_'
+};
+const OpNormal = {
+  eq: '_eq_',
+  notEq: '_notEq_',
+  gt: '_gt_',
+  gte: '_gte_',
+  lt: '_lt_',
+  lte: '_lte_',
+  in: '_in_',
+  notIn: '_notIn_',
+  is: '_is_',
+  isNot: '_isNot_',
+  between: '_between_',
+  notBetween: '_notBetween_',
+  startsWith: '_startsWith_',
+  endsWith: '_endsWith_',
+  includes: '_includes_',
+  startsWithI: '_startsWithI_',
+  endsWithI: '_endsWithI_',
+  includesI: '_includesI_',
+  ref: '_ref_'
+};
+const Op = {
+  skip: '_skip_',
+  ...OpJoint,
+  ...OpNormal
+};
+const OpJointValues = Object.values(OpJoint);
+const OpNormalValues = Object.values(OpNormal);
+const OpValues = Object.values(Op);
+
+// not use TypeOpsJointPostfix, which cause type not take affect for table.field
+// export type TypeOpsJoint = TypeRecordValues<TypeOpsJointPostfix<Pick<typeof Op, 'and' | 'or' | 'not' | 'exists' | 'notExists'>>>;
+
+// not use Knex.Raw
+
+// not use Knex.Raw
+// Columns extends {} ? TypeModelWhereInner<Columns> | Knex.Raw : TypeModelWhereInner<TRecord> | Knex.Raw;
+
+function isRaw(raw) {
+  return typeof raw?.constructor === 'function' && raw?.constructor?.name === 'Raw';
+}
+function getTableOrTableAlias(table) {
+  const _table = table.toString();
+  return _table.includes(' as ') ? _table.split(' as ')[1].trim() : _table;
+}
+function getTargetColumnName(column) {
+  if (column.includes(' as ')) return column.split(' as ')[1].trim();
+  if (column.includes('.')) return column.split('.')[1].trim();
+  return column;
+}
+function prepareColumns(columns) {
+  if (!columns) return undefined;
+  columns = Array.isArray(columns) ? columns : [columns];
+  if (columns.includes('*')) return undefined;
+  return columns;
+}
+function prepareClassModel(classType) {
+  if (typeof classType === 'string') {
+    const beanOptions = appResource.getBean(beanFullNameFromOnionName(classType, 'model'));
+    return beanOptions.beanClass;
+  }
+  return prepareClassType(classType);
+}
+function getClassEntityFromClassModel(modelClass) {
+  const beanOptions = appResource.getBean(modelClass);
+  const options = beanOptions.options;
+  return options.entity;
+}
+
+// export function formatValue(value) {
+//   if (typeof value !== 'object' || value instanceof Date) return value;
+//   // date
+//   if (value.type === 'Date') return moment(value.val).toDate();
+//   // like
+//   if (value.op === 'like') return `%${value.val}%`;
+//   if (value.op === 'likeLeft') return `%${value.val}`;
+//   if (value.op === 'likeRight') return `${value.val}%`;
+//   if (value.op === 'likeStrict') return `${value.val}`;
+//   // in
+//   if (['in', 'notIn'].includes(value.op)) {
+//     return formatValueArray(value);
+//   }
+//   // others
+//   return value.val;
+// }
+
+// export function formatValueArray(value) {
+//   if (!value.val) return null;
+//   const arr = typeof value.val === 'string' ? value.val.split(',') : value.val;
+//   if (arr.length === 0) return null;
+//   return arr;
+// }
+
+function buildWhere(knex, builder, wheres, having = false) {
+  _buildWhereInner(having, knex, builder, wheres);
+}
+function _buildWhereInner(having, knex, builder, wheres, column) {
+  // skip
+  if (wheres === Op.skip) {
+    return;
+  }
+  // raw
+  if (isRaw(wheres)) {
+    builder[having ? 'havingRaw' : 'whereRaw'](wheres);
+    return;
+  }
+  // loop
+  for (const key in wheres) {
+    const value = wheres[key];
+    if (key[0] !== '_') {
+      // columns
+      _buildWhereColumn(having, knex, builder, key, value);
+    } else if (OpNormalValues.includes(key)) {
+      // op: normal
+      if (column) {
+        _buildWhereColumn(having, knex, builder, column, value, key);
+      }
+    } else {
+      const op = _checkOpJoint(key);
+      if (op) {
+        // op: joint
+        _buildWhereOpJoint(having, knex, builder, column, value, op);
+      }
+    }
+  }
+}
+function _buildWhereOpJoint(having, knex, builder, column, wheres, op) {
+  // skip
+  if (wheres === Op.skip) {
+    return;
+  }
+  // and/or
+  if (op === Op.and) {
+    builder[having ? 'having' : 'where'](builder => {
+      for (const key in wheres) {
+        builder.andWhere(builder => {
+          _buildWhereInner(false, knex, builder, {
+            [key]: wheres[key]
+          }, column);
+        });
+      }
+    });
+    return;
+  }
+  // or
+  if (op === Op.or) {
+    builder[having ? 'having' : 'where'](builder => {
+      for (const key in wheres) {
+        builder.orWhere(builder => {
+          _buildWhereInner(false, knex, builder, {
+            [key]: wheres[key]
+          }, column);
+        });
+      }
+    });
+    return;
+  }
+  // not
+  if (op === Op.not) {
+    builder[having ? 'havingNot' : 'whereNot'](builder => {
+      _buildWhereInner(false, knex, builder, wheres, column);
+    });
+    return;
+  }
+  // exists
+  if (op === Op.exists) {
+    builder[having ? 'havingExists' : 'whereExists'](wheres);
+    return;
+  }
+  // notexists
+  if (op === Op.notExists) {
+    builder[having ? 'havingNotExists' : 'whereNotExists'](wheres);
+  }
+}
+function _buildWhereColumn(having, knex, builder, column, value, op) {
+  // skip
+  if (value === Op.skip) {
+    return;
+  }
+  // raw
+  if (isRaw(value)) {
+    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.eq);
+    return;
+  }
+  // null/undefined
+  if (isNil(value)) {
+    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.is);
+    return;
+  }
+  // array
+  if (Array.isArray(value)) {
+    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.in);
+    return;
+  }
+  // date
+  if (value instanceof Date) {
+    _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.eq);
+    return;
+  }
+  // object
+  if (typeof value === 'object') {
+    builder[having ? 'having' : 'where'](builder => {
+      _buildWhereInner(false, knex, builder, value, column);
+    });
+    return;
+  }
+  // column
+  _buildWhereColumnOpNormal(having, knex, builder, column, value, op ?? Op.eq);
+}
+function _buildWhereColumnOpNormal(having, knex, builder, column, value, op) {
+  column = _checkHavingColumn(knex, column);
+  if (op === Op.eq) {
+    builder[having ? 'having' : 'where'](column, '=', value);
+  } else if (op === Op.notEq) {
+    builder[having ? 'having' : 'where'](column, '<>', value);
+  } else if (op === Op.gt) {
+    builder[having ? 'having' : 'where'](column, '>', value);
+  } else if (op === Op.gte) {
+    builder[having ? 'having' : 'where'](column, '>=', value);
+  } else if (op === Op.lt) {
+    builder[having ? 'having' : 'where'](column, '<', value);
+  } else if (op === Op.lte) {
+    builder[having ? 'having' : 'where'](column, '<=', value);
+  } else if (op === Op.in) {
+    builder[having ? 'havingIn' : 'whereIn'](column, value);
+  } else if (op === Op.notIn) {
+    builder[having ? 'havingNotIn' : 'whereNotIn'](column, value);
+  } else if (op === Op.is) {
+    builder[having ? 'havingNull' : 'whereNull'](column);
+  } else if (op === Op.isNot) {
+    builder[having ? 'havingNotNull' : 'whereNotNull'](column);
+  } else if (op === Op.between) {
+    builder[having ? 'havingBetween' : 'whereBetween'](column, value);
+  } else if (op === Op.notBetween) {
+    builder[having ? 'havingNotBetween' : 'whereNotBetween'](column, value);
+  } else if (op === Op.startsWith) {
+    builder[having ? 'havingLike' : 'whereLike'](column, `${value}%`);
+  } else if (op === Op.endsWith) {
+    builder[having ? 'havingLike' : 'whereLike'](column, `%${value}`);
+  } else if (op === Op.includes) {
+    builder[having ? 'havingLike' : 'whereLike'](column, `%${value}%`);
+  } else if (op === Op.startsWithI) {
+    builder[having ? 'havingILike' : 'whereILike'](column, `${value}%`);
+  } else if (op === Op.endsWithI) {
+    builder[having ? 'havingILike' : 'whereILike'](column, `%${value}`);
+  } else if (op === Op.includesI) {
+    builder[having ? 'havingILike' : 'whereILike'](column, `%${value}%`);
+  } else if (op === Op.ref) {
+    builder[having ? 'having' : 'where'](column, '=', knex.ref(value));
+  }
+}
+function _checkHavingColumn(knex, column) {
+  let [aggr, name] = cast(column).split('_');
+  if (!OpAggrs.includes(aggr) || !name) return column;
+  if (aggr === 'count' && name === 'all') name = '*';
+  return knex.raw(`${_safeOp(aggr)}(${_safeColumn(name)})`);
+}
+function isAggrColumn(column) {
+  const [aggr, name] = cast(column).split('_');
+  if (!OpAggrs.includes(aggr) || !name) return false;
+  return true;
+}
+function _checkOpJoint(op) {
+  for (const item of OpJointValues) {
+    if (op.startsWith(item)) {
+      return item;
+    }
+  }
+  return undefined;
+}
+function _safeOp(op) {
+  return op.replace(/[\\.*#%'"`;,() ]/g, '');
+}
+function _safeColumn(column) {
+  return column.replace(/[\\.#%'"`;,() ]/g, '');
+}
+
+function $column(key) {
+  return key;
+}
+function $columns(key) {
+  return key;
+}
+function $columnsAll(classEntity, withTableName, withMeta) {
+  const classEntity2 = _prepareClassEntity(classEntity);
+  let columns = appMetadata.getMetadata(SymbolDecoratorRuleColumn, classEntity2.prototype);
+  if (withTableName) {
+    const tableName = $tableName(classEntity2);
+    columns = {
+      ...columns,
+      $table: tableName
+    };
+  }
+  if (withMeta) {
+    const comments = $tableComments(classEntity2);
+    const defaults = $tableDefaults(classEntity2);
+    columns = {
+      ...columns,
+      $comment: comments,
+      $default: defaults
+    };
+  }
+  return columns;
+}
+function $tableColumns(classEntity, key) {
+  // tableName
+  const tableName = $tableName(classEntity);
+  return {
+    [tableName]: key
+  };
+}
+function $tableName(classEntity) {
+  const beanOptionsEntity = appResource.getBean(_prepareClassEntity(classEntity));
+  const entityOptions = beanOptionsEntity?.options;
+  return entityOptions.table;
+}
+function $tableComments(classEntity) {
+  const app = useApp();
+  const classEntity2 = _prepareClassEntity(classEntity);
+  // rules
+  const rules = getTargetDecoratorRules(classEntity2.prototype);
+  const comments = {};
+  for (const key in rules) {
+    const rule = rules[key];
+    const comment = rule._def.openapi?.metadata?.description || rule._def.openapi?.metadata?.title;
+    comments[key] = comment ? app.meta.text(comment) : '';
+  }
+  // table comment
+  const beanOptions = appResource.getBean(classEntity2);
+  if (beanOptions) {
+    const openapi = cast(beanOptions.options)?.openapi;
+    const comment = openapi?.description || openapi?.title;
+    cast(comments).$table = comment ? app.meta.text(comment) : '';
+  }
+  // ok
+  return comments;
+}
+function $tableDefaults(classEntity) {
+  const classEntity2 = _prepareClassEntity(classEntity);
+  // rules
+  const rules = getTargetDecoratorRules(classEntity2.prototype);
+  const defaults = {};
+  for (const key in rules) {
+    const rule = rules[key];
+    defaults[key] = ZodMetadata.getDefaultValue(rule);
+  }
+  // ok
+  return defaults;
+}
+function _prepareClassEntity(classEntity) {
+  return isClass(classEntity) ? classEntity : cast(classEntity)();
+}
+
+const SymbolKeyFieldsMore = Symbol('$fieldsMore');
+
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+  var a = {};
+  return Object.keys(n).forEach(function (i) {
+    a[i] = n[i];
+  }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = true), a = r.slice().reverse().reduce(function (r, n) {
+    return n(i, e, r) || r;
+  }, a), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
+}
+function _initializerDefineProperty(e, i, r, l) {
+  r && Object.defineProperty(e, i, {
+    enumerable: r.enumerable,
+    configurable: r.configurable,
+    writable: r.writable,
+    value: r.initializer ? r.initializer.call(l) : void 0
+  });
+}
+
+class EntityBaseEmpty {}
+
+var _dec$g, _dec2$g, _dec3$4, _dec4$2, _dec5, _dec6, _dec7, _dec8, _class$g, _descriptor$2, _descriptor2, _descriptor3, _descriptor4;
+let EntityBaseInner = (_dec$g = Api.field(v.openapi({
+  title: $locale('CreatedAt'),
+  rest: {
+    order: OrderMaxBase - 2
+  }
+})), _dec2$g = Reflect.metadata("design:type", typeof Date === "undefined" ? Object : Date), _dec3$4 = Api.field(v.openapi({
+  title: $locale('UpdatedAt'),
+  rest: {
+    order: OrderMaxBase - 1
+  }
+})), _dec4$2 = Reflect.metadata("design:type", typeof Date === "undefined" ? Object : Date), _dec5 = Api.field(v.openapi({
+  title: $locale('Deleted'),
+  rest: {
+    visible: false
+  }
+}), v.default(false)), _dec6 = Reflect.metadata("design:type", Boolean), _dec7 = Api.field(v.openapi({
+  title: $locale('InstanceId'),
+  rest: {
+    visible: false
+  }
+}), v.default(0)), _dec8 = Reflect.metadata("design:type", Number), _class$g = class EntityBaseInner extends EntityBaseEmpty {
+  constructor(...args) {
+    super(...args);
+    _initializerDefineProperty(this, "createdAt", _descriptor$2, this);
+    _initializerDefineProperty(this, "updatedAt", _descriptor2, this);
+    _initializerDefineProperty(this, "deleted", _descriptor3, this);
+    _initializerDefineProperty(this, "iid", _descriptor4, this);
+  }
+}, _descriptor$2 = _applyDecoratedDescriptor(_class$g.prototype, "createdAt", [_dec$g, _dec2$g], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class$g.prototype, "updatedAt", [_dec3$4, _dec4$2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class$g.prototype, "deleted", [_dec5, _dec6], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor4 = _applyDecoratedDescriptor(_class$g.prototype, "iid", [_dec7, _dec8], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class$g);
+
+var _dec$f, _dec2$f, _class$f, _descriptor$1;
+let EntityBase = (_dec$f = Api.field(v.openapi({
+  title: $locale('TableIdentity'),
+  rest: {
+    order: OrderCoreBase + 1
+  }
+}), v.tableIdentity()), _dec2$f = Reflect.metadata("design:type", typeof TableIdentity === "undefined" ? Object : TableIdentity), _class$f = class EntityBase extends EntityBaseInner {
+  constructor(...args) {
+    super(...args);
+    _initializerDefineProperty(this, "id", _descriptor$1, this);
+  }
+}, _descriptor$1 = _applyDecoratedDescriptor(_class$f.prototype, "id", [_dec$f, _dec2$f], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class$f);
+
+var _dec$e, _dec2$e, _class$e, _descriptor;
+let EntityBaseSimple = (_dec$e = Api.field(v.openapi({
+  title: $locale('TableIdentity'),
+  rest: {
+    order: OrderCoreBase + 1
+  }
+})), _dec2$e = Reflect.metadata("design:type", Number), _class$e = class EntityBaseSimple extends EntityBaseInner {
+  constructor(...args) {
+    super(...args);
+    _initializerDefineProperty(this, "id", _descriptor, this);
+  }
+}, _descriptor = _applyDecoratedDescriptor(_class$e.prototype, "id", [_dec$e, _dec2$e], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class$e);
+
+const SymbolKeyEntity = Symbol('$entity');
+const SymbolKeyEntityMeta = Symbol('$entityMeta');
+const SymbolKeyModelOptions = Symbol('$modelOptions');
+
+const SymbolModelDb = Symbol('SymbolModelDb');
+const SymbolModelTable = Symbol('SymbolModelTable');
+class BeanModelMeta extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this[SymbolKeyEntity] = void 0;
+    this[SymbolKeyEntityMeta] = void 0;
+    this[SymbolKeyModelOptions] = void 0;
+    this[SymbolModelDb] = void 0;
+    this[SymbolModelTable] = void 0;
+  }
+  __init__(clientName, table) {
+    // clientName
+    if (!isNil(clientName)) {
+      if (typeof clientName === 'string') {
+        this[SymbolModelDb] = this.bean.database.getDb(clientName);
+      } else {
+        this[SymbolModelDb] = clientName;
+      }
+    }
+    // table
+    this[SymbolModelTable] = table;
+  }
+  get self() {
+    return cast(this);
+  }
+  get connection() {
+    return this.db.connection;
+  }
+  get dialect() {
+    return this.db.dialect;
+  }
+  get scopeOrm() {
+    return this.$scope.orm;
+  }
+  get modelViewRecord() {
+    return this.$scope.version.model.viewRecord;
+  }
+  get db() {
+    return this[SymbolModelDb] ?? this._getDb();
+  }
+  _getDb() {
+    let clientName = this.options.client;
+    // use current
+    if (!clientName) return this.bean.database.current;
+    // custom clientName
+    if (typeof clientName === 'function') {
+      clientName = clientName(this.ctx, this);
+    }
+    // db
+    return this.bean.database.getDb(clientName);
+  }
+  getTable() {
+    return this[SymbolModelTable] ?? this._getTable();
+  }
+  _getTable() {
+    const table = this.options.table;
+    if (table && typeof table === 'string') return table;
+    const defaultTable = this.options.entity && $tableName(this.options.entity);
+    if (table && typeof table === 'function') {
+      return table(this.ctx, defaultTable, this);
+    }
+    if (defaultTable) return defaultTable;
+    throw new Error(`not found table of ${this.$beanFullName}`);
+  }
+  get options() {
+    return this.$beanOptions.options || {};
+  }
+  get disableInstance() {
+    return this.options.disableInstance ?? this.scopeOrm.config.model.disableInstance;
+  }
+  get disableDeleted() {
+    return this.options.disableDeleted ?? this.scopeOrm.config.model.disableDeleted;
+  }
+  get disableCreateTime() {
+    return this.options.disableCreateTime ?? this.scopeOrm.config.model.disableCreateTime;
+  }
+  get disableUpdateTime() {
+    return this.options.disableUpdateTime ?? this.scopeOrm.config.model.disableUpdateTime;
+  }
+  _prepareDisableInstanceByOptions(table, data, options, useRaw) {
+    const columnNameInstance = useRaw ? 'iid' : `${getTableOrTableAlias(table)}.iid`;
+    if (this._checkDisableInstanceByOptions(options)) {
+      delete data.iid;
+      delete data[columnNameInstance];
+    } else {
+      delete data.iid;
+      if (!isNil(options?.iid)) {
+        data[columnNameInstance] = options?.iid;
+      } else {
+        if (!this.ctx.instance) {
+          throw new Error('ctx.instance not exists');
+        }
+        data[columnNameInstance] = this.ctx.instance.id;
+      }
+    }
+    return data;
+  }
+  _prepareDisableDeletedByOptions(table, data, options, useRaw) {
+    const columnNameDeleted = useRaw ? 'deleted' : `${getTableOrTableAlias(table)}.deleted`;
+    const deleted = this._prepareDisableDeletedByOptionsSimple(options);
+    if (!isNil(deleted)) {
+      delete data.deleted; // force
+      data[columnNameDeleted] = deleted;
+    }
+    return data;
+  }
+  _prepareDisableDeletedByOptionsSimple(options) {
+    if (!isNil(options?.deleted)) {
+      if (!this.disableDeleted) {
+        return options?.deleted;
+      }
+    } else {
+      if (this._checkDisableDeletedByOptions(options)) ; else {
+        return false;
+      }
+    }
+    return undefined;
+  }
+  _checkIfEntityValidByDeleted(entity, options) {
+    const deleted = this._prepareDisableDeletedByOptionsSimple(options);
+    return isNil(deleted) || Boolean(entity.deleted) === Boolean(deleted);
+  }
+  _checkDisableInstanceByOptions(options) {
+    return options?.disableInstance ?? this.disableInstance;
+  }
+  _checkDisableDeletedByOptions(options) {
+    if (this.disableDeleted) return true;
+    return options?.disableDeleted ?? this.disableDeleted;
+  }
+  _checkDisableCreateTimeByOptions(options) {
+    return options?.disableCreateTime ?? this.disableCreateTime;
+  }
+  _checkDisableUpdateTimeByOptions(options) {
+    return options?.disableUpdateTime ?? this.disableUpdateTime;
+  }
+  newInstance(client, table) {
+    return this.app.bean._newBean(this.$beanFullName, client ?? this.db, table);
+  }
+  newInstanceTarget(modelClassTarget, client, table) {
+    const modelClass2 = prepareClassModel(modelClassTarget);
+    const beanOptions = appResource.getBean(modelClass2);
+    const beanFullName = beanOptions.beanFullName;
+    const options = beanOptions?.options;
+    if (isNil(client) || client === 'auto') {
+      client = options?.client ? 'initial' : 'inherit';
+    }
+    if (client === 'initial') {
+      return this.app.bean._newBean(beanFullName, undefined, table);
+    } else if (client === 'inherit') {
+      client = this.db;
+    }
+    return this.app.bean._newBean(beanFullName, client ?? this.db, table);
+  }
+}
+
+class BeanModelUtils extends BeanModelMeta {
+  async prepareData(table, item) {
+    if (typeof table !== 'string') {
+      item = table;
+      table = undefined;
+    }
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // item
+    if (!item) return [{}, {}];
+    // columns
+    const columns = await this.columns(table);
+    // data
+    const data = {};
+    const dataOriginal = {};
+    for (const columnName in columns) {
+      const column = columns[columnName];
+      if (Object.prototype.hasOwnProperty.call(item, columnName)) {
+        let value = item[columnName];
+        dataOriginal[columnName] = value;
+        if (column.type === 'json' && value !== undefined) {
+          value = JSON.stringify(value);
+        }
+        data[columnName] = value;
+      }
+    }
+    return [data, dataOriginal];
+  }
+  async defaultData(table) {
+    if (this.options.entity) {
+      return $tableDefaults(this.options.entity);
+    }
+    table = table || this.getTable();
+    return await this.db.columns.defaultData(table);
+  }
+  async columns(table) {
+    table = table || this.getTable();
+    return await this.db.columns.columns(table);
+  }
+  isRaw(raw) {
+    return isRaw(raw);
+  }
+  raw(sql, bindings) {
+    return this.connection.raw(sql, bindings);
+  }
+  ref(src) {
+    return this.connection.ref(src);
+  }
+  toIdentifier(name) {
+    const parts = Array.isArray(name) ? name : name.split(',');
+    return this.raw(parts.map(_ => '??').join(','), parts);
+  }
+
+  // checkWhere(where: TypeModelWhere<TRecord>) {
+  //   return checkWhere(where);
+  // }
+
+  buildWhere(builder, wheres) {
+    if (!wheres) return;
+    return buildWhere(this.connection, builder, wheres);
+  }
+  buildJoin(builder, join) {
+    if (!join) return;
+    const [joinType, joinTable, joinOn] = join;
+    builder[joinType](joinTable, cast(joinOn));
+  }
+  buildJoins(builder, joins) {
+    if (!joins) return;
+    for (const [joinType, joinTable, joinOn] of joins) {
+      if (Array.isArray(joinOn)) {
+        cast(builder)[joinType](joinTable, ...joinOn);
+      } else {
+        builder[joinType](joinTable, joinOn);
+      }
+    }
+  }
+  buildDistinct(builder, distinct) {
+    if (distinct === undefined || distinct === false) return;
+    if (distinct === true) {
+      builder.distinct();
+    } else if (Array.isArray(distinct)) {
+      builder.distinct(...distinct);
+    } else {
+      builder.distinct(distinct);
+    }
+  }
+  buildCount(builder, column, distinct) {
+    if (column !== undefined) {
+      builder.count(column);
+    } else if (distinct !== undefined && distinct !== false) {
+      builder.count(this.raw(`distinct ${this.toIdentifier(distinct)}`));
+    } else {
+      builder.count();
+    }
+  }
+  buildOrders(builder, orders) {
+    if (!orders) return;
+    for (const [orderColumn, orderDirection, orderNulls] of orders) {
+      builder.orderBy(orderColumn, orderDirection, orderNulls);
+    }
+  }
+  buildLimit(builder, limit) {
+    if (limit !== 0 && limit !== undefined) {
+      builder.limit(limit);
+    }
+  }
+  buildOffset(builder, offset) {
+    if (offset !== undefined) {
+      builder.offset(offset);
+    }
+  }
+  buildColumns(builder, columns, groups) {
+    if (columns) {
+      builder.select(columns);
+    } else if (groups) {
+      builder.select(groups);
+    }
+  }
+  buildGroups(builder, groups) {
+    if (!groups) return;
+    groups = ensureArray(groups);
+    builder.groupBy(groups);
+    return groups;
+  }
+  buildAggrs(builder, aggrs) {
+    if (!aggrs) return;
+    for (const key in aggrs) {
+      const columns = ensureArray(aggrs[key]);
+      if (!columns) continue;
+      for (const column of columns) {
+        const column2 = `${key}_${column === '*' ? 'all' : column}`;
+        builder[key](column, {
+          as: column2
+        });
+      }
+    }
+  }
+  buildPage(builder, page) {
+    if (!page) return;
+    this.buildLimit(builder, page.size);
+    this.buildOffset(builder, page.index);
+  }
+  prepareHaving(builder, having) {
+    if (!having) return;
+    this.buildHaving(builder, having);
+  }
+  buildHaving(builder, having) {
+    return buildWhere(this.connection, builder, having, true);
+  }
+  prepareWhere(builder, table, where, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) throw new Error('should specify the table name');
+    // disableInstance/disableDeleted
+    where = Object.assign({}, where);
+    where = this._prepareWhereByOptions(table, where, options);
+    // build
+    this.buildWhere(builder, where);
+  }
+  convertItemsToBigNumber(items) {
+    for (const item of items) {
+      for (const key in item) {
+        if (isAggrColumn(key)) {
+          if (!isNil(item[key])) {
+            item[key] = BigNumber(item[key]);
+          }
+        }
+      }
+    }
+    return items;
+  }
+  extractCount(result, columnName) {
+    return this.extractFirstNumber(result, 0, columnName);
+  }
+  extractFirstNumber(result, defaultValue, columnName) {
+    const value = this.extractFirstValue(result, defaultValue, columnName);
+    if (value === undefined || value === null) return undefined;
+    return BigNumber(value);
+  }
+  extractFirstValue(result, defaultValue, columnName) {
+    const value = this._extractFirstValue(result, columnName);
+    if (value === undefined || value === null) return defaultValue;
+    return value;
+  }
+  _extractFirstValue(result, columnName) {
+    const res = Array.isArray(result) ? result[0] : result;
+    if (!res) return undefined;
+    if (columnName) return res[columnName];
+    const keys = Object.keys(res);
+    if (keys.length === 0) return undefined;
+    return res[keys[0]];
+  }
+  _prepareWhereByOptions(table, where, options) {
+    // disableInstance: should not check if specified
+    where = this._prepareDisableInstanceByOptions(table, where, options);
+    // disableDeleted: should not check if specified
+    where = this._prepareDisableDeletedByOptions(table, where, options);
+    // ok
+    return where;
+  }
+  _prepareInsertDataByOptions(table, data, options) {
+    let result = Object.assign({}, data);
+    // disableInstance: should not check if specified
+    result = this._prepareDisableInstanceByOptions(table, result, options, true);
+    // disableDeleted: should not check if specified
+    result = this._prepareDisableDeletedByOptions(table, result, options, true);
+    // createdAt/updatedAt
+    if (isNil(result.createdAt)) {
+      if (!this._checkDisableCreateTimeByOptions(options)) {
+        result.createdAt = new Date();
+      } else {
+        delete result.createdAt;
+      }
+    }
+    if (isNil(result.updatedAt)) {
+      if (!this._checkDisableUpdateTimeByOptions(options)) {
+        result.updatedAt = new Date();
+      } else {
+        delete result.updatedAt;
+      }
+    }
+    return result;
+  }
+}
+
+class BeanModelKnex extends BeanModelUtils {
+  get schema() {
+    return this.connection.schema;
+  }
+  builder(table) {
+    // table
+    table = table || this.getTable();
+    if (table) {
+      return this.connection(table);
+    }
+    return this.connection.queryBuilder();
+  }
+  builderSelect(table, options) {
+    if (typeof table !== 'string') {
+      options = table;
+      table = undefined;
+    }
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // builder
+    const builder = this.builder(table);
+    // where
+    this.prepareWhere(builder, table, {}, options);
+    // ready
+    return builder;
+  }
+  async query(sql, bindings) {
+    const raw = this.connection.raw(sql, bindings);
+    const result = await raw;
+    // dialect
+    return this.dialect.query(result);
+  }
+  async queryOne(sql, bindings) {
+    const res = await this.query(sql, bindings);
+    return res[0];
+  }
+}
+
+class BeanModelView extends BeanModelKnex {
+  async createView(viewName, callback) {
+    if (callback) {
+      // create view
+      let _view = null;
+      await this.schema.createView(viewName, view => {
+        _view = view;
+        return callback(view);
+      });
+      // view sql
+      const sql = cast(_view).toSQL();
+      const viewSql = sql[0].sql;
+      // record view
+      const viewRecord = await this.modelViewRecord.get({
+        viewName
+      });
+      if (viewRecord) {
+        await this.modelViewRecord.update({
+          id: viewRecord.id,
+          viewSql
+        });
+      } else {
+        await this.modelViewRecord.insert({
+          viewName,
+          viewSql
+        });
+      }
+    } else {
+      // get record
+      const viewRecord = await this.modelViewRecord.get({
+        viewName
+      });
+      if (!viewRecord) throw new Error(`not found view record: ${viewName}`);
+      await this.raw(viewRecord.viewSql);
+    }
+  }
+  async dropView(viewName, disableRemoveRecord) {
+    // drop view: use dropViewIfExists
+    await this.schema.dropViewIfExists(viewName);
+    // remove record
+    if (!disableRemoveRecord) {
+      await this.modelViewRecord.delete({
+        viewName
+      });
+    }
+  }
+  async alterView(viewName, callback) {
+    await this._viewDependentsAll_handle(viewName, async () => {
+      // drop view
+      await this.dropView(viewName, true);
+      // create view
+      await this.createView(viewName, callback);
+    });
+  }
+  async createTable(tableName, callback) {
+    await this.schema.createTable(tableName, callback);
+  }
+  async dropTable(tableName) {
+    await this.schema.dropTable(tableName);
+  }
+  async alterTable(tableName, callback, alterViewAuto) {
+    if (!alterViewAuto) {
+      // alter table
+      return await this.schema.alterTable(tableName, table => {
+        return callback(table);
+      });
+    }
+    await this._viewDependentsAll_handle(tableName, async () => {
+      await this.schema.alterTable(tableName, table => {
+        return callback(table);
+      });
+    });
+  }
+  async viewDependents(viewName) {
+    // builder
+    const builder = this.builder();
+    // dialect
+    return await this.dialect.viewDependents(builder, viewName);
+  }
+  async viewDependentsAll(viewName) {
+    // views
+    const views = [{
+      name: viewName,
+      dependencies: []
+    }];
+    // dependencies all
+    await this._viewDependentsAll_inner(viewName, views);
+    // swap
+    swapDeps(views);
+    // shift
+    views.shift();
+    // ready
+    return views.map(view => view.name);
+  }
+  async _viewDependentsAll_inner(viewName, views) {
+    const dependents = await this.viewDependents(viewName);
+    for (const dependent of dependents) {
+      // dependencies
+      const view = views.find(view => view.name === dependent);
+      if (view) {
+        const dep = cast(view.dependencies).find(dep => dep.toLowerCase() === viewName.toLowerCase());
+        if (!dep) {
+          cast(view.dependencies).push(viewName);
+        }
+      } else {
+        views.push({
+          name: dependent,
+          dependencies: [viewName]
+        });
+      }
+      // next
+      await this._viewDependentsAll_inner(dependent, views);
+    }
+  }
+  async _viewDependentsAll_handle(viewName, callback) {
+    // viewDependentsAll
+    const viewDependents = await this.viewDependentsAll(viewName);
+    // drop dependents
+    for (let i = viewDependents.length - 1; i >= 0; i--) {
+      const viewDependent = viewDependents[i];
+      await this.dropView(viewDependent, true);
+    }
+    // callback
+    await callback();
+    // create dependents
+    for (const viewDependent of viewDependents) {
+      await this.createView(viewDependent);
+    }
+  }
+}
+
+class BeanModelCrudInner extends BeanModelView {
+  async _mget(table, ids, options) {
+    const items = await this._mget_original(table, ids, options);
+    return items.filter(item => !isNil(item));
+  }
+
+  // with undefined
+  async _mget_original(table, ids, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // ids maybe empty
+    if (!ids || ids.length === 0) return [];
+    // params
+    const params = {
+      where: {
+        id: ids
+      }
+    };
+    if (options?.columns) {
+      params.columns = options?.columns;
+    }
+    // select
+    const options2 = options?.columns ? Object.assign({}, options, {
+      columns: undefined
+    }) : options;
+    const items = await this._select(table, params, options2);
+    // sort
+    const result = [];
+    for (const id of ids) {
+      // item maybe undefined
+      const item = items.find(item => cast(item).id === id);
+      result.push(item);
+    }
+    return result;
+  }
+  async _select(table, params, options, builder) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // builder
+    builder = builder ?? this._select_buildParams(table, params, options);
+    // ready
+    this.$loggerChild('model').debug('model.select: %s', builder.toQuery());
+    return await builder;
+  }
+  _select_buildParams(table, params, options) {
+    // builder
+    const builder = this.builder(table);
+    // groups
+    const groups = this.buildGroups(builder, params?.groups);
+    // columns
+    this.buildColumns(builder, params?.columns, groups);
+    // distinct
+    this.buildDistinct(builder, params?.distinct);
+    // aggregate
+    this.buildAggrs(builder, params?.aggrs);
+    // joins
+    this.buildJoins(builder, params?.joins);
+    // where
+    this.prepareWhere(builder, table, params?.where, options);
+    // having
+    this.prepareHaving(builder, params?.having);
+    // orders
+    this.buildOrders(builder, params?.orders);
+    // limit
+    this.buildLimit(builder, params?.limit);
+    // offset
+    this.buildOffset(builder, params?.offset);
+    // ok
+    return builder;
+  }
+  async _get(table, where, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // params
+    const params = {
+      where,
+      limit: 1
+    };
+    if (options?.columns) {
+      params.columns = options?.columns;
+    }
+    // select
+    const items = await this._select(table, params, options);
+    const item = items[0];
+    if (!item) return undefined;
+    return item;
+  }
+  async _count(table, params, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // params
+    params = params || {};
+    // builder
+    const builder = this.builder(table);
+    // count
+    this.buildCount(builder, params.column, params.distinct);
+    // joins
+    this.buildJoins(builder, params.joins);
+    // where
+    this.prepareWhere(builder, table, params.where, options);
+    // ready
+    this.$loggerChild('model').debug('model.count: %s', builder.toQuery());
+    const res = await builder;
+    return this.extractFirstNumber(res);
+  }
+  async _insertBulk(table, data, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // data
+    data = data || {};
+    const datasTemp = Array.isArray(data) ? data : [data];
+    // options
+    const datas = [];
+    const datasOriginal = [];
+    for (const dataTemp of datasTemp) {
+      // first
+      const dataTemp2 = this._prepareInsertDataByOptions(table, dataTemp, options);
+      // then
+      const [dataNew, dataNewOriginal] = await this.prepareData(table, dataTemp2);
+      datas.push(dataNew);
+      datasOriginal.push(dataNewOriginal);
+    }
+    // builder
+    const builder = this.builder(table);
+    // insert
+    builder.insert(datas);
+    // debug
+    this.$loggerChild('model').debug('model.insert: %s', builder.toQuery());
+    // dialect insert
+    const ids = await this.dialect.insert(builder);
+    // combine
+    const result = [];
+    const dataDefault = await this.defaultData(table);
+    for (let index = 0; index < ids.length; index++) {
+      const dataWithId = {};
+      if (ids[index] !== undefined) dataWithId.id = ids[index];
+      // datasOriginal[index] maybe has id
+      result.push(Object.assign({}, dataDefault, dataWithId, datasOriginal[index]));
+    }
+    // ok
+    return Array.isArray(data) ? result : result[0];
+  }
+  async _update(table, data, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // data
+    [data] = await this.prepareData(table, data);
+    // where
+    const where = Object.assign({}, options?.where);
+    // id
+    const columnId = `${table}.id`;
+    for (const key of ['id', columnId]) {
+      if (!isNil(data[key])) {
+        cast(where).id = data[key];
+        delete data[key];
+      }
+    }
+    // disableUpdateTime
+    if (!this._checkDisableUpdateTimeByOptions(options)) {
+      cast(data).updatedAt = new Date();
+    }
+    // builder
+    const builder = this.builder(table);
+    // update
+    builder.update(data);
+    // where
+    this.prepareWhere(builder, table, where, options);
+    // debug
+    this.$loggerChild('model').debug('model.update: %s', builder.toQuery());
+    // ready
+    await builder;
+    // ok
+    return data;
+  }
+  async _delete(table, where, options) {
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // disableDeleted
+    if (!this._checkDisableDeletedByOptions(options)) {
+      // need not set options2: disableDeleted: true, deleted: undefined
+      const options2 = Object.assign({}, options, {
+        where
+      });
+      await this._update(table, {
+        deleted: true
+      }, options2);
+      return;
+    }
+    // builder
+    const builder = this.builder(table);
+    // delete
+    builder.delete();
+    // where
+    this.prepareWhere(builder, table, where, options);
+    // debug
+    this.$loggerChild('model').debug('model.delete: %s', builder.toQuery());
+    // ready
+    await builder;
+  }
+}
+
+class BeanModelCrudTable extends BeanModelCrudInner {
+  async mget(table, ids, options) {
+    return await this._mget(table, ids, options);
+  }
+  async select(table, params, options) {
+    return await this._select(table, params, options);
+  }
+  async get(table, where, options) {
+    return await this._get(table, where, options);
+  }
+  async count(table, params, options) {
+    return await this._count(table, params, options);
+  }
+  async insert(table, data, options) {
+    return await this._insertBulk(table, data, options);
+  }
+  async insertBulk(table, data, options) {
+    return await this._insertBulk(table, data, options);
+  }
+  async update(table, data, options) {
+    return await this._update(table, data, options);
+  }
+  async delete(table, where, options) {
+    return await this._delete(table, where, options);
+  }
+}
+
+var _dec$d, _dec2$d, _dec3$3, _class$d;
+let BeanModel = (_dec$d = Bean(), _dec2$d = Virtual(), _dec3$3 = BeanInfo({
+  module: "a-orm"
+}), _dec$d(_class$d = _dec2$d(_class$d = _dec3$3(_class$d = class BeanModel extends BeanModelCrudTable {}) || _class$d) || _class$d) || _class$d);
+
+const SymbolCacheOptions = Symbol('SymbolCacheOptions');
+const SymbolCacheEnabled = Symbol('SymbolCacheEnabled');
+class ModelCacheBase extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this[SymbolCacheOptions] = void 0;
+    this._model = void 0;
+    this._cacheType = void 0;
+  }
+  __init__(model, cacheType) {
+    this._model = model;
+    this._cacheType = cacheType;
+  }
+  get scopeOrm() {
+    return this.$scope.orm;
+  }
+  getInstance(table) {
+    if (this.options === false) throw new Error('cache disabled');
+    return this.app.bean.summer.cache(this.getName(table), this.options);
+  }
+  getName(table) {
+    const clientNameReal = this.$scope.orm.service.database.prepareClientNameReal(this._model.db.clientName);
+    return `${this.$beanFullName}:${clientNameReal}:${table}:${this._cacheType}`;
+  }
+  get options() {
+    if (this[SymbolCacheOptions] === undefined) {
+      this[SymbolCacheOptions] = this._getCacheOptionsInner();
+    }
+    return this[SymbolCacheOptions];
+  }
+  get enabled() {
+    if (this[SymbolCacheEnabled] === undefined) {
+      this[SymbolCacheEnabled] = this._getCacheEnabledInner();
+    }
+    return this[SymbolCacheEnabled];
+  }
+  _getCacheEnabledInner() {
+    if (this.options === false) return false;
+    // enable
+    if (!this.bean.onion.checkOnionOptionsEnabled(this.options)) return false;
+    // default
+    return true;
+  }
+  _getCacheOptionsInner() {
+    if (this._model.options.cache?.[this._cacheType] === false) return false;
+    // options
+    let _cacheOptions = this._model.options.cache?.[this._cacheType] ?? {};
+    // preset
+    let configPreset;
+    let preset = _cacheOptions.preset;
+    if (!preset && !_cacheOptions.mode) preset = this.scopeOrm.config.summer.presetDefault;
+    if (preset) {
+      configPreset = this.scopeOrm.config.summer.preset[preset];
+    }
+    // extend
+    _cacheOptions = deepExtend({
+      enable: this.scopeOrm.config.summer.enable,
+      meta: this.scopeOrm.config.summer.meta,
+      redis: {
+        client: this.scopeOrm.config.summer.redis.client
+      }
+    }, configPreset, _cacheOptions, {
+      preset: undefined
+    });
+    // ok
+    return _cacheOptions;
+  }
+}
+
+var _dec$c, _dec2$c, _class$c;
+let ServiceCacheEntity = (_dec$c = Service(), _dec2$c = BeanInfo({
+  module: "a-orm"
+}), _dec$c(_class$c = _dec2$c(_class$c = class ServiceCacheEntity extends ModelCacheBase {
+  __init__(model) {
+    super.__init__(model, 'entity');
+  }
+  async clear(table) {
+    if (!this.enabled) return;
+    table = table || this._model.getTable();
+    const cache = this.getInstance(table);
+    await cache.clear();
+  }
+  async del(id, table) {
+    if (!this.enabled) return;
+    table = table || this._model.getTable();
+    const cache = this.getInstance(table);
+    if (Array.isArray(id)) {
+      await cache.mdel(id);
+    } else {
+      await cache.del(id);
+    }
+  }
+  get keysAux() {
+    return this._model.options.cache?.keysAux;
+  }
+}) || _class$c) || _class$c);
+
+var _dec$b, _dec2$b, _class$b;
+let ServiceCacheQuery = (_dec$b = Service(), _dec2$b = BeanInfo({
+  module: "a-orm"
+}), _dec$b(_class$b = _dec2$b(_class$b = class ServiceCacheQuery extends ModelCacheBase {
+  __init__(model) {
+    super.__init__(model, 'query');
+  }
+  async clear(table) {
+    if (!this.enabled) return;
+    table = table || this._model.getTable();
+    const cache = this.getInstance(table);
+    await cache.clear();
+  }
+}) || _class$b) || _class$b);
+
+var _dec$a, _dec2$a, _class$a;
+let ServiceRelations = (_dec$a = Service(), _dec2$a = BeanInfo({
+  module: "a-orm"
+}), _dec$a(_class$a = _dec2$a(_class$a = class ServiceRelations extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._model = void 0;
+  }
+  __init__(model) {
+    this._model = model;
+  }
+  async handleRelationsOne(entity, includeWrapper, methodOptions) {
+    if (!entity) return entity;
+    // relations
+    const relations = this.__handleRelationsCollection(includeWrapper);
+    if (!relations) return entity;
+    for (const relation of relations) {
+      await this.__handleRelationOne(entity, relation, methodOptions);
+    }
+    return entity;
+  }
+  async handleRelationsMany(entities, includeWrapper, methodOptions) {
+    if (entities.length === 0) return entities;
+    // relations
+    const relations = this.__handleRelationsCollection(includeWrapper);
+    if (!relations) return entities;
+    for (const relation of relations) {
+      await this.__handleRelationMany(entities, relation, methodOptions);
+    }
+    return entities;
+  }
+  async handleRelationsMutate(entitiesResult, entities, includeWrapper, methodOptions) {
+    if (entitiesResult.length === 0) return entitiesResult;
+    // relations
+    const relations = this.__handleRelationsCollection(includeWrapper);
+    if (!relations) return entitiesResult;
+    for (const relation of relations) {
+      entitiesResult = await this.__handleRelationMutate(entitiesResult, entities, relation, methodOptions);
+    }
+    return entitiesResult;
+  }
+  async handleRelationsDelete(ids, includeWrapper, methodOptions) {
+    if (ids.length === 0) return;
+    // relations
+    const relations = this.__handleRelationsCollection(includeWrapper);
+    if (!relations) return;
+    for (const relation of relations) {
+      await this.__handleRelationDelete(ids, relation, methodOptions);
+    }
+  }
+  async __handleRelationOne(entity, relation, methodOptions) {
+    const [relationName, relationReal, includeReal, withReal] = relation;
+    const {
+      type,
+      modelMiddle,
+      model,
+      keyFrom,
+      keyTo,
+      key,
+      options
+    } = relationReal;
+    const modelTarget = this.__getModelTarget(model, options?.meta);
+    const tableNameTarget = modelTarget.getTable();
+    const optionsReal = Object.assign({}, options, {
+      include: includeReal,
+      with: withReal
+    });
+    const methodOptionsReal = Object.assign({}, methodOptions, {
+      columns: undefined
+    });
+    if (type === 'hasOne') {
+      const idFrom = cast(entity).id;
+      if (isNil(idFrom)) {
+        entity[relationName] = undefined;
+      } else {
+        const where = {
+          [key]: idFrom
+        };
+        const options2 = deepExtend({}, methodOptionsReal, optionsReal);
+        entity[relationName] = await modelTarget.get(where, options2);
+      }
+    } else if (type === 'belongsTo') {
+      const idTo = cast(entity)[key];
+      if (isNil(idTo)) {
+        entity[relationName] = undefined;
+      } else {
+        const where = {
+          id: idTo
+        };
+        const options2 = deepExtend({}, methodOptionsReal, optionsReal);
+        entity[relationName] = await modelTarget.get(where, options2);
+      }
+    } else if (type === 'hasMany') {
+      const idFrom = cast(entity).id;
+      if (isNil(idFrom)) {
+        entity[relationName] = optionsReal.groups ? [] : optionsReal.aggrs ? undefined : [];
+      } else {
+        if (optionsReal.groups) {
+          const options2 = deepExtend({}, optionsReal, {
+            where: {
+              [`${tableNameTarget}.${key}`]: idFrom
+            }
+          });
+          entity[relationName] = await modelTarget.group(options2, methodOptionsReal);
+        } else if (optionsReal.aggrs) {
+          const options2 = deepExtend({}, optionsReal, {
+            where: {
+              [`${tableNameTarget}.${key}`]: idFrom
+            }
+          });
+          entity[relationName] = await modelTarget.aggregate(options2, methodOptionsReal);
+        } else {
+          const options2 = deepExtend({}, optionsReal, {
+            where: {
+              [`${tableNameTarget}.${key}`]: idFrom
+            }
+          });
+          entity[relationName] = await modelTarget.select(options2, methodOptionsReal);
+        }
+      }
+    } else if (type === 'belongsToMany') {
+      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle);
+      const idFrom = cast(entity).id;
+      if (isNil(idFrom)) {
+        entity[relationName] = optionsReal.groups ? [] : optionsReal.aggrs ? undefined : [];
+      } else {
+        const itemsMiddle = await modelTargetMiddle.select({
+          where: {
+            [keyFrom]: idFrom
+          }
+        }, methodOptionsReal);
+        const idsTo = itemsMiddle.map(item => item[keyTo]);
+        if (optionsReal.groups) {
+          const options2 = deepExtend({}, optionsReal, {
+            where: {
+              [`${tableNameTarget}.id`]: idsTo
+            }
+          });
+          entity[relationName] = await modelTarget.group(options2, methodOptionsReal);
+        } else if (optionsReal.aggrs) {
+          const options2 = deepExtend({}, optionsReal, {
+            where: {
+              [`${tableNameTarget}.id`]: idsTo
+            }
+          });
+          entity[relationName] = await modelTarget.aggregate(options2, methodOptionsReal);
+        } else {
+          const options2 = deepExtend({}, methodOptionsReal, optionsReal);
+          entity[relationName] = await modelTarget.mget(idsTo, options2);
+        }
+      }
+    }
+  }
+  async __handleRelationMany(entities, relation, methodOptions) {
+    const [relationName, relationReal, includeReal, withReal] = relation;
+    const {
+      type,
+      modelMiddle,
+      model,
+      keyFrom,
+      keyTo,
+      key,
+      options
+    } = relationReal;
+    const modelTarget = this.__getModelTarget(model, options?.meta);
+    const tableNameTarget = modelTarget.getTable();
+    const optionsReal = Object.assign({}, options, {
+      include: includeReal,
+      with: withReal
+    });
+    const methodOptionsReal = Object.assign({}, methodOptions, {
+      columns: undefined
+    });
+    if (type === 'hasOne') {
+      const idsFrom = entities.map(item => cast(item).id).filter(id => !isNil(id));
+      const [columns, withKey] = this.__prepareColumnsAndKey(optionsReal.columns, key);
+      const options2 = deepExtend({}, optionsReal, {
+        columns,
+        where: {
+          [key]: idsFrom
+        }
+      });
+      const items = await modelTarget.select(options2, methodOptionsReal);
+      for (const entity of entities) {
+        entity[relationName] = items.find(item => {
+          if (item[key] === cast(entity).id) {
+            if (!withKey) delete item[key];
+            return true;
+          }
+          return false;
+        });
+      }
+    } else if (type === 'belongsTo') {
+      const idsTo = entities.map(item => cast(item)[key]).filter(id => !isNil(id));
+      const options2 = deepExtend({}, methodOptionsReal, optionsReal);
+      const items = await modelTarget.mget(idsTo, options2);
+      for (const entity of entities) {
+        entity[relationName] = items.find(item => cast(item).id === cast(entity)[key]);
+      }
+    } else if (type === 'hasMany') {
+      const idsFrom = entities.map(item => cast(item).id).filter(id => !isNil(id));
+      if (optionsReal.groups) {
+        const groups = [`${tableNameTarget}.${key}`].concat(optionsReal.groups);
+        const options2 = deepExtend({}, optionsReal, {
+          groups,
+          where: {
+            [`${tableNameTarget}.${key}`]: idsFrom
+          }
+        });
+        const items = await modelTarget.group(options2, methodOptionsReal);
+        for (const entity of entities) {
+          entity[relationName] = [];
+          for (const item of items) {
+            if (item[key] === cast(entity).id) {
+              delete item[key];
+              entity[relationName].push(item);
+            }
+          }
+        }
+      } else if (optionsReal.aggrs) {
+        const options2 = deepExtend({}, optionsReal, {
+          groups: `${tableNameTarget}.${key}`,
+          where: {
+            [`${tableNameTarget}.${key}`]: idsFrom
+          }
+        });
+        const items = await modelTarget.group(options2, methodOptionsReal);
+        for (const entity of entities) {
+          entity[relationName] = items.find(item => item[key] === cast(entity).id);
+        }
+      } else {
+        const [columns, withKey] = this.__prepareColumnsAndKey(optionsReal.columns, key);
+        const options2 = deepExtend({}, optionsReal, {
+          columns,
+          where: {
+            [`${tableNameTarget}.${key}`]: idsFrom
+          }
+        });
+        const items = await modelTarget.select(options2, methodOptionsReal);
+        for (const entity of entities) {
+          entity[relationName] = [];
+          for (const item of items) {
+            if (item[key] === cast(entity).id) {
+              if (!withKey) delete item[key];
+              entity[relationName].push(item);
+            }
+          }
+        }
+      }
+    } else if (type === 'belongsToMany') {
+      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle);
+      const idsFrom = entities.map(item => cast(item).id).filter(id => !isNil(id));
+      const itemsMiddle = await modelTargetMiddle.select({
+        where: {
+          [keyFrom]: idsFrom
+        }
+      }, methodOptionsReal);
+      if (optionsReal.groups) {
+        for (const entity of entities) {
+          const idsTo = itemsMiddle.filter(item => item[keyFrom] === cast(entity).id).map(item => item[keyTo]);
+          const options2 = deepExtend({}, optionsReal, {
+            groups: optionsReal.groups,
+            where: {
+              [`${tableNameTarget}.id`]: idsTo
+            }
+          });
+          entity[relationName] = await modelTarget.group(options2, methodOptionsReal);
+        }
+      } else if (optionsReal.aggrs) {
+        for (const entity of entities) {
+          const idsTo = itemsMiddle.filter(item => item[keyFrom] === cast(entity).id).map(item => item[keyTo]);
+          const options2 = deepExtend({}, optionsReal, {
+            where: {
+              [`${tableNameTarget}.id`]: idsTo
+            }
+          });
+          entity[relationName] = await modelTarget.aggregate(options2, methodOptionsReal);
+        }
+      } else {
+        const idsTo = itemsMiddle.map(item => item[keyTo]);
+        const options2 = deepExtend({}, methodOptionsReal, optionsReal);
+        const items = await modelTarget.mget(idsTo, options2);
+        for (const entity of entities) {
+          entity[relationName] = [];
+          for (const itemMiddle of itemsMiddle) {
+            if (itemMiddle[keyFrom] === cast(entity).id) {
+              entity[relationName].push(items.find(item => cast(item).id === cast(itemMiddle)[keyTo]));
+            }
+          }
+        }
+      }
+    }
+  }
+  async __handleRelationMutate(entitiesResult, entities, relation, methodOptions) {
+    const [relationName, relationReal, includeReal, withReal] = relation;
+    const {
+      type,
+      modelMiddle,
+      model,
+      keyFrom,
+      keyTo,
+      key,
+      options
+    } = relationReal;
+    const modelTarget = this.__getModelTarget(model, options?.meta);
+    const methodOptionsReal = Object.assign({}, methodOptions, {
+      include: includeReal,
+      with: withReal
+    });
+    if (type === 'hasOne') {
+      let children = [];
+      for (let index = 0; index < entities.length; index++) {
+        const entity = entities[index];
+        if (entity[relationName]) {
+          // donot checkif has id of entity[relationName], for safety
+          const item = await modelTarget.get({
+            [key]: cast(entity).id
+          });
+          if (!isNil(item?.id) && !isNil(entity[relationName].id) && item?.id !== entity[relationName].id) {
+            throw new Error(`invalid id: ${entity[relationName].id}`);
+          }
+          children.push(Object.assign({}, entity[relationName], {
+            [key]: cast(entity).id,
+            id: item?.id
+          }));
+        }
+      }
+      children = await modelTarget.mutateBulk(children, methodOptionsReal);
+      const result = entitiesResult.concat();
+      for (let index = 0; index < entities.length; index++) {
+        const entityResult = result[index];
+        const entity = entities[index];
+        if (entity[relationName]) {
+          entityResult[relationName] = children.find(item => item[key] === cast(entity).id);
+        }
+      }
+      return result;
+    } else if (type === 'belongsTo') {
+      // do nothing
+      return entitiesResult;
+    } else if (type === 'hasMany') {
+      let children = [];
+      for (let index = 0; index < entities.length; index++) {
+        const entity = entities[index];
+        if (entity[relationName] && entity[relationName].length > 0) {
+          const entityId = cast(entity).id;
+          const idsTo = entity[relationName].map(item => item.id).filter(id => !isNil(id));
+          const itemsTarget = await cast(modelTarget).__select_raw(undefined, {
+            where: {
+              [key]: entityId,
+              id: idsTo
+            }
+          }, methodOptionsReal);
+          const idsTarget = itemsTarget.map(item => item.id);
+          for (const child of entity[relationName]) {
+            if (!isNil(child.id) && !idsTarget.includes(child.id)) {
+              throw new Error(`invalid id: ${child.id}`);
+            }
+            children.push(Object.assign({}, child, {
+              [key]: entityId
+            }));
+          }
+        }
+      }
+      children = await modelTarget.mutateBulk(children, methodOptionsReal);
+      const result = entitiesResult.concat();
+      for (let index = 0; index < entities.length; index++) {
+        const entityResult = result[index];
+        const entity = entities[index];
+        if (entity[relationName]) {
+          entityResult[relationName] = [];
+          for (const child of children) {
+            if (child[key] === cast(entity).id) {
+              entityResult[relationName].push(child);
+            }
+          }
+        }
+      }
+      return result;
+    } else if (type === 'belongsToMany') {
+      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle);
+      let children = [];
+      for (let index = 0; index < entities.length; index++) {
+        const entity = entities[index];
+        if (entity[relationName] && entity[relationName].length > 0) {
+          const idsTo = entity[relationName].map(item => item.id);
+          const itemsMiddle = await cast(modelTargetMiddle).__select_raw(undefined, {
+            where: {
+              [keyFrom]: cast(entity).id,
+              [keyTo]: idsTo
+            }
+          }, methodOptionsReal);
+          for (const child of entity[relationName]) {
+            const itemMiddle = itemsMiddle.find(item => item[keyTo] === child.id);
+            if (!itemMiddle) {
+              if (!child.deleted) {
+                // add
+                children.push({
+                  [keyFrom]: cast(entity).id,
+                  [keyTo]: child.id
+                });
+              }
+            } else {
+              if (child.deleted) {
+                // delete
+                children.push({
+                  id: itemMiddle.id,
+                  deleted: child.deleted
+                });
+              }
+            }
+          }
+        }
+      }
+      children = await modelTargetMiddle.mutateBulk(children, methodOptionsReal);
+      const result = entitiesResult.concat();
+      for (let index = 0; index < entities.length; index++) {
+        const entityResult = result[index];
+        const entity = entities[index];
+        if (entity[relationName]) {
+          entityResult[relationName] = [];
+          for (const child of children) {
+            if (child[keyFrom] === cast(entity).id) {
+              entityResult[relationName].push({
+                id: child[keyTo]
+              });
+            }
+          }
+        }
+      }
+      return result;
+    }
+    // do nothing
+    return entitiesResult;
+  }
+  async __handleRelationDelete(ids, relation, methodOptions) {
+    const [_relationName, relationReal, includeReal, withReal] = relation;
+    const {
+      type,
+      modelMiddle,
+      model,
+      keyFrom,
+      key,
+      options
+    } = relationReal;
+    const modelTarget = this.__getModelTarget(model, options?.meta);
+    const methodOptionsReal = Object.assign({}, methodOptions, {
+      include: includeReal,
+      with: withReal
+    });
+    if (type === 'hasOne' || type === 'hasMany') {
+      const children = await cast(modelTarget).__select_raw(undefined, {
+        columns: 'id',
+        where: {
+          [key]: ids
+        }
+      }, methodOptionsReal);
+      const idsTo = children.map(item => item.id);
+      await modelTarget.deleteBulk(idsTo, methodOptionsReal);
+    } else if (type === 'belongsTo') ; else if (type === 'belongsToMany') {
+      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle);
+      const itemsMiddle = await cast(modelTargetMiddle).__select_raw(undefined, {
+        columns: 'id',
+        where: {
+          [keyFrom]: ids
+        }
+      }, methodOptionsReal);
+      const idsMiddle = itemsMiddle.map(item => item.id);
+      await modelTargetMiddle.deleteBulk(idsMiddle, methodOptionsReal);
+    }
+  }
+  __prepareColumnsAndKey(columns, key) {
+    if (!columns) return [columns, true];
+    columns = Array.isArray(columns) ? columns : [columns];
+    if (columns.includes('*') || columns.includes(key)) return [columns, true];
+    columns.push(key);
+    return [columns, false];
+  }
+  __getModelTarget(modelClassTarget, meta) {
+    return this._model.newInstanceTarget(modelClassTarget, meta?.client, meta?.table);
+  }
+  __handleRelationsCollection(includeWrapper) {
+    // collect
+    const relations = [];
+    // include
+    if (this._model.options.relations) {
+      for (const key in this._model.options.relations) {
+        const relationDef = this._model.options.relations[key];
+        const relationCur = includeWrapper?.include?.[key];
+        let relationReal;
+        let includeReal;
+        let withReal;
+        if (relationCur === false) {
+          continue;
+        } else if (relationCur === true) {
+          relationReal = relationDef;
+        } else if (typeof relationCur === 'object') {
+          relationReal = deepExtend({}, relationDef, {
+            options: relationCur
+          });
+          includeReal = relationCur.include;
+          withReal = relationCur.with;
+        } else if (relationDef.options?.autoload) {
+          relationReal = relationDef;
+        } else {
+          continue;
+        }
+        relations.push([key, relationReal, includeReal, withReal]);
+      }
+    }
+    // with
+    if (includeWrapper?.with) {
+      for (const key in includeWrapper.with) {
+        const relationReal = includeWrapper.with[key];
+        if (!relationReal) continue;
+        relations.push([key, relationReal, relationReal.options?.include, relationReal.options?.with]);
+      }
+    }
+    return relations;
+  }
+}) || _class$a) || _class$a);
+
+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);
+  }
+  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);
+  }
+}
+
+const SymbolModelsClearAll = Symbol('SymbolModelsClearAll');
+class BeanModelCache extends BeanModelCrud {
+  constructor(...args) {
+    super(...args);
+    this.cacheQuery = void 0;
+    this.cacheEntity = void 0;
+    this.relations = void 0;
+    this[SymbolModelsClearAll] = void 0;
+  }
+  __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);
+  }
+  async insert(data, options) {
+    if (!data) data = {};
+    const items = await this.insertBulk([data], options);
+    return items[0];
+  }
+  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);
+  }
+  async __insertBulk_raw(table, items, options) {
+    if (items.length === 0) return [];
+    // table
+    table = table || this.getTable();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // insert
+    const res = await this._insertBulk(table, items, options);
+    // clear cache
+    await this.cacheQueryClear(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();
+    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;
+  }
+  async mget(ids, options) {
+    const items = await this.__mget_raw(undefined, ids, options);
+    return await this.relations.handleRelationsMany(items, options, options);
+  }
+  async __mget_raw(table, ids, options) {
+    // table
+    table = table || this.getTable();
+    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);
+  }
+  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 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();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    const items = await this.__select_cache(table, params, options);
+    return this.convertItemsToBigNumber(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();
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    const items = await this.__select_cache(table, params, options);
+    return this.convertItemsToBigNumber(items);
+  }
+  async select(params, options, _modelJoins) {
+    const items = await this.__select_raw(undefined, params, options);
+    return await this.relations.handleRelationsMany(items, params, options);
+  }
+  async __select_raw(table, params, options) {
+    // table
+    table = table || this.getTable();
+    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;
+      }
+    }
+    // 2: mget
+    const ids = items.map(item => cast(item).id);
+    const options2 = params?.columns ? Object.assign({}, options, {
+      columns: params?.columns
+    }) : options;
+    return await this.__mget_raw(table, ids, options2);
+  }
+  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, {
+      get: async () => {
+        return await super._select(table, params, options, builder);
+      },
+      db: this.db
+    });
+    return items;
+  }
+  async get(where, options) {
+    const item = await this.__get_raw(undefined, where, options);
+    return await this.relations.handleRelationsOne(item, options, options);
+  }
+  async __get_raw(table, where, options) {
+    // table
+    table = table || this.getTable();
+    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 = options?.columns ? Object.assign({}, options, {
+        columns: undefined
+      }) : options;
+      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();
+    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;
+        options = Object.assign({}, options, {
+          where: undefined
+        });
+        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);
+        }
+        // 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();
+    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 __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
+        // disableInstance: use the model options, not use options by outer
+        return await super._get(table, where, {
+          disableDeleted: true
+        });
+      },
+      db: this.db
+    });
+    if (!item) return item;
+    if (!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);
+    });
+  }
+  __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.cacheEntity.del(id, table);
+    await this.cacheQueryClear(table);
+  }
+  async cacheEntityClear(table) {
+    await this.cacheEntity.clear(table);
+    await this.cacheQueryClear(table);
+  }
+  async cacheQueryClear(table) {
+    await this.cacheQuery.clear(table);
+    await this._cacheQueryClearModelsClear();
+  }
+  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);
+      } else {
+        await modelTarget.cacheQueryClear();
+      }
+    }
+  }
+  _getModelsClear(modelName) {
+    const modelsClearAll = this._getModelsClearAll();
+    return modelsClearAll[modelName ?? this.$onionName];
+  }
+  _getModelsClearAll() {
+    if (!this[SymbolModelsClearAll]) {
+      this[SymbolModelsClearAll] = this._collectModelsClearAll();
+    }
+    return this[SymbolModelsClearAll];
+  }
+  _collectModelsClearAll() {
+    const modelsClearAll = {};
+    const onionSlices = this.bean.onion.model.getOnionsEnabled();
+    for (const onionSlice of onionSlices) {
+      const modelName = onionSlice.name;
+      if (!modelsClearAll[modelName]) modelsClearAll[modelName] = [];
+      //
+      const modelsClear = onionSlice.beanOptions.options?.cache?.modelsClear;
+      if (modelsClear) {
+        const modelsClear2 = Array.isArray(modelsClear) ? modelsClear : [modelsClear];
+        modelsClearAll[modelName].push(...modelsClear2);
+      }
+      //
+      const modelsClearedBy = onionSlice.beanOptions.options?.cache?.modelsClearedBy;
+      if (modelsClearedBy) {
+        const modelsClearedBy2 = Array.isArray(modelsClearedBy) ? modelsClearedBy : [modelsClearedBy];
+        for (const modelName2 of modelsClearedBy2) {
+          if (!modelsClearAll[modelName2]) modelsClearAll[modelName2] = [];
+          modelsClearAll[modelName2].push(modelName);
+        }
+      }
+    }
+    return modelsClearAll;
+  }
+  _checkDisableCacheQueryByOptions(options) {
+    if (options?.disableCacheQuery === true || options?.disableCacheQuery === false) {
+      return options?.disableCacheQuery;
+    }
+    return !this.cacheQuery.enabled;
+  }
+  _checkDisableCacheEntityByOptions(options) {
+    if (options?.disableCacheEntity === true || options?.disableCacheEntity === false) {
+      return options?.disableCacheEntity;
+    }
+    return !this.cacheEntity.enabled;
+  }
+  __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;
+    }
+  }
+  __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;
+  }
+}
+
+var _dec$9, _dec2$9, _dec3$2, _class$9;
+let BeanModelBase = (_dec$9 = Bean(), _dec2$9 = Virtual(), _dec3$2 = BeanInfo({
+  module: "a-orm"
+}), _dec$9(_class$9 = _dec2$9(_class$9 = _dec3$2(_class$9 = class BeanModelBase extends BeanModelCache {}) || _class$9) || _class$9) || _class$9);
+
+var _dec$8, _dec2$8, _dec3$1, _dec4$1, _class$8;
+const SymbolModuleScope$1 = Symbol('SymbolModuleScope');
+let ServiceEntityResolver = (_dec$8 = Service(), _dec2$8 = BeanInfo({
+  module: "a-orm"
+}), _dec3$1 = Reflect.metadata("design:type", Function), _dec4$1 = Reflect.metadata("design:paramtypes", [String]), _dec$8(_class$8 = _dec2$8(_class$8 = _dec3$1(_class$8 = _dec4$1(_class$8 = 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];
+  }
+}) || _class$8) || _class$8) || _class$8) || _class$8);
+
+var _dec$7, _dec2$7, _dec3, _dec4, _class$7;
+const SymbolModuleScope = Symbol('SymbolModuleScope');
+let ServiceModelResolver = (_dec$7 = Service(), _dec2$7 = BeanInfo({
+  module: "a-orm"
+}), _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [String]), _dec$7(_class$7 = _dec2$7(_class$7 = _dec3(_class$7 = _dec4(_class$7 = 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);
+  }
+}) || _class$7) || _class$7) || _class$7) || _class$7);
+
+var _dec$6, _dec2$6, _class$6;
+let BroadcastColumnsClear = (_dec$6 = Broadcast(), _dec2$6 = BeanInfo({
+  module: "a-orm"
+}), _dec$6(_class$6 = _dec2$6(_class$6 = class BroadcastColumnsClear extends BeanBroadcastBase {
+  async execute(data, isEmitter) {
+    const {
+      clientName,
+      tableName
+    } = data;
+    if (!isEmitter) {
+      await cast(this.scope.service.database).__columnsClearRaw(clientName, tableName);
+    }
+  }
+}) || _class$6) || _class$6);
+
+var _dec$5, _dec2$5, _class$5;
+let BroadcastDatabaseClientReload = (_dec$5 = Broadcast(), _dec2$5 = BeanInfo({
+  module: "a-orm"
+}), _dec$5(_class$5 = _dec2$5(_class$5 = class BroadcastDatabaseClientReload extends BeanBroadcastBase {
+  async execute(data, isEmitter) {
+    const {
+      clientName,
+      clientConfig,
+      extraData
+    } = data;
+    if (!isEmitter) {
+      await cast(this.scope.service.database).__reloadAllClientsRaw(clientName, clientConfig, extraData);
+    }
+  }
+}) || _class$5) || _class$5);
+
+var _dec$4, _dec2$4, _class$4;
+let EventClientNameReal = (_dec$4 = Event(), _dec2$4 = BeanInfo({
+  module: "a-orm"
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class EventClientNameReal extends BeanEventBase {}) || _class$4) || _class$4);
+
+var _dec$3, _dec2$3, _class$3;
+let EventColumnsClear = (_dec$3 = Event(), _dec2$3 = BeanInfo({
+  module: "a-orm"
+}), _dec$3(_class$3 = _dec2$3(_class$3 = class EventColumnsClear extends BeanEventBase {}) || _class$3) || _class$3);
+
+var _dec$2, _dec2$2, _class$2;
+let EventDatabaseClientReload = (_dec$2 = Event(), _dec2$2 = BeanInfo({
+  module: "a-orm"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class EventDatabaseClientReload extends BeanEventBase {}) || _class$2) || _class$2);
+
+var _dec$1, _dec2$1, _class$1;
+let ScheduleSoftDeletionPrune = (_dec$1 = Schedule({
+  repeat: {
+    every: 24 * 3600 * 1000
+  }
+}), _dec2$1 = BeanInfo({
+  module: "a-orm"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class ScheduleSoftDeletionPrune extends BeanBase {
+  async execute() {
+    const onionSlices = this.bean.onion.model.getOnionsEnabled();
+    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 _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
+      });
+    } else {
+      const expiredTime = new Date(Date.now() - expired);
+      await modelTarget.delete({
+        deleted: true,
+        updatedAt: {
+          _lt_: expiredTime
+        }
+      }, {
+        disableDeleted: true
+      });
+    }
+  }
+}) || _class$1) || _class$1);
+
+function config(_app) {
+  return {
+    table: {
+      identityType: 'string'
+    },
+    model: {
+      disableDeleted: false,
+      disableInstance: false,
+      disableCreateTime: false,
+      disableUpdateTime: false
+    },
+    softDeletionPrune: {
+      enable: true,
+      expired: 14 * 24 * 3600 * 1000
+    },
+    dialects: {
+      mysql: 'a-ormdialect.databaseDialect.mysql',
+      mysql2: 'a-ormdialect.databaseDialect.mysql3',
+      pg: 'a-ormdialect.databaseDialect.pg'
+    },
+    summer: {
+      enable: true,
+      meta: {},
+      presetDefault: 'redis',
+      preset: {
+        redis: configRedis,
+        redisWithIgnoreNull: configRedisWithIgnoreNull,
+        all: configAll,
+        allWithIgnoreNull: configAllWithIgnoreNull
+      },
+      redis: {
+        client: 'model'
+      }
+    }
+  };
+}
+
+var locale_en_us = {
+  TableIdentity: 'ID',
+  CreatedAt: 'Created At',
+  UpdatedAt: 'Updated At',
+  Deleted: 'Deleted',
+  InstanceId: 'Instance ID',
+  ShouldSpecifyTable: 'should specify the table name'
+};
+
+var locale_zh_cn = {
+  TableIdentity: '标识',
+  CreatedAt: '创建时间',
+  UpdatedAt: '修改时间',
+  Deleted: '已删除',
+  InstanceId: '实例标识',
+  ShouldSpecifyTable: '应该指定表名'
+};
+
+let Errors = /*#__PURE__*/function (Errors) {
+  Errors[Errors["ShouldSpecifyTable"] = 1001] = "ShouldSpecifyTable";
+  return Errors;
+}({});
+
+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.scope('a-orm').service.database.getDialect(client);
+      return await dialect[method](this, ...args);
+    });
+  });
+}
+
+const __ThisModule__ = 'a-orm';
+
+function ExtendTableBuilder(app) {
+  const scope = app.bean.scope(__ThisModule__);
+  function _basicFields(options, identityType) {
+    options = options || {};
+    if (options.id !== false) {
+      const _identityType = identityType ?? scope.config.table.identityType;
+      if (_identityType === 'string') {
+        this.bigIncrements();
+      } else if (_identityType === 'number') {
+        this.increments();
+      }
+    }
+    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 === 'string') {
+      return this.bigInteger(columnName); // default value is null
+    } else if (_identityType === 'number') {
+      return this.integer(columnName); // default value is null
+    }
+  });
+  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);
+    });
+  });
+}
+
+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 moduleLoaded() {
+    // ExtendKnex
+    ExtendKnex(this.app);
+    // db
+    Object.defineProperty(this.app.context, 'db', {
+      enumerable: false,
+      get() {
+        return this.app.bean._getBean(ServiceDatabaseAsyncLocalStorage$1).current;
+      }
+    });
+    // transactionConsistency
+    Object.defineProperty(this.app.context, 'transactionConsistency', {
+      enumerable: false,
+      get() {
+        if (!this[SymbolTransactionConsistency]) {
+          this[SymbolTransactionConsistency] = this.app.bean._newBean(ServiceTransactionConsistency_);
+        }
+        return this[SymbolTransactionConsistency];
+      }
+    });
+    // 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);
+          }
+        };
+      }
+    });
+    Object.defineProperty(this.app.context, 'commitDone', {
+      enumerable: false,
+      get() {
+        return function () {
+          cast(this).transactionConsistency.commitDone();
+        };
+      }
+    });
+  }
+  async configLoaded(_config) {}
+}
+async function configDefault(app) {
+  return {
+    testDatabase: false,
+    defaultClient: app.meta.env.DATABASE_DEFAULT_CLIENT,
+    clients: {
+      pg: {
+        client: 'pg',
+        connection: {
+          host: app.meta.env.DATABASE_CLIENT_PG_HOST,
+          port: Number.parseInt(app.meta.env.DATABASE_CLIENT_PG_PORT),
+          user: app.meta.env.DATABASE_CLIENT_PG_USER,
+          password: app.meta.env.DATABASE_CLIENT_PG_PASSWORD,
+          database: app.meta.env.DATABASE_CLIENT_PG_DATABASE
+        }
+      },
+      mysql: {
+        client: 'mysql2',
+        connection: {
+          host: app.meta.env.DATABASE_CLIENT_MYSQL_HOST,
+          port: Number.parseInt(app.meta.env.DATABASE_CLIENT_MYSQL_PORT),
+          user: app.meta.env.DATABASE_CLIENT_MYSQL_USER,
+          password: app.meta.env.DATABASE_CLIENT_MYSQL_PASSWORD,
+          database: app.meta.env.DATABASE_CLIENT_MYSQL_DATABASE
+        }
+      }
+    },
+    base: {
+      pool: {
+        min: 0,
+        max: 5
+      },
+      acquireConnectionTimeout: 60000 * 10,
+      asyncStackTraces: true
+    }
+  };
+}
+async function configDev(_app) {
+  return {
+    testDatabase: true,
+    base: {
+      pool: {
+        min: 0,
+        max: 1
+      }
+    }
+  };
+}
+async function configProd(_app) {
+  return {
+    testDatabase: false,
+    base: {
+      asyncStackTraces: false
+    }
+  };
+}
+async function configTest(_app) {
+  return {
+    testDatabase: true,
+    base: {
+      pool: {
+        min: 0,
+        max: 1
+      }
+    }
+  };
+}
+
+var _dec, _dec2, _class;
+const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn
+};
+let ScopeModuleAOrm = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-orm"
+}), _dec(_class = _dec2(_class = class ScopeModuleAOrm extends BeanScopeBase {}) || _class) || _class);
+function $locale(key) {
+  return `a-orm::${key}`;
+}
+/** scope: end */
+
+function Transaction(options) {
+  return Aspect.aopMethod('a-orm:transaction', options);
+}
+const Database = {
+  transaction: Transaction
+};
+
+function DatabaseDialect() {
+  return createBeanDecorator('databaseDialect');
+}
+
+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(), v.bigNumber())(classTarget.prototype, column2);
+    }
+  }
+  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);
+  }
+  // aggrs
+  if (aggrs) {
+    _DtoAggregate_inner(TargetClass, modelLike, aggrs);
+  }
+  // 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);
+  }
+}
+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
+  });
+  const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel);
+  if (mutateTypeTopLevel) {
+    let schema;
+    if (type === 'hasOne' || type === 'belongsTo') {
+      schema = v.lazy(v.optional(), schemaLazy);
+    } else {
+      schema = v.array(v.lazy(schemaLazy));
+    }
+    Api.field(v.optional(), schema)(entityClass.prototype, relationName);
+  } else {
+    let schema;
+    if (type === 'hasOne' || type === 'belongsTo') {
+      schema = v.lazy(v.optional(), schemaLazy);
+    } else {
+      if (optionsReal.groups) {
+        schema = v.array(v.lazy(schemaLazy));
+      } else if (optionsReal.aggrs) {
+        schema = v.lazy(v.optional(), schemaLazy);
+      } else {
+        schema = v.array(v.lazy(schemaLazy));
+      }
+    }
+    Api.field(schema)(entityClass.prototype, relationName);
+  }
+}
+function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel) {
+  return () => {
+    if (!autoload) {
+      return _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel);
+    }
+    // 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);
+      entityTarget[SymbolSchemaDynamicRefId] = dynamicName;
+      addSchemaDynamic(dynamicName, entityTarget);
+    }
+    return entityTarget;
+  };
+}
+function _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel) {
+  if (mutateTypeTopLevel) {
+    return _DtoMutate_raw(modelTarget, optionsReal, mutateTypeTopLevel, undefined, false); // 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;
+  // collect
+  const relations = [];
+  // include
+  if (options.relations) {
+    for (const key in options.relations) {
+      const relationDef = options.relations[key];
+      const relationCur = includeWrapper?.include?.[key];
+      let relationReal;
+      let includeReal;
+      let withReal;
+      let autoload;
+      if (relationCur === false) {
+        continue;
+      } else if (relationCur === true) {
+        relationReal = relationDef;
+        autoload = relationDef.options?.autoload;
+      } else if (typeof relationCur === 'object') {
+        relationReal = deepExtend({}, relationDef, {
+          options: relationCur
+        });
+        includeReal = relationCur.include;
+        withReal = relationCur.with;
+      } else if (relationDef.options?.autoload) {
+        relationReal = relationDef;
+        autoload = relationDef.options?.autoload;
+      } else {
+        continue;
+      }
+      relations.push([key, relationReal, includeReal, withReal, autoload]);
+    }
+  }
+  // with
+  if (includeWrapper?.with) {
+    for (const key in includeWrapper.with) {
+      const relationReal = includeWrapper.with[key];
+      if (!relationReal) continue;
+      relations.push([key, relationReal, relationReal.options?.include, relationReal.options?.with, false]);
+    }
+  }
+  return relations;
+}
+
+function _DtoMutate_raw(modelLike, params, mutateTypeTopLevel, columnsOmitDefault, topLevel) {
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  let entityClass = getClassEntityFromClassModel(modelClass);
+  // columns
+  const 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.splice(index, 1);
+        }
+      } else {
+        for (const key of ['deleted', 'id']) {
+          if (!columns.includes(key)) columns.unshift(key);
+        }
+      }
+    }
+    entityClass = $Class.pick(entityClass, prepareColumns(params?.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']);
+  }
+  // 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);
+}
+
+function DtoUpdate(modelLike, params) {
+  return $Class.partial(_DtoMutate_raw(modelLike, params, 'update', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true));
+}
+
+const $Dto = {
+  create: DtoCreate,
+  update: DtoUpdate,
+  get: DtoGet,
+  aggregate: DtoAggregate,
+  group: DtoGroup
+};
+
+// const __tableNames = new Set();
+
+function Entity(table, options) {
+  if (typeof table === 'string') {
+    options = Object.assign({}, options, {
+      table
+    });
+  } else {
+    options = 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 => {
+    mergeFieldsOpenapiMetadata(target);
+  });
+}
+
+function Model(options) {
+  return createBeanDecorator('model', options);
+}
+
+function hasOne$2(classModel, key, options) {
+  // :  IModelRelationHasOne<MODEL, AUTOLOAD, COLUMNS> {
+  return {
+    type: 'hasOne',
+    model: classModel,
+    key,
+    options
+  };
+}
+function belongsTo$1(_classModelSelf, classModel, key, options) {
+  // : IModelRelationBelongsTo<MODELSelf, MODEL, AUTOLOAD, COLUMNS> {
+  return {
+    type: 'belongsTo',
+    model: classModel,
+    key,
+    options
+  };
+}
+function hasMany$2(classModel, key, options, _modelJoins, _group) {
+  // : IModelRelationHasMany<MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+  return {
+    type: 'hasMany',
+    model: classModel,
+    key,
+    options
+  };
+}
+function belongsToMany$2(classModelMiddle, classModel, keyFrom, keyTo, options, _modelJoins, _group) {
+  // : IModelRelationBelongsToMany<MODELMiddle, MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+  return {
+    type: 'belongsToMany',
+    modelMiddle: classModelMiddle,
+    model: classModel,
+    keyFrom,
+    keyTo,
+    options
+  };
+}
+const $relation = {
+  hasOne: hasOne$2,
+  belongsTo: belongsTo$1,
+  hasMany: hasMany$2,
+  belongsToMany: belongsToMany$2
+};
+
+// function hasMany<
+//   MODEL extends BeanModelMeta | (keyof IModelClassRecord),
+//   AUTOLOAD extends boolean = boolean,
+//   COLUMNS
+//   extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+//   Aggrs extends TypeModelSelectAggrParamsAggrs<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   Groups extends TypeModelColumnsStrict<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+// >(
+//   classModel: TypeModelClassLike<MODEL>,
+//   key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+//   options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>,
+//   _modelJoins?: ModelJoins,
+//   _aggrs?: Aggrs,
+//   _groups?: Groups,
+// ): any { // : IModelRelationHasMany<MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+//   return { type: 'hasMany', model: classModel, key, options };
+// }
+
+// function belongsToMany<
+//   MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord),
+//   MODEL extends BeanModelMeta | (keyof IModelClassRecord),
+//   AUTOLOAD extends boolean = boolean,
+//   COLUMNS
+//   extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+//   Aggrs extends TypeModelSelectAggrParamsAggrs<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   Groups extends TypeModelColumnsStrict<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+// >(
+//   classModelMiddle: TypeModelClassLike<MODELMiddle>,
+//   classModel: TypeModelClassLike<MODEL>,
+//   keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+//   keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+//   options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>,
+//   _modelJoins?: ModelJoins,
+//   _aggrs?: Aggrs,
+//   _groups?: Groups,
+// ): any { // : IModelRelationBelongsToMany<MODELMiddle, MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+//   return { type: 'belongsToMany', modelMiddle: classModelMiddle, model: classModel, keyFrom, keyTo, options };
+// }
+
+function hasOne$1(classModel, key, options) {
+  return {
+    type: 'hasOne',
+    model: classModel,
+    key,
+    options
+  };
+}
+function belongsTo(_classModelSelf, classModel, key, options) {
+  return {
+    type: 'belongsTo',
+    model: classModel,
+    key,
+    options
+  };
+}
+function hasMany$1(classModel, key, options, _modelJoins, _group) {
+  return {
+    type: 'hasMany',
+    model: classModel,
+    key,
+    options
+  };
+}
+function belongsToMany$1(classModelMiddle, classModel, keyFrom, keyTo, options, _modelJoins, _group) {
+  return {
+    type: 'belongsToMany',
+    modelMiddle: classModelMiddle,
+    model: classModel,
+    keyFrom,
+    keyTo,
+    options
+  };
+}
+const $relationDynamic = {
+  hasOne: hasOne$1,
+  belongsTo,
+  hasMany: hasMany$1,
+  belongsToMany: belongsToMany$1
+};
+
+function hasOne(classModel, key, options) {
+  return {
+    type: 'hasOne',
+    model: classModel,
+    key,
+    options
+  };
+}
+
+// function belongsTo<
+//   MODELSelf extends BeanModelMeta | (keyof IModelClassRecord),
+//   MODEL extends BeanModelMeta | (keyof IModelClassRecord),
+//   OPTIONS extends IModelRelationOptionsOneMutate<TypeModelOfModelLike<MODEL>>,
+// >(
+//   _classModelSelf: TypeModelClassLike<MODELSelf>,
+//   classModel: TypeModelClassLike<MODEL>,
+//   key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity],
+//   options?: OPTIONS,
+// ): IModelRelationBelongsToDynamic<MODELSelf, MODEL, OPTIONS> {
+//   return { type: 'belongsTo', model: classModel, key, options };
+// }
+
+function hasMany(classModel, key, options) {
+  return {
+    type: 'hasMany',
+    model: classModel,
+    key,
+    options
+  };
+}
+function belongsToMany(classModelMiddle, classModel, keyFrom, keyTo, options) {
+  return {
+    type: 'belongsToMany',
+    modelMiddle: classModelMiddle,
+    model: classModel,
+    keyFrom,
+    keyTo,
+    options
+  };
+}
+const $relationMutate = {
+  hasOne,
+  // belongsTo,
+  hasMany,
+  belongsToMany
+};
+
+export { $Dto, $column, $columns, $columnsAll, $locale, $relation, $relationDynamic, $relationMutate, $tableColumns, $tableComments, $tableDefaults, $tableName, AopMethodTransaction, BeanDatabase, BeanDatabaseDialectBase, BeanModel, BeanModelBase, BeanModelMeta, BroadcastColumnsClear, BroadcastDatabaseClientReload, Database, DatabaseDialect, Entity, EntityBase, EntityBaseEmpty, EntityBaseInner, EntityBaseSimple, Errors, EventClientNameReal, EventColumnsClear, EventDatabaseClientReload, ExtendKnex, ExtendSchemaBuilder, ExtendTableBuilder, Main, Model, Op, OpAggrs, OpJoint, OpJointValues, OpNormal, OpNormalValues, OpValues, ScheduleSoftDeletionPrune, ScopeModuleAOrm, ServiceCacheEntity, ServiceCacheQuery, ServiceColumns, ServiceColumnsCache, ServiceDatabase, ServiceDatabaseAsyncLocalStorage, ServiceDatabaseClient, ServiceDb, ServiceEntityResolver, ServiceModelResolver, ServiceRelations, ServiceTransaction, ServiceTransactionAsyncLocalStorage, ServiceTransactionConsistency‌, ServiceTransactionFiber, ServiceTransactionState, SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyFieldsMore, SymbolKeyModelOptions, TransactionIsolationLevelsMap, buildWhere, config, configDefault, getClassEntityFromClassModel, getTableOrTableAlias, getTargetColumnName, isAggrColumn, isRaw, locales, prepareClassModel, prepareColumns };