vona-module-a-orm 5.0.95 → 5.1.1

package/src/bean/bean.model/bean.model_crud.ts

@@ -0,0 +1,46 @@
+import type { TableIdentity } from 'table-identity';
+
+import type {
+  IModelCountParams,
+  IModelGetOptionsGeneral,
+  IModelMethodOptionsGeneral,
+  IModelSelectParams,
+  IModelUpdateOptionsGeneral,
+  TypeModelWhere,
+} from '../../types/index.ts';
+
+import { BeanModelCrudInner } from './bean.model_crud_inner.ts';
+
+export class BeanModelCrud<TRecord extends {} = {}> extends BeanModelCrudInner<TRecord> {
+  async mget(ids: TableIdentity[], options?: IModelGetOptionsGeneral<TRecord>): Promise<Partial<TRecord>[]> {
+    return await this._mget(undefined, ids, options);
+  }
+
+  async select(params?: IModelSelectParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<Partial<TRecord>[]> {
+    return await this._select(undefined, params, options);
+  }
+
+  async get(where: TypeModelWhere<TRecord>, options?: IModelGetOptionsGeneral<TRecord>): Promise<Partial<TRecord> | undefined> {
+    return await this._get(undefined, where, options);
+  }
+
+  async count(params?: IModelCountParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<string | undefined> {
+    return await this._count(undefined, params, options);
+  }
+
+  async insert(data?: Partial<TRecord>, options?: IModelMethodOptionsGeneral): Promise<TRecord> {
+    return (await this._insertBulk(undefined, data, options)) as Promise<TRecord>;
+  }
+
+  async insertBulk(data: Partial<TRecord>[], options?: IModelMethodOptionsGeneral): Promise<TRecord[]> {
+    return (await this._insertBulk(undefined, data, options)) as Promise<TRecord[]>;
+  }
+
+  async update(data: Partial<TRecord>, options?: IModelUpdateOptionsGeneral<TRecord>): Promise<Partial<TRecord>> {
+    return await this._update(undefined, data, options);
+  }
+
+  async delete(where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void> {
+    return await this._delete(undefined, where, options);
+  }
+}

package/src/bean/bean.model/bean.model_crud_inner.ts

@@ -0,0 +1,281 @@
+import type { Knex } from 'knex';
+import type { TableIdentity } from 'table-identity';
+
+import { isNil } from '@cabloy/utils';
+import { cast } from 'vona';
+
+import type {
+  IModelCountParams,
+  IModelGetOptionsGeneral,
+  IModelIncrementParams,
+  IModelMethodOptionsGeneral,
+  IModelSelectGeneralParams,
+  IModelSelectParams,
+  IModelUpdateOptionsGeneral,
+  ITableRecord,
+  TypeModelWhere,
+} from '../../types/index.ts';
+
+import { BeanModelView } from './bean.model_view.ts';
+
+export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecord> {
+  protected async _mget(table?: keyof ITableRecord, ids?: TableIdentity[], options?: IModelGetOptionsGeneral<TRecord>): Promise<TRecord[]> {
+    const items = await this._mget_original(table, ids, options);
+    return items.filter(item => !isNil(item));
+  }
+
+  // with undefined
+  protected async _mget_original(
+    table?: keyof ITableRecord,
+    ids?: TableIdentity[],
+    options?: IModelGetOptionsGeneral<TRecord>,
+  ): Promise<(TRecord | undefined)[]> {
+    // table
+    table = table || this.getTable(undefined);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // ids maybe empty
+    if (!ids || ids.length === 0) return [];
+    // params
+    const params: IModelSelectParams<TRecord> = {
+      where: {
+        id: ids,
+      } as any,
+    };
+    if (options?.columns) {
+      params.columns = options?.columns as any;
+    }
+    // select
+    const options2 = options?.columns ? Object.assign({}, options, { columns: undefined }) : options;
+    const items = await this._select(table, params, options2);
+    // sort
+    const result: (TRecord | undefined)[] = [];
+    for (const id of ids) {
+      // item maybe undefined
+      const item = items.find(item => cast(item).id === id);
+      result.push(item);
+    }
+    return result;
+  }
+
+  protected async _select<T extends IModelSelectParams<TRecord>>(
+    table?: keyof ITableRecord,
+    params?: T,
+    options?: IModelMethodOptionsGeneral,
+    builder?: Knex.QueryBuilder<TRecord, TRecord[]>,
+  ): Promise<TRecord[]> {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // builder
+    builder = builder ?? this._select_buildParams(table, params as any, options);
+    // ready
+    this.$loggerChild('model').debug(() => `model.select: ${builder.toQuery()}`);
+    // datas
+    const datas = await builder;
+    return (await this.dialect.select(builder, datas, () => this.columns(table))) as TRecord[];
+  }
+
+  protected _select_buildParams<T extends IModelSelectGeneralParams<TRecord>>(
+    table: keyof ITableRecord,
+    params?: T,
+    options?: IModelMethodOptionsGeneral,
+  ) {
+    // builder
+    const builder = this.builder<TRecord, TRecord>(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 as any);
+    // orders
+    this.buildOrders(builder, params?.orders);
+    // limit
+    this.buildLimit(builder, params?.limit);
+    // offset
+    this.buildOffset(builder, params?.offset);
+    // ok
+    return builder;
+  }
+
+  protected async _get(
+    table: keyof ITableRecord | undefined,
+    where: TypeModelWhere<TRecord>,
+    options?: IModelGetOptionsGeneral<TRecord>,
+  ): Promise<TRecord | undefined> {
+    // table
+    table = table || this.getTable(where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // params
+    const params: IModelSelectParams<TRecord> = { where, limit: 1 };
+    if (options?.columns) {
+      params.columns = options?.columns as any;
+    }
+    // select
+    const items = await this._select(table, params, options);
+    const item = items[0];
+    if (!item) return undefined;
+    return item as unknown as TRecord;
+  }
+
+  protected async _count(
+    table?: keyof ITableRecord,
+    params?: IModelCountParams<TRecord>,
+    options?: IModelMethodOptionsGeneral,
+  ): Promise<string | undefined> {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // params
+    params = params || {};
+    // builder
+    const builder = this.builder<TRecord>(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: ${builder.toQuery()}`);
+    const res = await builder;
+    return this.extractFirstNumber(res);
+  }
+
+  protected async _increment(
+    table?: keyof ITableRecord,
+    params?: IModelIncrementParams<TRecord>,
+    options?: IModelMethodOptionsGeneral,
+  ): Promise<number> {
+    // table
+    table = table || this.getTable(params?.where);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // params
+    params = params || ({} as unknown as IModelIncrementParams<TRecord>);
+    // builder
+    const builder = this.builder<TRecord>(table);
+    // count
+    this.buildIncrement(builder, params.columns);
+    // joins
+    this.buildJoins(builder, params.joins);
+    // where
+    this.prepareWhere(builder, table, params.where, options);
+    // ready
+    this.$loggerChild('model').debug(() => `model.increment: ${builder.toQuery()}`);
+    const res = await builder;
+    return res as unknown as number;
+  }
+
+  protected async _insertBulk(
+    table?: keyof ITableRecord,
+    data?: Partial<TRecord> | Partial<TRecord>[],
+    options?: IModelMethodOptionsGeneral,
+  ): Promise<TRecord | TRecord[]> {
+    // data
+    data = data || ({} as any);
+    const datasTemp = Array.isArray(data) ? data : [data];
+    // table
+    table = table || this.getTable(datasTemp[0]);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // options
+    const datas: any[] = [];
+    const datasOriginal: any[] = [];
+    for (const dataTemp of datasTemp) {
+      // first
+      const dataTemp2 = this._prepareInsertDataByOptions(table, dataTemp, options);
+      // then
+      const [dataNew, dataNewOriginal] = await this.prepareData(table, dataTemp2);
+      if (isNil(cast(dataNewOriginal).id) && Object.prototype.hasOwnProperty.call(dataNewOriginal, 'id')) {
+        delete cast(dataNewOriginal).id;
+      }
+      datas.push(dataNew);
+      datasOriginal.push(dataNewOriginal);
+    }
+    // builder
+    const builder = this.builder<TRecord>(table);
+    // // debug
+    // this.$loggerChild('model').debug(() => `model.insert: ${builder.toQuery()}`);
+    // dialect insert
+    const ids = await this.dialect.insert(builder, datas);
+    // combine
+    const result: any[] = [];
+    const dataDefault = await this.defaultData(table);
+    for (let index = 0; index < ids.length; index++) {
+      const dataWithId: any = {};
+      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];
+  }
+
+  protected async _update(
+    table: keyof ITableRecord | undefined,
+    data: Partial<TRecord>,
+    options?: IModelUpdateOptionsGeneral<TRecord>,
+  ): Promise<Partial<TRecord>> {
+    // table
+    table = table || this.getTable(data);
+    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<TRecord>(table);
+    // update
+    builder.update(data as any);
+    // where
+    this.prepareWhere(builder, table, where, options);
+    // debug
+    this.$loggerChild('model').debug(() => `model.update: ${builder.toQuery()}`);
+    // ready
+    await builder;
+    // ok
+    return data;
+  }
+
+  protected async _delete(table?: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void> {
+    // table
+    table = table || this.getTable(where);
+    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 } as any, options2);
+      return;
+    }
+    // builder
+    const builder = this.builder<TRecord>(table);
+    // delete
+    builder.delete();
+    // where
+    this.prepareWhere(builder, table, where, options);
+    // debug
+    this.$loggerChild('model').debug(() => `model.delete: ${builder.toQuery()}`);
+    // ready
+    await builder;
+  }
+}

package/src/bean/bean.model/bean.model_crud_table.ts

@@ -0,0 +1,59 @@
+import type { TableIdentity } from 'table-identity';
+
+import type {
+  IModelCountParams,
+  IModelGetOptionsGeneral,
+  IModelMethodOptionsGeneral,
+  IModelSelectParams,
+  IModelUpdateOptionsGeneral,
+  ITableRecord,
+  TypeModelWhere,
+} from '../../types/index.ts';
+
+import { BeanModelCrudInner } from './bean.model_crud_inner.ts';
+
+export class BeanModelCrudTable<TRecord extends {}> extends BeanModelCrudInner<TRecord> {
+  async mget(
+    table: keyof ITableRecord,
+    ids: TableIdentity[],
+    options?: Omit<IModelGetOptionsGeneral<TRecord>, 'include' | 'with'>,
+  ): Promise<TRecord[]> {
+    return await this._mget(table, ids, options);
+  }
+
+  async select(
+    table: keyof ITableRecord,
+    params?: Omit<IModelSelectParams<TRecord>, 'include' | 'with'>,
+    options?: IModelMethodOptionsGeneral,
+  ): Promise<TRecord[]> {
+    return await this._select(table, params, options);
+  }
+
+  async get(
+    table: keyof ITableRecord,
+    where: TypeModelWhere<TRecord>,
+    options?: Omit<IModelGetOptionsGeneral<TRecord>, 'include' | 'with'>,
+  ): Promise<TRecord | undefined> {
+    return await this._get(table, where, options);
+  }
+
+  async count(table: keyof ITableRecord, params?: IModelCountParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<string | undefined> {
+    return await this._count(table, params, options);
+  }
+
+  async insert(table: keyof ITableRecord, data?: Partial<TRecord>, options?: IModelMethodOptionsGeneral): Promise<TRecord> {
+    return (await this._insertBulk(table, data, options)) as Promise<TRecord>;
+  }
+
+  async insertBulk(table: keyof ITableRecord, data: Partial<TRecord>[], options?: IModelMethodOptionsGeneral): Promise<TRecord[]> {
+    return (await this._insertBulk(table, data, options)) as Promise<TRecord[]>;
+  }
+
+  async update(table: keyof ITableRecord, data: Partial<TRecord>, options?: IModelUpdateOptionsGeneral<TRecord>): Promise<Partial<TRecord>> {
+    return await this._update(table, data, options);
+  }
+
+  async delete(table: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void> {
+    return await this._delete(table, where, options);
+  }
+}

package/src/bean/bean.model/bean.model_knex.ts

@@ -0,0 +1,60 @@
+import type { Knex } from 'knex';
+
+import type { IModelMethodOptionsGeneral, ITableRecord } from '../../types/index.ts';
+
+import { BeanModelUtils } from './bean.model_utils.ts';
+
+export class BeanModelKnex<TRecord extends {}> extends BeanModelUtils<TRecord> {
+  get schema(): Knex.SchemaBuilder {
+    return this.connection.schema;
+  }
+
+  builder<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(table?: Knex.TableDescriptor): Knex.QueryBuilder<TRecord2, TResult2[]> {
+    // table
+    table = table || this.getTable(undefined);
+    if (table) {
+      return this.connection(table);
+    }
+    return this.connection.queryBuilder<TRecord2, TResult2[]>();
+  }
+
+  builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(options?: IModelMethodOptionsGeneral): Knex.QueryBuilder<TRecord2, TResult2[]>;
+  builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(
+    table: keyof ITableRecord,
+    options?: IModelMethodOptionsGeneral,
+  ): Knex.QueryBuilder<TRecord2, TResult2[]>;
+  builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(table?, options?): Knex.QueryBuilder<TRecord2, TResult2[]> {
+    if (typeof table !== 'string') {
+      options = table;
+      table = undefined;
+    }
+    // table
+    table = table || this.getTable(undefined);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // builder
+    const builder = this.builder<TRecord2, TResult2>(table);
+    // where
+    this.prepareWhere(builder, table, {}, options);
+    // ready
+    return builder;
+  }
+
+  async query(value: Knex.Value): Promise<TRecord[]>;
+  async query(sql: string, binding: Knex.RawBinding): Promise<TRecord[]>;
+  async query(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Promise<TRecord[]>;
+  async query(sql, bindings?): Promise<TRecord[]> {
+    const raw = this.connection.raw(sql, bindings);
+    const result = await raw;
+    // dialect
+    return this.dialect.query(result) as unknown as TRecord[];
+  }
+
+  async queryOne(value: Knex.Value): Promise<TRecord | undefined>;
+  async queryOne(sql: string, binding: Knex.RawBinding): Promise<TRecord | undefined>;
+  async queryOne(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Promise<TRecord | undefined>;
+  async queryOne(sql, bindings?): Promise<TRecord | undefined> {
+    const res = await this.query(sql, bindings);
+    if (!res[0]) return undefined;
+    return res[0];
+  }
+}

package/src/bean/bean.model/bean.model_meta.ts

@@ -0,0 +1,204 @@
+import { isNil } from '@cabloy/utils';
+import { appResource, BeanBase, cast } from 'vona';
+import { $tableNameFromEntity } from 'vona-module-a-ormutils';
+
+import type { ServiceDb } from '../../service/db_.ts';
+import type {
+  IDatabaseClientRecord,
+  IDecoratorModelOptions,
+  IModelClassRecord,
+  IModelMethodOptionsGeneral,
+  IModelUpdateOptionsGeneral,
+  ITableRecord,
+  TypeEntityMeta,
+  TypeModelClassLike,
+  TypeModelOptionsTable,
+  TypeModelRelationOptionsMetaClient,
+} from '../../types/index.ts';
+import type { BeanModel } from '../bean.model.ts';
+
+import { getTableOrTableAlias, prepareClassModel } from '../../common/utils.ts';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from '../../types/index.ts';
+
+const SymbolModelDb = Symbol('SymbolModelDb');
+const SymbolModelTable = Symbol('SymbolModelTable');
+
+export class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
+  public [SymbolKeyEntity]: TRecord;
+  public [SymbolKeyEntityMeta]: TypeEntityMeta<TRecord>;
+  public [SymbolKeyModelOptions]: IDecoratorModelOptions;
+
+  private [SymbolModelDb]?: ServiceDb;
+  private [SymbolModelTable]?: TypeModelOptionsTable;
+
+  protected __init__(clientName?: keyof IDatabaseClientRecord | ServiceDb, table?: TypeModelOptionsTable) {
+    // clientName
+    if (!isNil(clientName)) {
+      if (typeof clientName === 'string') {
+        this[SymbolModelDb] = this.bean.database.getDb(clientName);
+      } else {
+        this[SymbolModelDb] = clientName;
+      }
+    }
+    // table
+    this[SymbolModelTable] = table;
+  }
+
+  protected get self() {
+    return cast<BeanModel>(this);
+  }
+
+  protected get connection() {
+    return this.db.connection;
+  }
+
+  protected get dialect() {
+    return this.db.dialect;
+  }
+
+  public get scopeOrm() {
+    return this.$scope.orm;
+  }
+
+  public get modelViewRecord() {
+    return this.$scope.version.model.viewRecord;
+  }
+
+  public get db() {
+    return this[SymbolModelDb] ?? this._getDb();
+  }
+
+  private _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(where: object | undefined): keyof ITableRecord {
+    return this._getTable(where);
+  }
+
+  private _getTable(where: object | undefined) {
+    const table = this[SymbolModelTable] ?? this.options.table;
+    if (table && typeof table === 'string') return table;
+    const defaultTable = this.options.entity && $tableNameFromEntity(this.options.entity);
+    if (table && typeof table === 'function') {
+      return table(this.ctx, where, defaultTable!, this) as any;
+    }
+    if (defaultTable) return defaultTable;
+    throw new Error(`not found table of ${this.$beanFullName}`);
+  }
+
+  get options(): IDecoratorModelOptions {
+    return (this.$beanOptions.options || {}) as IDecoratorModelOptions;
+  }
+
+  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;
+  }
+
+  protected _prepareDisableInstanceByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean) {
+    const columnNameInstance = useRaw ? 'iid' : `${getTableOrTableAlias(table)}.iid`;
+    if (this._checkDisableInstanceByOptions(options)) {
+      delete data.iid;
+      delete data[columnNameInstance];
+    } else {
+      delete data.iid;
+      if (!this.ctx.instance) {
+        throw new Error('ctx.instance not exists');
+      }
+      data[columnNameInstance] = this.ctx.instance.id;
+    }
+    return data;
+  }
+
+  protected _prepareDisableDeletedByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean) {
+    const columnNameDeleted = useRaw ? 'deleted' : `${getTableOrTableAlias(table)}.deleted`;
+    const deleted = this._prepareDisableDeletedByOptionsSimple(options);
+    if (!isNil(deleted)) {
+      delete data.deleted; // force
+      data[columnNameDeleted] = deleted;
+    }
+    return data;
+  }
+
+  protected _prepareDisableDeletedByOptionsSimple(options?: IModelMethodOptionsGeneral): boolean | undefined {
+    if (!isNil(options?.deleted)) {
+      if (!this.disableDeleted) {
+        return options?.deleted;
+      }
+    } else {
+      if (this._checkDisableDeletedByOptions(options)) {
+        // do nothing
+      } else {
+        return false;
+      }
+    }
+    return undefined;
+  }
+
+  protected _checkIfEntityValidByDeleted(entity: any, options?: IModelMethodOptionsGeneral) {
+    const deleted = this._prepareDisableDeletedByOptionsSimple(options);
+    return isNil(deleted) || Boolean(entity.deleted) === Boolean(deleted);
+  }
+
+  protected _checkDisableInstanceByOptions(_options?: IModelMethodOptionsGeneral) {
+    return this.disableInstance;
+  }
+
+  protected _checkDisableDeletedByOptions(options?: IModelMethodOptionsGeneral) {
+    if (this.disableDeleted) return true;
+    return options?.disableDeleted ?? this.disableDeleted;
+  }
+
+  protected _checkDisableCreateTimeByOptions(options?: IModelUpdateOptionsGeneral<TRecord>) {
+    return options?.disableCreateTime ?? this.disableCreateTime;
+  }
+
+  protected _checkDisableUpdateTimeByOptions(options?: IModelUpdateOptionsGeneral<TRecord>) {
+    return options?.disableUpdateTime ?? this.disableUpdateTime;
+  }
+
+  public newInstance(client?: keyof IDatabaseClientRecord | ServiceDb, table?: TypeModelOptionsTable): this {
+    return this.app.bean._newBean(this.$beanFullName as any, client ?? this.db, table);
+  }
+
+  public newInstanceTarget<MODEL extends BeanModelMeta | keyof IModelClassRecord>(
+    modelClassTarget: TypeModelClassLike<MODEL>,
+    client?: TypeModelRelationOptionsMetaClient,
+    table?: TypeModelOptionsTable,
+  ): BeanModelMeta {
+    const modelClass2 = prepareClassModel(modelClassTarget);
+    const beanOptions = appResource.getBean(modelClass2);
+    const beanFullName = beanOptions!.beanFullName;
+    const options = beanOptions?.options as IDecoratorModelOptions | undefined;
+    // client
+    if (isNil(client) || client === '_auto_') {
+      client = options?.client ? '_initial_' : '_inherit_';
+    }
+    if (client === '_initial_') {
+      return this.app.bean._newBean(beanFullName as any, undefined, table);
+    } else if (client === '_inherit_') {
+      client = this.db;
+    }
+    return this.app.bean._newBean(beanFullName as any, client ?? this.db, table);
+  }
+}