vona-module-a-orm 5.1.5 → 5.1.7

package/src/bean/bean.model/bean.model_cache.ts

@@ -45,7 +45,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
   public cacheEntity: ServiceCacheEntity;
   protected relations: ServiceRelations;
 
-  protected __init__(clientName?: keyof IDatabaseClientRecord | ServiceDb, table?: keyof ITableRecord) {
+  protected __init__(
+    clientName?: keyof IDatabaseClientRecord | ServiceDb,
+    table?: keyof ITableRecord,
+  ) {
     super.__init__(clientName, table);
     this.cacheQuery = this.bean._newBean(ServiceCacheQuery, this);
     this.cacheEntity = this.bean._newBean(ServiceCacheEntity, this);
@@ -57,18 +60,29 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     await disposeInstance(this.cacheEntity);
   }
 
-  async insert<T extends IModelInsertOptions<TRecord>>(data?: Partial<TRecord>, options?: T): Promise<TRecord> {
+  async insert<T extends IModelInsertOptions<TRecord>>(
+    data?: Partial<TRecord>,
+    options?: T,
+  ): Promise<TRecord> {
     if (!data) data = {};
     const items = await this.insertBulk([data], options);
     return items[0];
   }
 
-  async insertBulk<T extends IModelInsertOptions<TRecord>>(items: Partial<TRecord>[], options?: T): Promise<TRecord[]> {
+  async insertBulk<T extends IModelInsertOptions<TRecord>>(
+    items: Partial<TRecord>[],
+    options?: T,
+  ): Promise<TRecord[]> {
     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 as any, options as any, options);
+    return await this.relations.handleRelationsMutate(
+      itemsResult,
+      itemsNew as any,
+      options as any,
+      options,
+    );
   }
 
   async __insertBulk_raw(
@@ -88,13 +102,19 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return res;
   }
 
-  async mutate<T extends IModelMutateOptions<TRecord>>(data?: Partial<TRecord>, options?: T): Promise<Partial<TRecord>> {
+  async mutate<T extends IModelMutateOptions<TRecord>>(
+    data?: Partial<TRecord>,
+    options?: T,
+  ): Promise<Partial<TRecord>> {
     if (!data) data = {};
     const items = await this.mutateBulk([data], options);
     return items[0];
   }
 
-  async mutateBulk<T extends IModelMutateOptions<TRecord>>(items: Partial<TRecord>[], options?: T): Promise<Partial<TRecord>[]> {
+  async mutateBulk<T extends IModelMutateOptions<TRecord>>(
+    items: Partial<TRecord>[],
+    options?: T,
+  ): Promise<Partial<TRecord>[]> {
     return await this.__mutateBulk_raw(undefined, items, options);
   }
 
@@ -140,7 +160,12 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
       .concat(itemsUpdate as any);
     let itemsMutateResult = itemsInsertNew.concat(itemsUpdate as any);
     const indexesMutate = indexesInsert.concat(indexesUpdate);
-    itemsMutateResult = await this.relations.handleRelationsMutate(itemsMutateResult, itemsMutate as any, options as any, options);
+    itemsMutateResult = await this.relations.handleRelationsMutate(
+      itemsMutateResult,
+      itemsMutate as any,
+      options as any,
+      options,
+    );
     let result: TRecord[] = [];
     for (let index = 0; index < indexesMutate.length; index++) {
       result[indexesMutate[index]] = itemsMutateResult[index] as any;
@@ -153,7 +178,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return result;
   }
 
-  async mget<T extends IModelGetOptions<TRecord>>(ids: TableIdentity[], options?: T): Promise<Partial<TRecord>[]> {
+  async mget<T extends IModelGetOptions<TRecord>>(
+    ids: TableIdentity[],
+    options?: T,
+  ): Promise<Partial<TRecord>[]> {
     if (ids.length === 0) return [];
     const relations = this.relations.handleRelationsCollection(options as any);
     const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
@@ -170,7 +198,11 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return items;
   }
 
-  private async __mget_raw(table: keyof ITableRecord | undefined, ids: TableIdentity[], options?: IModelGetOptions<TRecord>): Promise<TRecord[]> {
+  private async __mget_raw(
+    table: keyof ITableRecord | undefined,
+    ids: TableIdentity[],
+    options?: IModelGetOptions<TRecord>,
+  ): Promise<TRecord[]> {
     // table
     table = table || this.getTable(undefined);
     if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
@@ -195,7 +227,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return this.__filterMGetColumns(items, options?.columns);
   }
 
-  async count<T extends IModelSelectCountParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
+  async count<
+    T extends IModelSelectCountParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(
     params?: T,
     options?: IModelMethodOptions,
     _modelJoins?: ModelJoins,
@@ -206,19 +241,17 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return this.extractFirstValue(item);
   }
 
-  async increment<T extends IModelIncrementParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
-    params: T,
-    options?: IModelMethodOptions,
-    _modelJoins?: ModelJoins,
-  ): Promise<number> {
+  async increment<
+    T extends IModelIncrementParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(params: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<number> {
     return await this.__increment_raw(undefined, params, options);
   }
 
-  async decrement<T extends IModelIncrementParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
-    params: T,
-    options?: IModelMethodOptions,
-    _modelJoins?: ModelJoins,
-  ): Promise<number> {
+  async decrement<
+    T extends IModelIncrementParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(params: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<number> {
     const columns = {} as TypeModelIncrementParamsColumns<TRecord>;
     for (const key in params.columns) {
       columns[key] = -params.columns[key]!;
@@ -259,7 +292,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return res;
   }
 
-  async aggregate<T extends IModelSelectAggrParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
+  async aggregate<
+    T extends IModelSelectAggrParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(
     params?: T,
     options?: IModelMethodOptions,
     _modelJoins?: ModelJoins,
@@ -280,7 +316,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return items;
   }
 
-  async group<T extends IModelSelectGroupParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
+  async group<
+    T extends IModelSelectGroupParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(
     params?: T,
     options?: IModelMethodOptions,
     _modelJoins?: ModelJoins,
@@ -300,16 +339,20 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return items;
   }
 
-  async selectAndCount<T extends IModelSelectParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
-    params?: T,
-    options?: IModelMethodOptions,
-    modelJoins?: ModelJoins,
-  ): Promise<any> {
+  async selectAndCount<
+    T extends IModelSelectParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<any> {
     // pageNo/pageSize
     const pageSize = params?.limit ?? this.scopeOrm.config.rest.query.pageSize.default;
     const pageNo = Math.floor((params?.offset ?? 0) / pageSize) + 1;
     // count
-    const paramsCount = Object.assign({}, params, { columns: undefined, orders: undefined, limit: undefined, offset: undefined });
+    const paramsCount = Object.assign({}, params, {
+      columns: undefined,
+      orders: undefined,
+      limit: undefined,
+      offset: undefined,
+    });
     let count = await this.count(paramsCount, options, modelJoins);
     if (!count) count = '0';
     // list
@@ -325,11 +368,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return { list, total: count, pageCount, pageSize, pageNo };
   }
 
-  async select<T extends IModelSelectParams<TRecord>, ModelJoins extends TypeModelsClassLikeGeneral | undefined>(
-    params?: T,
-    options?: IModelMethodOptions,
-    _modelJoins?: ModelJoins,
-  ): Promise<any[]> {
+  async select<
+    T extends IModelSelectParams<TRecord>,
+    ModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  >(params?: T, options?: IModelMethodOptions, _modelJoins?: ModelJoins): Promise<any[]> {
     const relations = this.relations.handleRelationsCollection(params as any);
     const [params2, refKeys] = this.relations.prepareColumnsByRelations(relations, params);
     let items = await this.__select_raw(undefined, params2, options);
@@ -375,11 +417,17 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     }
     // 2: mget
     const ids = items.map(item => cast(item).id);
-    const options3 = params?.columns ? Object.assign({}, options, { columns: params?.columns }) : options;
+    const options3 = params?.columns
+      ? Object.assign({}, options, { columns: params?.columns })
+      : options;
     return await this.__mget_raw(table, ids, options3);
   }
 
-  private async __select_cache(table: keyof ITableRecord, params?: IModelSelectParams<TRecord>, options?: IModelMethodOptions): Promise<TRecord[]> {
+  private async __select_cache(
+    table: keyof ITableRecord,
+    params?: IModelSelectParams<TRecord>,
+    options?: IModelMethodOptions,
+  ): Promise<TRecord[]> {
     // check if cache
     if (this._checkDisableCacheQueryByOptions(options)) {
       return await super._select(table, params, options);
@@ -400,7 +448,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return items;
   }
 
-  async get<T extends IModelGetOptions<TRecord>>(where: TypeModelWhere<TRecord>, options?: T): Promise<Partial<TRecord> | undefined> {
+  async get<T extends IModelGetOptions<TRecord>>(
+    where: TypeModelWhere<TRecord>,
+    options?: T,
+  ): Promise<Partial<TRecord> | undefined> {
     const relations = this.relations.handleRelationsCollection(options);
     const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
     let item: TRecord | undefined = await this.__get_raw(undefined, where, options2);
@@ -444,19 +495,33 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
       return items[0];
     }
     // key
-    return this.__filterGetColumns(await this.__get_key(id, table, where, options), options?.columns);
+    return this.__filterGetColumns(
+      await this.__get_key(id, table, where, options),
+      options?.columns,
+    );
   }
 
-  async update<T extends IModelUpdateOptions<TRecord>>(data: Partial<TRecord>, options?: T): Promise<Partial<TRecord>> {
+  async update<T extends IModelUpdateOptions<TRecord>>(
+    data: Partial<TRecord>,
+    options?: T,
+  ): Promise<Partial<TRecord>> {
     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 as any, options);
+    const items = await this.relations.handleRelationsMutate(
+      dataNew,
+      dataNew,
+      options as any,
+      options,
+    );
     return items[0];
   }
 
-  async updateBulk<T extends IModelUpdateOptions<TRecord>>(items: Partial<TRecord>[], options?: T): Promise<Partial<TRecord>[]> {
+  async updateBulk<T extends IModelUpdateOptions<TRecord>>(
+    items: Partial<TRecord>[],
+    options?: T,
+  ): Promise<Partial<TRecord>[]> {
     await this.__updateBulk_raw(undefined, items, options);
     return await this.relations.handleRelationsMutate(items, items, options as any, options);
   }
@@ -525,14 +590,20 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return Array.isArray(id) ? id : [id];
   }
 
-  async delete<T extends IModelDeleteOptions<TRecord>>(where?: TypeModelWhere<TRecord>, options?: T): Promise<void> {
+  async delete<T extends IModelDeleteOptions<TRecord>>(
+    where?: TypeModelWhere<TRecord>,
+    options?: T,
+  ): Promise<void> {
     const ids = await this.__delete_raw(undefined, where, options);
     if (!isNil(ids)) {
       await this.relations.handleRelationsDelete(ids as [], options as any, options);
     }
   }
 
-  async deleteBulk<T extends IModelDeleteOptions<TRecord>>(ids: TableIdentity[], options?: T): Promise<void> {
+  async deleteBulk<T extends IModelDeleteOptions<TRecord>>(
+    ids: TableIdentity[],
+    options?: T,
+  ): Promise<void> {
     return await this.__deleteBulk_raw_with_relations(undefined, ids, options);
   }
 
@@ -639,7 +710,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     });
   }
 
-  public async cacheEntityDelInner(id: TableIdentity | TableIdentity[], table?: keyof ITableRecord) {
+  public async cacheEntityDelInner(
+    id: TableIdentity | TableIdentity[],
+    table?: keyof ITableRecord,
+  ) {
     await this.cacheEntity.del(id, table);
     await this.cacheQueryClearInner(table);
   }
@@ -729,7 +803,11 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     return !(options?.cache?.enable ?? this.cacheEntity.enabled);
   }
 
-  private __checkIfOnlyKey(keys: (string | TypeModelColumn<TRecord>)[], table: keyof ITableRecord, noCheckLength?: boolean): string | false {
+  private __checkIfOnlyKey(
+    keys: (string | TypeModelColumn<TRecord>)[],
+    table: keyof ITableRecord,
+    noCheckLength?: boolean,
+  ): string | false {
     const columnId = `${table}.id`;
     if (!noCheckLength) {
       const keysAux = this.cacheEntity.keysAux;
@@ -748,11 +826,17 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     }
   }
 
-  private __checkCacheKeyValid(where: {} | undefined, table: keyof ITableRecord, noCheckLength?: boolean) {
+  private __checkCacheKeyValid(
+    where: {} | undefined,
+    table: keyof ITableRecord,
+    noCheckLength?: boolean,
+  ) {
     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;
+    return ['number', 'string', 'bigint', 'array'].includes(typeof where[columnId])
+      ? where[columnId]
+      : undefined;
   }
 
   protected __get__(prop: string) {

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

@@ -12,19 +12,31 @@ import type {
 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>[]> {
+  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>[]> {
+  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> {
+  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> {
+  async count(
+    params?: IModelCountParams<TRecord>,
+    options?: IModelMethodOptionsGeneral,
+  ): Promise<string | undefined> {
     return await this._count(undefined, params, options);
   }
 
@@ -32,15 +44,24 @@ export class BeanModelCrud<TRecord extends {} = {}> extends BeanModelCrudInner<T
     return (await this._insertBulk(undefined, data, options)) as Promise<TRecord>;
   }
 
-  async insertBulk(data: Partial<TRecord>[], options?: IModelMethodOptionsGeneral): 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>> {
+  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> {
+  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

@@ -19,7 +19,11 @@ import type {
 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[]> {
+  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));
   }
@@ -45,7 +49,9 @@ export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecor
       params.columns = options?.columns as any;
     }
     // select
-    const options2 = options?.columns ? Object.assign({}, options, { columns: undefined }) : options;
+    const options2 = options?.columns
+      ? Object.assign({}, options, { columns: undefined })
+      : options;
     const items = await this._select(table, params, options2);
     // sort
     const result: (TRecord | undefined)[] = [];
@@ -201,7 +207,10 @@ export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecor
       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')) {
+      if (
+        isNil(cast(dataNewOriginal).id) &&
+        Object.prototype.hasOwnProperty.call(dataNewOriginal, 'id')
+      ) {
         delete cast(dataNewOriginal).id;
       }
       datas.push(dataNew);
@@ -275,7 +284,11 @@ export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecor
     return data;
   }
 
-  protected async _delete(table?: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral): Promise<void> {
+  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();

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

@@ -37,23 +37,43 @@ export class BeanModelCrudTable<TRecord extends {}> extends BeanModelCrudInner<T
     return await this._get(table, where, options);
   }
 
-  async count(table: keyof ITableRecord, params?: IModelCountParams<TRecord>, options?: IModelMethodOptionsGeneral): Promise<string | undefined> {
+  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> {
+  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[]> {
+  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>> {
+  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> {
+  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

@@ -9,7 +9,9 @@ export class BeanModelKnex<TRecord extends {}> extends BeanModelUtils<TRecord> {
     return this.connection.schema;
   }
 
-  builder<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(table?: Knex.TableDescriptor): Knex.QueryBuilder<TRecord2, TResult2[]> {
+  builder<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(
+    table?: Knex.TableDescriptor,
+  ): Knex.QueryBuilder<TRecord2, TResult2[]> {
     // table
     table = table || this.getTable(undefined);
     if (table) {
@@ -18,12 +20,17 @@ export class BeanModelKnex<TRecord extends {}> extends BeanModelUtils<TRecord> {
     return this.connection.queryBuilder<TRecord2, TResult2[]>();
   }
 
-  builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(options?: IModelMethodOptionsGeneral): Knex.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[]> {
+  builderSelect<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(
+    table?,
+    options?,
+  ): Knex.QueryBuilder<TRecord2, TResult2[]> {
     if (typeof table !== 'string') {
       options = table;
       table = undefined;
@@ -41,7 +48,10 @@ export class BeanModelKnex<TRecord extends {}> extends BeanModelUtils<TRecord> {
 
   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: 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;
@@ -51,7 +61,10 @@ export class BeanModelKnex<TRecord extends {}> extends BeanModelUtils<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: 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;

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

@@ -31,7 +31,10 @@ export class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
   private [SymbolModelDb]?: ServiceDb;
   private [SymbolModelTable]?: TypeModelOptionsTable;
 
-  protected __init__(clientName?: keyof IDatabaseClientRecord | ServiceDb, table?: TypeModelOptionsTable) {
+  protected __init__(
+    clientName?: keyof IDatabaseClientRecord | ServiceDb,
+    table?: TypeModelOptionsTable,
+  ) {
     // clientName
     if (!isNil(clientName)) {
       if (typeof clientName === 'string') {
@@ -115,7 +118,12 @@ export class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
     return this.options.disableUpdateTime ?? this.scopeOrm.config.model.disableUpdateTime;
   }
 
-  protected _prepareDisableInstanceByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean) {
+  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;
@@ -130,7 +138,12 @@ export class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
     return data;
   }
 
-  protected _prepareDisableDeletedByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean) {
+  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)) {
@@ -140,7 +153,9 @@ export class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
     return data;
   }
 
-  protected _prepareDisableDeletedByOptionsSimple(options?: IModelMethodOptionsGeneral): boolean | undefined {
+  protected _prepareDisableDeletedByOptionsSimple(
+    options?: IModelMethodOptionsGeneral,
+  ): boolean | undefined {
     if (!isNil(options?.deleted)) {
       if (!this.disableDeleted) {
         return options?.deleted;
@@ -177,7 +192,10 @@ export class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
     return options?.disableUpdateTime ?? this.disableUpdateTime;
   }
 
-  public newInstance(client?: keyof IDatabaseClientRecord | ServiceDb, table?: TypeModelOptionsTable): this {
+  public newInstance(
+    client?: keyof IDatabaseClientRecord | ServiceDb,
+    table?: TypeModelOptionsTable,
+  ): this {
     return this.app.bean._newBean(this.$beanFullName as any, client ?? this.db, table);
   }