vona-module-a-orm 5.1.4 → 5.1.6

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);
   }
 

package/src/bean/bean.model/bean.model_utils.ts

@@ -25,7 +25,10 @@ import { BeanModelMeta } from './bean.model_meta.ts';
 
 export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
   async prepareData(item?: Partial<TRecord>): Promise<[TRecord, TRecord]>;
-  async prepareData(table: keyof ITableRecord, item?: Partial<TRecord>): Promise<[TRecord, TRecord]>;
+  async prepareData(
+    table: keyof ITableRecord,
+    item?: Partial<TRecord>,
+  ): Promise<[TRecord, TRecord]>;
   async prepareData(table?, item?): Promise<[TRecord, TRecord]> {
     if (typeof table !== 'string') {
       item = table;
@@ -73,8 +76,14 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
   }
 
   raw(value: Knex.Value): Knex.Raw<any>;
-  raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(sql: string, binding: Knex.RawBinding): Knex.Raw<TResult2>;
-  raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Knex.Raw<TResult2>;
+  raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(
+    sql: string,
+    binding: Knex.RawBinding,
+  ): Knex.Raw<TResult2>;
+  raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(
+    sql: string,
+    bindings: readonly Knex.RawBinding[] | Knex.ValueDict,
+  ): Knex.Raw<TResult2>;
   raw(sql, bindings?) {
     return this.connection.raw(sql, bindings);
   }
@@ -114,7 +123,10 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     }
   }
 
-  buildDistinct(builder: Knex.QueryBuilder, distinct?: boolean | keyof TRecord | (keyof TRecord)[]) {
+  buildDistinct(
+    builder: Knex.QueryBuilder,
+    distinct?: boolean | keyof TRecord | (keyof TRecord)[],
+  ) {
     if (distinct === undefined || distinct === false) return;
     if (distinct === true) {
       builder.distinct();
@@ -125,7 +137,11 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     }
   }
 
-  buildCount(builder: Knex.QueryBuilder, column?: TypeModelColumn<TRecord>, distinct?: boolean | keyof TRecord | (keyof TRecord)[]) {
+  buildCount(
+    builder: Knex.QueryBuilder,
+    column?: TypeModelColumn<TRecord>,
+    distinct?: boolean | keyof TRecord | (keyof TRecord)[],
+  ) {
     if (column !== undefined) {
       builder.count(column);
     } else if (distinct !== undefined && distinct !== false) {
@@ -158,7 +174,11 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     }
   }
 
-  buildColumns(builder: Knex.QueryBuilder, columns?: TypeModelColumns<TRecord>, groups?: (keyof TRecord)[] | undefined) {
+  buildColumns(
+    builder: Knex.QueryBuilder,
+    columns?: TypeModelColumns<TRecord>,
+    groups?: (keyof TRecord)[] | undefined,
+  ) {
     if (columns) {
       builder.select(columns as any);
     } else if (groups) {
@@ -191,16 +211,27 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     this.buildOffset(builder, page.index);
   }
 
-  prepareHaving(builder: Knex.QueryBuilder, having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>) {
+  prepareHaving(
+    builder: Knex.QueryBuilder,
+    having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>,
+  ) {
     if (!having) return;
     this.buildHaving(builder, having);
   }
 
-  buildHaving(builder: Knex.QueryBuilder, having: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>) {
+  buildHaving(
+    builder: Knex.QueryBuilder,
+    having: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>,
+  ) {
     return buildWhere(this.db, builder, having, true);
   }
 
-  prepareWhere(builder: Knex.QueryBuilder, table?: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral) {
+  prepareWhere(
+    builder: Knex.QueryBuilder,
+    table?: keyof ITableRecord,
+    where?: TypeModelWhere<TRecord>,
+    options?: IModelMethodOptionsGeneral,
+  ) {
     // table
     table = table || this.getTable(where);
     if (!table) throw new Error('should specify the table name');
@@ -225,7 +256,11 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     return String(value);
   }
 
-  extractFirstValue(result: Array<object> | object, defaultValue?: any, columnName?: string): any | undefined {
+  extractFirstValue(
+    result: Array<object> | object,
+    defaultValue?: any,
+    columnName?: string,
+  ): any | undefined {
     const value = this._extractFirstValue(result, columnName);
     if (value === undefined || value === null) return defaultValue;
     return value;
@@ -240,7 +275,11 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     return res[keys[0]];
   }
 
-  protected _prepareWhereByOptions(table: keyof ITableRecord, where, options?: IModelMethodOptionsGeneral) {
+  protected _prepareWhereByOptions(
+    table: keyof ITableRecord,
+    where,
+    options?: IModelMethodOptionsGeneral,
+  ) {
     // disableInstance: should not check if specified
     where = this._prepareDisableInstanceByOptions(table, where, options);
     // disableDeleted: should not check if specified
@@ -249,7 +288,11 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     return where;
   }
 
-  protected _prepareInsertDataByOptions(table: keyof ITableRecord, data, options?: IModelMethodOptionsGeneral) {
+  protected _prepareInsertDataByOptions(
+    table: keyof ITableRecord,
+    data,
+    options?: IModelMethodOptionsGeneral,
+  ) {
     let result = Object.assign({}, data);
     // disableInstance: should not check if specified
     result = this._prepareDisableInstanceByOptions(table, result, options, true);
@@ -272,4 +315,12 @@ export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
     }
     return result;
   }
+
+  protected _ellipsis‌Logger(str: string) {
+    const maxLength = this.scopeOrm.config.logger.maxLength;
+    if (str.length > maxLength) {
+      str = str.substring(0, maxLength) + ' ...';
+    }
+    return str;
+  }
 }

package/src/bean/bean.model/bean.model_view.ts

@@ -7,7 +7,10 @@ import { cast } from 'vona';
 import { BeanModelKnex } from './bean.model_knex.ts';
 
 export class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
-  async createView(viewName: string, callback?: (viewBuilder: Knex.ViewBuilder) => any): Promise<void> {
+  async createView(
+    viewName: string,
+    callback?: (viewBuilder: Knex.ViewBuilder) => any,
+  ): Promise<void> {
     if (callback) {
       // create view
       let _view: Knex.ViewBuilder | null = null;
@@ -42,7 +45,10 @@ export class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
     }
   }
 
-  async alterView(viewName: string, callback?: (viewBuilder: Knex.ViewBuilder) => any): Promise<void> {
+  async alterView(
+    viewName: string,
+    callback?: (viewBuilder: Knex.ViewBuilder) => any,
+  ): Promise<void> {
     await this._viewDependentsAll_handle(viewName, async () => {
       // drop view
       await this.dropView(viewName, true);
@@ -51,7 +57,10 @@ export class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
     });
   }
 
-  async createTable(tableName: string, callback: (tableBuilder: Knex.CreateTableBuilder) => any): Promise<void> {
+  async createTable(
+    tableName: string,
+    callback: (tableBuilder: Knex.CreateTableBuilder) => any,
+  ): Promise<void> {
     await this.schema.createTable(tableName, callback);
   }
 
@@ -59,7 +68,11 @@ export class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
     await this.schema.dropTable(tableName);
   }
 
-  async alterTable(tableName: string, callback: (tableBuilder: Knex.CreateTableBuilder) => any, alterViewAuto?: boolean): Promise<void> {
+  async alterTable(
+    tableName: string,
+    callback: (tableBuilder: Knex.CreateTableBuilder) => any,
+    alterViewAuto?: boolean,
+  ): Promise<void> {
     if (!alterViewAuto) {
       // alter table
       return await this.schema.alterTable(tableName, table => {
@@ -99,7 +112,9 @@ export class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
       // dependencies
       const view = views.find(view => view.name === dependent);
       if (view) {
-        const dep = cast(view.dependencies).find(dep => dep.toLowerCase() === viewName.toLowerCase());
+        const dep = cast(view.dependencies).find(
+          dep => dep.toLowerCase() === viewName.toLowerCase(),
+        );
         if (!dep) {
           cast(view.dependencies).push(viewName);
         }

package/src/bean/event.clientNameReal.ts

@@ -7,4 +7,7 @@ export type TypeEventClientNameRealData = keyof IDatabaseClientRecord;
 export type TypeEventClientNameRealResult = keyof IDatabaseClientRecord;
 
 @Event()
-export class EventClientNameReal extends BeanEventBase<TypeEventClientNameRealData, TypeEventClientNameRealResult> {}
+export class EventClientNameReal extends BeanEventBase<
+  TypeEventClientNameRealData,
+  TypeEventClientNameRealResult
+> {}

package/src/bean/event.columnsClear.ts

@@ -10,4 +10,7 @@ export interface TypeEventColumnsClearData {
 export type TypeEventColumnsClearResult = void;
 
 @Event()
-export class EventColumnsClear extends BeanEventBase<TypeEventColumnsClearData, TypeEventColumnsClearResult> {}
+export class EventColumnsClear extends BeanEventBase<
+  TypeEventColumnsClearData,
+  TypeEventColumnsClearResult
+> {}

package/src/bean/queue.doubleDelete.ts

@@ -22,8 +22,15 @@ export class QueueDoubleDelete
   extends BeanQueueBase<TypeQueueDoubleDeleteJobData, TypeQueueDoubleDeleteJobResult>
   implements IQueueExecute<TypeQueueDoubleDeleteJobData, TypeQueueDoubleDeleteJobResult>
 {
-  async execute(data: TypeQueueDoubleDeleteJobData, _options?: IQueuePushOptions): Promise<TypeQueueDoubleDeleteJobResult> {
-    const beanInstance = this.app.bean._newBean(data.beanFullName as any, data.clientName, data.table);
+  async execute(
+    data: TypeQueueDoubleDeleteJobData,
+    _options?: IQueuePushOptions,
+  ): Promise<TypeQueueDoubleDeleteJobResult> {
+    const beanInstance = this.app.bean._newBean(
+      data.beanFullName as any,
+      data.clientName,
+      data.table,
+    );
     await beanInstance[data.method](...data.args);
   }
 }

package/src/bean/schedule.softDeletionPrune.ts

@@ -13,7 +13,9 @@ export class ScheduleSoftDeletionPrune extends BeanBase implements IScheduleExec
     const onionSlices = this.bean.onion.model.getOnionsEnabledCached();
     for (const onionSlice of onionSlices) {
       if (onionSlice.beanOptions.options?.disableDeleted) continue;
-      let softDeletionPrune = onionSlice.beanOptions.options?.softDeletionPrune ?? this.scope.config.softDeletionPrune.enable;
+      let softDeletionPrune =
+        onionSlice.beanOptions.options?.softDeletionPrune ??
+        this.scope.config.softDeletionPrune.enable;
       if (!softDeletionPrune) continue;
       if (softDeletionPrune === true) softDeletionPrune = {};
       await this._modulePrune(onionSlice, softDeletionPrune);

package/src/common/buildWhere.ts

@@ -4,12 +4,23 @@ import { isNil } from '@cabloy/utils';
 import { cast } from 'vona';
 
 import type { ServiceDb } from '../service/db_.ts';
-import type { TypeModelColumnValue, TypeModelWhere, TypeModelWhereFieldAll, TypeOpsJoint, TypeOpsNormal } from '../types/modelWhere.ts';
+import type {
+  TypeModelColumnValue,
+  TypeModelWhere,
+  TypeModelWhereFieldAll,
+  TypeOpsJoint,
+  TypeOpsNormal,
+} from '../types/modelWhere.ts';
 
 import { Op, OpAggrs, OpJointValues, OpNormalValues } from '../types/modelWhere.ts';
 import { isRaw, isRef } from './utils.ts';
 
-export function buildWhere<TRecord>(db: ServiceDb, builder: Knex.QueryBuilder, wheres: TypeModelWhere<TRecord>, having: boolean = false) {
+export function buildWhere<TRecord>(
+  db: ServiceDb,
+  builder: Knex.QueryBuilder,
+  wheres: TypeModelWhere<TRecord>,
+  having: boolean = false,
+) {
   _buildWhereInner(having, db, builder, wheres);
 }
 
@@ -111,7 +122,9 @@ function _buildWhereColumn<TRecord>(
   db: ServiceDb,
   builder: Knex.QueryBuilder,
   column: keyof TRecord,
-  value: TypeModelColumnValue<TRecord, TRecord[keyof TRecord]> | TypeModelWhereFieldAll<TRecord, TRecord[keyof TRecord]>,
+  value:
+    | TypeModelColumnValue<TRecord, TRecord[keyof TRecord]>
+    | TypeModelWhereFieldAll<TRecord, TRecord[keyof TRecord]>,
   op?: TypeOpsNormal,
 ) {
   // skip
@@ -206,11 +219,23 @@ function _buildWhereColumnOpNormal<TRecord>(
 }
 
 function _getOpLikeReal(having: boolean, db: ServiceDb) {
-  return db.dialect.capabilities.like ? (having ? 'havingLike' : 'whereLike') : having ? 'havingILike' : 'whereILike';
+  return db.dialect.capabilities.like
+    ? having
+      ? 'havingLike'
+      : 'whereLike'
+    : having
+      ? 'havingILike'
+      : 'whereILike';
 }
 
 function _getOpILikeReal(having: boolean, db: ServiceDb) {
-  return db.dialect.capabilities.ilike ? (having ? 'havingILike' : 'whereILike') : having ? 'havingLike' : 'whereLike';
+  return db.dialect.capabilities.ilike
+    ? having
+      ? 'havingILike'
+      : 'whereILike'
+    : having
+      ? 'havingLike'
+      : 'whereLike';
 }
 
 function _checkHavingColumn<TRecord>(db: ServiceDb, column: keyof TRecord | string) {

package/src/common/utils.ts

@@ -26,7 +26,9 @@ export function getTargetColumnName(column: string) {
   return column;
 }
 
-export function prepareColumns<TRecord>(columns?: TypeModelColumns<TRecord>): Array<TypeModelColumn<TRecord>> | undefined {
+export function prepareColumns<TRecord>(
+  columns?: TypeModelColumns<TRecord>,
+): Array<TypeModelColumn<TRecord>> | undefined {
   if (!columns) return undefined;
   columns = Array.isArray(columns) ? columns : [columns];
   if (columns.includes('*')) return undefined;
@@ -34,7 +36,9 @@ export function prepareColumns<TRecord>(columns?: TypeModelColumns<TRecord>): Ar
 }
 
 export function prepareClassModel<ModelLike extends BeanModelMeta | keyof IModelClassRecord>(
-  classType: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  classType: ModelLike extends BeanModelMeta
+    ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
+    : ModelLike,
 ): Constructable<ModelLike> {
   if (typeof classType === 'string') {
     const beanOptions = appResource.getBean(beanFullNameFromOnionName(classType, 'model'));

package/src/config/config.ts

@@ -56,5 +56,8 @@ export function config(_app: VonaApplication) {
         client: 'model',
       },
     },
+    logger: {
+      maxLength: 256,
+    },
   };
 }

package/src/extend/schemaBuilder.ts

@@ -10,7 +10,8 @@ import type { IFetchDatabasesResultItem, IFetchIndexesResultItem } from '../type
 export function ExtendSchemaBuilder(app: VonaApplication) {
   ['fetchDatabases', 'createDatabase', 'dropDatabase', 'fetchIndexes'].forEach(method => {
     knex.SchemaBuilder.extend(method, async function (...args) {
-      const client = cast<Knex.Client>(cast(this).client).config.client as keyof IDatabaseClientDialectRecord;
+      const client = cast<Knex.Client>(cast(this).client).config
+        .client as keyof IDatabaseClientDialectRecord;
       const dialect = app.bean.database.getDialect(client);
       return await dialect[method](this, ...args);
     });

package/src/extend/tableBuilder.ts

@@ -14,7 +14,11 @@ export interface IBasicFieldsOptions {
 
 export function ExtendTableBuilder(app: VonaApplication) {
   const scope = app.scope(__ThisModule__);
-  function _basicFields(this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions, identityType?: TableIdentityType) {
+  function _basicFields(
+    this: knex.Knex.TableBuilder,
+    options?: IBasicFieldsOptions,
+    identityType?: TableIdentityType,
+  ) {
     options = options || ({} as IBasicFieldsOptions);
     if (options.id !== false) {
       const _identityType = identityType ?? scope.config.table.identityType;
@@ -32,24 +36,33 @@ export function ExtendTableBuilder(app: VonaApplication) {
     return this;
   }
 
-  knex.TableBuilder.extend('basicFields', function (this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions) {
-    _basicFields.call(this, options, undefined);
-    return this;
-  });
-  knex.TableBuilder.extend('basicFieldsSimple', function (this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions) {
-    _basicFields.call(this, options, 'number');
-    return this;
-  });
-  knex.TableBuilder.extend('tableIdentity', function (this: knex.Knex.TableBuilder, columnName: string) {
-    const _identityType = scope.config.table.identityType;
-    if (_identityType === 'bigint') {
-      return this.bigInteger(columnName); // default value is null
-    } else if (_identityType === 'number') {
-      return this.integer(columnName); // default value is null
-    } else {
-      throw new Error(`Should create column ${columnName} by yourself`);
-    }
-  });
+  knex.TableBuilder.extend(
+    'basicFields',
+    function (this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions) {
+      _basicFields.call(this, options, undefined);
+      return this;
+    },
+  );
+  knex.TableBuilder.extend(
+    'basicFieldsSimple',
+    function (this: knex.Knex.TableBuilder, options?: IBasicFieldsOptions) {
+      _basicFields.call(this, options, 'number');
+      return this;
+    },
+  );
+  knex.TableBuilder.extend(
+    'tableIdentity',
+    function (this: knex.Knex.TableBuilder, columnName: string) {
+      const _identityType = scope.config.table.identityType;
+      if (_identityType === 'bigint') {
+        return this.bigInteger(columnName); // default value is null
+      } else if (_identityType === 'number') {
+        return this.integer(columnName); // default value is null
+      } else {
+        throw new Error(`Should create column ${columnName} by yourself`);
+      }
+    },
+  );
   knex.TableBuilder.extend('userId', function (this: knex.Knex.TableBuilder, columnName?: string) {
     return this.tableIdentity(columnName ?? 'userId');
   });

package/src/lib/const.ts

@@ -25,7 +25,9 @@ export function getCacheModelCacheInstances(app: VonaApplication) {
   return app.meta[SymbolCacheModelCacheInstances];
 }
 
-export function getCacheModelsClear(app: VonaApplication): Record<keyof IModelRecord, TypeModelClassLikeGeneral[]> {
+export function getCacheModelsClear(
+  app: VonaApplication,
+): Record<keyof IModelRecord, TypeModelClassLikeGeneral[]> {
   if (!app.meta[SymbolCacheModelsClear]) {
     app.meta[SymbolCacheModelsClear] = _collectModelsClear(app);
   }

package/src/lib/databaseDialect.ts

@@ -2,6 +2,8 @@ import { createBeanDecorator } from 'vona';
 
 import type { IDecoratorDatabaseDialectOptions } from '../types/index.ts';
 
-export function DatabaseDialect<T extends IDecoratorDatabaseDialectOptions>(options?: T): ClassDecorator {
+export function DatabaseDialect<T extends IDecoratorDatabaseDialectOptions>(
+  options?: T,
+): ClassDecorator {
   return createBeanDecorator('databaseDialect', options);
 }

package/src/lib/dto/dtoAggregate.ts

@@ -11,20 +11,28 @@ import type { IModelClassRecord } from '../../types/onion/model.ts';
 import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
 
 export function DtoAggregate<
-  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<
+    TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]
+  >,
   ModelLike extends BeanModelMeta | keyof IModelClassRecord,
 >(
-  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  modelLike: ModelLike extends BeanModelMeta
+    ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
+    : ModelLike,
   aggrs: Aggrs,
 ): Constructable<TypeDtoAggrResult<Aggrs>> {
   return _DtoAggregate_raw(modelLike, aggrs);
 }
 
 function _DtoAggregate_raw<
-  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<
+    TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]
+  >,
   ModelLike extends BeanModelMeta | keyof IModelClassRecord,
 >(
-  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  modelLike: ModelLike extends BeanModelMeta
+    ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
+    : ModelLike,
   aggrs: Aggrs,
 ): Constructable<TypeDtoAggrResult<Aggrs>> {
   abstract class TargetClass {}
@@ -32,11 +40,15 @@ function _DtoAggregate_raw<
 }
 
 export function _DtoAggregate_inner<
-  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<
+    TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]
+  >,
   ModelLike extends BeanModelMeta | keyof IModelClassRecord,
 >(
   classTarget: Constructable,
-  _modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  _modelLike: ModelLike extends BeanModelMeta
+    ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
+    : ModelLike,
   aggrs: Aggrs,
 ): Constructable<TypeDtoAggrResult<Aggrs>> {
   for (const key in aggrs) {

package/src/lib/dto/dtoCreate.ts

@@ -6,9 +6,29 @@ import type { IModelClassRecord } from '../../types/onion/model.ts';
 
 import { _DtoMutate_raw } from './dtoMutate.ts';
 
-export function DtoCreate<ModelLike extends BeanModelMeta | keyof IModelClassRecord, T extends IDtoMutateParams<ModelLike> | undefined = undefined>(
-  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+export function DtoCreate<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  T extends IDtoMutateParams<ModelLike> | undefined = undefined,
+>(
+  modelLike: ModelLike extends BeanModelMeta
+    ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
+    : ModelLike,
   params?: T,
-): Constructable<TypeDtoMutateResult<ModelLike, T, 'create', 'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt', true>> {
-  return _DtoMutate_raw(modelLike, params, 'create', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] as any, true, undefined);
+): Constructable<
+  TypeDtoMutateResult<
+    ModelLike,
+    T,
+    'create',
+    'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt',
+    true
+  >
+> {
+  return _DtoMutate_raw(
+    modelLike,
+    params,
+    'create',
+    ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] as any,
+    true,
+    undefined,
+  );
 }