vona-module-a-orm 5.1.4 → 5.1.6

package/src/service/columnsCache_.ts

@@ -17,12 +17,14 @@ export class ServiceColumnsCache extends BeanBase {
   /** real client name */
   protected __init__(clientName: keyof IDatabaseClientRecord) {
     this.clientName = clientName;
-    this._onColumnsClearCancel = this.scope.event.columnsClear.on(({ clientName, tableName }, next) => {
-      if (clientName === this.clientName) {
-        this.columnsClear(tableName);
-      }
-      next();
-    });
+    this._onColumnsClearCancel = this.scope.event.columnsClear.on(
+      ({ clientName, tableName }, next) => {
+        if (clientName === this.clientName) {
+          this.columnsClear(tableName);
+        }
+        next();
+      },
+    );
   }
 
   protected async __dispose__() {

package/src/service/database.ts

@@ -4,7 +4,11 @@ import { Service } from 'vona-module-a-bean';
 
 import type { BeanDatabaseDialectBase } from '../bean/bean.databaseDialectBase.ts';
 import type { ConfigDatabaseClient } from '../types/config.ts';
-import type { IDatabaseClientDialectRecord, IDatabaseClientRecord, IDbInfo } from '../types/database.ts';
+import type {
+  IDatabaseClientDialectRecord,
+  IDatabaseClientRecord,
+  IDbInfo,
+} from '../types/database.ts';
 
 import { ServiceDatabaseClient } from './databaseClient_.ts';
 
@@ -14,7 +18,11 @@ export class ServiceDatabase extends BeanBase {
     return this.app.config.database;
   }
 
-  getClientConfig(clientName: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient, original?: boolean): ConfigDatabaseClient {
+  getClientConfig(
+    clientName: keyof IDatabaseClientRecord,
+    clientConfig?: ConfigDatabaseClient,
+    original?: boolean,
+  ): ConfigDatabaseClient {
     // clientConfig
     if (!clientConfig) {
       clientConfig = this.configDatabase.clients[clientName];
@@ -51,7 +59,10 @@ export class ServiceDatabase extends BeanBase {
     return { level, clientName };
   }
 
-  prepareClientNameSelector(dbInfo: IDbInfo, dialect: BeanDatabaseDialectBase | keyof IDatabaseClientDialectRecord) {
+  prepareClientNameSelector(
+    dbInfo: IDbInfo,
+    dialect: BeanDatabaseDialectBase | keyof IDatabaseClientDialectRecord,
+  ) {
     const dialect2 = typeof dialect === 'string' ? this.bean.database.getDialect(dialect) : dialect;
     if (!dialect2.capabilities.level) return dbInfo.clientName;
     // combine
@@ -80,7 +91,8 @@ export class ServiceDatabase extends BeanBase {
     // check instance
     const instanceName = this.ctx.instanceName;
     if (!isNil(instanceName)) {
-      const configInstanceBase = this.$scope.instance.service.instance.getConfigInstanceBase(instanceName);
+      const configInstanceBase =
+        this.$scope.instance.service.instance.getConfigInstanceBase(instanceName);
       if (configInstanceBase?.isolate) {
         return configInstanceBase.isolateClient!;
       }
@@ -89,9 +101,12 @@ export class ServiceDatabase extends BeanBase {
   }
 
   prepareClientNameReal(clientName?: keyof IDatabaseClientRecord): keyof IDatabaseClientRecord {
-    return this.scope.event.clientNameReal.emitSync(this.prepareClientName(clientName), clientName => {
-      return clientName;
-    });
+    return this.scope.event.clientNameReal.emitSync(
+      this.prepareClientName(clientName),
+      clientName => {
+        return clientName;
+      },
+    );
   }
 
   columnsClear(clientName?: keyof IDatabaseClientRecord, tableName?: string) {
@@ -100,16 +115,25 @@ export class ServiceDatabase extends BeanBase {
   }
 
   private columnsClearWorker(clientName?: keyof IDatabaseClientRecord, tableName?: string) {
-    this.scope.event.columnsClear.emitSync({ clientName: this.prepareClientNameReal(clientName), tableName });
+    this.scope.event.columnsClear.emitSync({
+      clientName: this.prepareClientNameReal(clientName),
+      tableName,
+    });
   }
 
-  async reloadClients(clientName?: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient) {
+  async reloadClients(
+    clientName?: keyof IDatabaseClientRecord,
+    clientConfig?: ConfigDatabaseClient,
+  ) {
     clientName = this.prepareClientName(clientName);
     await this.bean.mutate.reloadInstances(ServiceDatabaseClient, { clientName, clientConfig });
     this.columnsClear(clientName);
   }
 
-  async reloadClientsWorker(clientName?: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient) {
+  async reloadClientsWorker(
+    clientName?: keyof IDatabaseClientRecord,
+    clientConfig?: ConfigDatabaseClient,
+  ) {
     clientName = this.prepareClientName(clientName);
     await this.bean.mutate.reloadInstancesWorker({
       beanFullName: appResource.getBeanFullName(ServiceDatabaseClient) as any,

package/src/service/databaseClient_.ts

@@ -85,7 +85,10 @@ export class ServiceDatabaseClient extends BeanMutateBase {
   }
 
   async reload(clientConfig?: ConfigDatabaseClient) {
-    const clientConfigReal = this.scope.service.database.getClientConfig(this.clientName, clientConfig);
+    const clientConfigReal = this.scope.service.database.getClientConfig(
+      this.clientName,
+      clientConfig,
+    );
     this.$mutate([this.clientNameSelector, clientConfigReal]);
     await this.__close();
     this.__load(this.clientNameSelector, clientConfigReal);

package/src/service/relations_.ts

@@ -69,12 +69,21 @@ export class ServiceRelations extends BeanBase {
     const relations = this.handleRelationsCollection(includeWrapper);
     if (!relations) return entitiesResult;
     for (const relation of relations) {
-      entitiesResult = await this.__handleRelationMutate(entitiesResult, entities, relation, methodOptions);
+      entitiesResult = await this.__handleRelationMutate(
+        entitiesResult,
+        entities,
+        relation,
+        methodOptions,
+      );
     }
     return entitiesResult;
   }
 
-  public async handleRelationsDelete(ids: TableIdentity[], includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions) {
+  public async handleRelationsDelete(
+    ids: TableIdentity[],
+    includeWrapper?: IModelRelationIncludeWrapper,
+    methodOptions?: IModelMethodOptions,
+  ) {
     if (ids.length === 0) return;
     // relations
     const relations = this.handleRelationsCollection(includeWrapper);
@@ -84,7 +93,11 @@ export class ServiceRelations extends BeanBase {
     }
   }
 
-  private async __handleRelationOne<TRecord extends {}>(entity: TRecord, relation: IRelationItem, methodOptions?: IModelMethodOptions) {
+  private async __handleRelationOne<TRecord extends {}>(
+    entity: TRecord,
+    relation: IRelationItem,
+    methodOptions?: IModelMethodOptions,
+  ) {
     const [relationName, relationReal, includeReal, withReal] = relation;
     const { type, modelMiddle, model, keyFrom, keyTo, key, options } = relationReal;
     const modelTarget = this.__getModelTarget(model, options?.meta) as BeanModelCache;
@@ -125,12 +138,18 @@ export class ServiceRelations extends BeanBase {
         }
       }
     } else if (type === 'belongsToMany') {
-      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle) as BeanModelCrud;
+      const modelTargetMiddle = this.__getModelTarget(
+        modelMiddle,
+        options?.meta?.middle,
+      ) as BeanModelCrud;
       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 itemsMiddle = await modelTargetMiddle.select(
+          { where: { [keyFrom]: idFrom } },
+          methodOptionsReal,
+        );
         const idsTo = itemsMiddle.map(item => item[keyTo]);
         if (optionsReal.groups) {
           const options2 = deepExtend({}, optionsReal, { where: { id: idsTo } });
@@ -146,7 +165,11 @@ export class ServiceRelations extends BeanBase {
     }
   }
 
-  private async __handleRelationMany<TRecord extends {}>(entities: TRecord[], relation: IRelationItem, methodOptions?: IModelMethodOptions) {
+  private async __handleRelationMany<TRecord extends {}>(
+    entities: TRecord[],
+    relation: IRelationItem,
+    methodOptions?: IModelMethodOptions,
+  ) {
     const [relationName, relationReal, includeReal, withReal] = relation;
     const { type, modelMiddle, model, keyFrom, keyTo, key, options } = relationReal;
     const modelTarget = this.__getModelTarget(model, options?.meta) as BeanModelCache;
@@ -218,23 +241,36 @@ export class ServiceRelations extends BeanBase {
         }
       }
     } else if (type === 'belongsToMany') {
-      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle) as BeanModelCrud;
+      const modelTargetMiddle = this.__getModelTarget(
+        modelMiddle,
+        options?.meta?.middle,
+      ) as BeanModelCrud;
       const idsFrom = entities.map(item => cast(item).id).filter(id => !isNil(id));
       let itemsMiddle;
       if (idsFrom.length === 0) {
         itemsMiddle = [];
       } else {
-        itemsMiddle = await modelTargetMiddle.select({ where: { [keyFrom]: idsFrom } }, methodOptionsReal);
+        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: { id: idsTo } });
+          const idsTo = itemsMiddle
+            .filter(item => item[keyFrom] === cast(entity).id)
+            .map(item => item[keyTo]);
+          const options2 = deepExtend({}, optionsReal, {
+            groups: optionsReal.groups,
+            where: { 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 idsTo = itemsMiddle
+            .filter(item => item[keyFrom] === cast(entity).id)
+            .map(item => item[keyTo]);
           const options2 = deepExtend({}, optionsReal, { where: { id: idsTo } });
           entity[relationName] = await modelTarget.aggregate(options2, methodOptionsReal);
         }
@@ -246,7 +282,9 @@ export class ServiceRelations extends BeanBase {
           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]));
+              entity[relationName].push(
+                items.find(item => cast(item).id === cast(itemMiddle)[keyTo]),
+              );
             }
           }
         }
@@ -263,7 +301,10 @@ export class ServiceRelations extends BeanBase {
     const [relationName, relationReal, includeReal, withReal] = relation;
     const { type, modelMiddle, model, keyFrom, keyTo, key, options } = relationReal;
     const modelTarget = this.__getModelTarget(model, options?.meta) as BeanModelCache;
-    const methodOptionsReal = Object.assign({}, methodOptions, { include: includeReal, with: withReal });
+    const methodOptionsReal = Object.assign({}, methodOptions, {
+      include: includeReal,
+      with: withReal,
+    });
     if (type === 'hasOne') {
       let children: any[] = [];
       for (let index = 0; index < entities.length; index++) {
@@ -271,7 +312,11 @@ export class ServiceRelations extends BeanBase {
         if (entity[relationName]) {
           // donot check if has id of entity[relationName], for safety
           const item: any = await modelTarget.get({ [key]: cast(entity).id });
-          if (!isNil(item?.id) && !isNil(entity[relationName].id) && String(item?.id) !== String(entity[relationName].id)) {
+          if (
+            !isNil(item?.id) &&
+            !isNil(entity[relationName].id) &&
+            String(item?.id) !== String(entity[relationName].id)
+          ) {
             throw new Error(`invalid id: ${entity[relationName].id}`);
           }
           const dataNew: any = { [key]: cast(entity).id };
@@ -287,7 +332,9 @@ export class ServiceRelations extends BeanBase {
         const entityResult = result[index];
         const entity = entities[index];
         if (entity[relationName]) {
-          entityResult[relationName] = children.find(item => String(item[key]) === String(cast(entity).id));
+          entityResult[relationName] = children.find(
+            item => String(item[key]) === String(cast(entity).id),
+          );
         }
       }
       return result;
@@ -305,7 +352,11 @@ export class ServiceRelations extends BeanBase {
           if (idsTo.length === 0) {
             idsTarget = [];
           } else {
-            const itemsTarget = await cast(modelTarget).__select_raw(undefined, { where: { [key]: entityId, id: idsTo } }, methodOptionsReal);
+            const itemsTarget = await cast(modelTarget).__select_raw(
+              undefined,
+              { where: { [key]: entityId, id: idsTo } },
+              methodOptionsReal,
+            );
             idsTarget = itemsTarget.map(item => item.id);
           }
           for (const child of entity[relationName]) {
@@ -332,7 +383,10 @@ export class ServiceRelations extends BeanBase {
       }
       return result;
     } else if (type === 'belongsToMany') {
-      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle) as BeanModelCache;
+      const modelTargetMiddle = this.__getModelTarget(
+        modelMiddle,
+        options?.meta?.middle,
+      ) as BeanModelCache;
       let children: any[] = [];
       for (let index = 0; index < entities.length; index++) {
         const entity = entities[index];
@@ -384,20 +438,38 @@ export class ServiceRelations extends BeanBase {
     return entitiesResult;
   }
 
-  private async __handleRelationDelete(ids: TableIdentity[], relation: IRelationItem, methodOptions?: IModelMethodOptions) {
+  private async __handleRelationDelete(
+    ids: TableIdentity[],
+    relation: IRelationItem,
+    methodOptions?: IModelMethodOptions,
+  ) {
     const [_relationName, relationReal, includeReal, withReal] = relation;
     const { type, modelMiddle, model, keyFrom, key, options } = relationReal;
     const modelTarget = this.__getModelTarget(model, options?.meta) as BeanModelCache;
-    const methodOptionsReal = Object.assign({}, methodOptions, { include: includeReal, with: withReal });
+    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 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') {
       // do nothing
     } else if (type === 'belongsToMany') {
-      const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle) as BeanModelCache;
-      const itemsMiddle = await cast(modelTargetMiddle).__select_raw(undefined, { columns: 'id', where: { [keyFrom]: ids } }, methodOptionsReal);
+      const modelTargetMiddle = this.__getModelTarget(
+        modelMiddle,
+        options?.meta?.middle,
+      ) as BeanModelCache;
+      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);
     }
@@ -411,7 +483,10 @@ export class ServiceRelations extends BeanBase {
     return [columns, false];
   }
 
-  public prepareColumnsByRelations<T extends { columns?: any }>(relations: IRelationItem[], options?: T): [T | undefined, string[] | undefined] {
+  public prepareColumnsByRelations<T extends { columns?: any }>(
+    relations: IRelationItem[],
+    options?: T,
+  ): [T | undefined, string[] | undefined] {
     if (!options || !options.columns) return [options, undefined];
     const columns = Array.isArray(options.columns) ? options.columns : [options.columns];
     if (columns.includes('*')) return [options, undefined];

package/src/service/transaction_.ts

@@ -5,7 +5,10 @@ import type { FunctionAny, FunctionAsync } from 'vona';
 import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
 
-import type { ITransactionConsistencyCommitOptions, ITransactionOptions } from '../types/transaction.ts';
+import type {
+  ITransactionConsistencyCommitOptions,
+  ITransactionOptions,
+} from '../types/transaction.ts';
 import type { ServiceDb } from './db_.ts';
 import type { ServiceTransactionFiber } from './transactionFiber_.ts';
 
@@ -103,13 +106,18 @@ export class ServiceTransaction extends BeanBase {
     throw new Error('transaction error: unknown propagation');
   }
 
-  private async _isolationLevelRequired<RESULT>(fn: FunctionAsync<RESULT>, options?: ITransactionOptions): Promise<RESULT> {
+  private async _isolationLevelRequired<RESULT>(
+    fn: FunctionAsync<RESULT>,
+    options?: ITransactionOptions,
+  ): Promise<RESULT> {
     let res: RESULT;
     // begin
     let fiber: ServiceTransactionFiber | undefined;
     if (!this.inTransaction) {
       const connection = this._db.client.connection;
-      const transactionConnection = await connection.transaction(_translateTransactionOptions(options));
+      const transactionConnection = await connection.transaction(
+        _translateTransactionOptions(options),
+      );
       fiber = this.transactionState.add(this._db, transactionConnection);
     }
     // fn
@@ -138,7 +146,9 @@ export class ServiceTransaction extends BeanBase {
   }
 }
 
-function _translateTransactionOptions(options?: ITransactionOptions): Knex.TransactionConfig | undefined {
+function _translateTransactionOptions(
+  options?: ITransactionOptions,
+): Knex.TransactionConfig | undefined {
   if (!options) return undefined;
   return {
     isolationLevel: TransactionIsolationLevelsMap[options.isolationLevel ?? 'DEFAULT'] as any,

package/src/types/dto/dtoGet.ts

@@ -2,12 +2,17 @@ import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
 import type { IModelRelationIncludeWrapper } from '../model.ts';
 import type { TypeModelColumns } from '../modelWhere.ts';
 import type { IModelClassRecord } from '../onion/model.ts';
-import type { TypeModelOfModelLike, TypeModelRelationResult, TypeSymbolKeyEntity } from '../relations.ts';
+import type {
+  TypeModelOfModelLike,
+  TypeModelRelationResult,
+  TypeSymbolKeyEntity,
+} from '../relations.ts';
 
-export type IDtoGetParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> = IBuildDtoGetParams<
-  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
-  TypeModelOfModelLike<ModelLike>
->;
+export type IDtoGetParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> =
+  IBuildDtoGetParams<
+    TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
+    TypeModelOfModelLike<ModelLike>
+  >;
 
 export interface IBuildDtoGetParams<TRecord, Model extends BeanModelMeta>
   extends IModelRelationIncludeWrapper<Model>, IBuildDtoGetParamsBasic<TRecord> {}
@@ -16,7 +21,10 @@ export interface IBuildDtoGetParamsBasic<TRecord> {
   columns?: TypeModelColumns<TRecord>;
 }
 
-export type TypeDtoGetResult<ModelLike extends BeanModelMeta | keyof IModelClassRecord, TOptionsRelation> = TypeModelRelationResult<
+export type TypeDtoGetResult<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  TOptionsRelation,
+> = TypeModelRelationResult<
   TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
   TypeModelOfModelLike<ModelLike>,
   TOptionsRelation

package/src/types/dto/dtoGroup.ts

@@ -1,3 +1,4 @@
 import type { TypeModelGroupRelationResultGroups } from '../relationsGroup.ts';
 
-export type TypeDtoGroupResult<TRecord, Aggrs, Groups, Columns> = TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, Columns>;
+export type TypeDtoGroupResult<TRecord, Aggrs, Groups, Columns> =
+  TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, Columns>;

package/src/types/dto/dtoMutate.ts

@@ -27,10 +27,11 @@ import type {
 
 export type TypeDtoMutateType = 'create' | 'update' | 'mutate';
 
-export type IDtoMutateParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> = IBuildDtoMutateParams<
-  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
-  TypeModelOfModelLike<ModelLike>
->;
+export type IDtoMutateParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> =
+  IBuildDtoMutateParams<
+    TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
+    TypeModelOfModelLike<ModelLike>
+  >;
 
 export interface IBuildDtoMutateParams<TRecord, Model extends BeanModelMeta>
   extends IModelRelationIncludeWrapper<Model>, IBuildDtoMutateParamsBasic<TRecord> {}
@@ -73,9 +74,18 @@ export type TypeDtoMutateRelationResult<
 > &
   (TModel extends BeanModelMeta
     ? OmitNever<
-        TypeDtoMutateRelationResultMergeInclude<TMutateTypeTopLevel, TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>>
+        TypeDtoMutateRelationResultMergeInclude<
+          TMutateTypeTopLevel,
+          TypeUtilGetModelOptions<TModel>,
+          TypeUtilGetParamsInlcude<TOptionsRelation>
+        >
       > &
-        OmitNever<TypeDtoMutateModelRelationResultMergeWith<TMutateTypeTopLevel, TypeUtilGetParamsWith<TOptionsRelation>>>
+        OmitNever<
+          TypeDtoMutateModelRelationResultMergeWith<
+            TMutateTypeTopLevel,
+            TypeUtilGetParamsWith<TOptionsRelation>
+          >
+        >
     : {});
 
 type TypeDtoMutateRelationResultMergeInclude<
@@ -85,15 +95,32 @@ type TypeDtoMutateRelationResultMergeInclude<
 > = {
   [RelationName in keyof TModelOptions['relations']]: TInclude extends {}
     ? TInclude[RelationName] extends {} | boolean
-      ? TypeDtoMutateRelationResultMergeIncludeWrapper<TMutateTypeTopLevel, TModelOptions['relations'][RelationName], TInclude[RelationName]>
-      : TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel, TModelOptions['relations'][RelationName]>
-    : TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel, TModelOptions['relations'][RelationName]>;
+      ? TypeDtoMutateRelationResultMergeIncludeWrapper<
+          TMutateTypeTopLevel,
+          TModelOptions['relations'][RelationName],
+          TInclude[RelationName]
+        >
+      : TypeDtoMutateRelationResultMergeAutoload<
+          TMutateTypeTopLevel,
+          TModelOptions['relations'][RelationName]
+        >
+    : TypeDtoMutateRelationResultMergeAutoload<
+        TMutateTypeTopLevel,
+        TModelOptions['relations'][RelationName]
+      >;
 };
 
 type TypeDtoMutateModelRelationResultMergeWith<
   TMutateTypeTopLevel extends TypeDtoMutateType,
   TWith extends {} | undefined | unknown,
-> = TWith extends {} ? { [RelationName in keyof TWith]: TypeDtoMutateRelationResultMergeWithRelation<TMutateTypeTopLevel, TWith[RelationName]> } : {};
+> = TWith extends {}
+  ? {
+      [RelationName in keyof TWith]: TypeDtoMutateRelationResultMergeWithRelation<
+        TMutateTypeTopLevel,
+        TWith[RelationName]
+      >;
+    }
+  : {};
 
 type TypeDtoMutateRelationResultMergeIncludeWrapper<
   TMutateTypeTopLevel extends TypeDtoMutateType,
@@ -107,17 +134,27 @@ type TypeDtoMutateRelationResultMergeIncludeWrapper<
       ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, IncludeWrapper>
       : never;
 
-type TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel extends TypeDtoMutateType, Relation> =
+type TypeDtoMutateRelationResultMergeAutoload<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  Relation,
+> =
   TypeUtilGetRelationOptionsAutoload<Relation> extends true
     ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined>
     : never;
 
-type TypeDtoMutateRelationResultMergeWithRelation<TMutateTypeTopLevel extends TypeDtoMutateType, WithRelation> = WithRelation extends false
+type TypeDtoMutateRelationResultMergeWithRelation<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  WithRelation,
+> = WithRelation extends false
   ? never
   : WithRelation extends true
     ? never
     : WithRelation extends {}
-      ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, WithRelation, TypeUtilGetRelationOptions<WithRelation>>
+      ? TypeUtilGetDtoMutateRelationEntityByType<
+          TMutateTypeTopLevel,
+          WithRelation,
+          TypeUtilGetRelationOptions<WithRelation>
+        >
       : never;
 
 type TypeUtilGetDtoMutateRelationEntityByType<
@@ -146,8 +183,32 @@ type TypeUtilGetDtoMutateEntityByType<
   : TYPE extends 'belongsToMany'
     ? Array<{ id: TableIdentity; deleted?: boolean }> | undefined
     : TYPE extends 'hasMany'
-      ? Array<TypeDtoMutateRelationResult<TRecord, TModel, IncludeWrapper, TMutateTypeTopLevel, undefined, false, Columns, REFKEY>> | undefined
-      : TypeDtoMutateRelationResult<TRecord, TModel, IncludeWrapper, TMutateTypeTopLevel, undefined, false, Columns, REFKEY> | undefined;
+      ?
+          | Array<
+              TypeDtoMutateRelationResult<
+                TRecord,
+                TModel,
+                IncludeWrapper,
+                TMutateTypeTopLevel,
+                undefined,
+                false,
+                Columns,
+                REFKEY
+              >
+            >
+          | undefined
+      :
+          | TypeDtoMutateRelationResult<
+              TRecord,
+              TModel,
+              IncludeWrapper,
+              TMutateTypeTopLevel,
+              undefined,
+              false,
+              Columns,
+              REFKEY
+            >
+          | undefined;
 
 type TypeDtoMutateRelationResultEntity<
   TRecord,
@@ -157,7 +218,13 @@ type TypeDtoMutateRelationResultEntity<
   TTopLevel extends boolean | undefined = undefined,
   REFKEY = undefined,
 > = TypeDtoMutateRelationResultPatch<
-  TypeDtoMutateRelationResultEntityInner<TRecord, Columns, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel>,
+  TypeDtoMutateRelationResultEntityInner<
+    TRecord,
+    Columns,
+    TMutateTypeTopLevel,
+    TColumnsOmitDefault,
+    TTopLevel
+  >,
   TMutateTypeTopLevel,
   TTopLevel,
   REFKEY
@@ -169,7 +236,10 @@ type TypeDtoMutateRelationResultPatch<
   TTopLevel extends boolean | undefined = undefined,
   REFKEY = undefined,
 > = TTopLevel extends false
-  ? TypeUtilEntityOmit<TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>, REFKEY>
+  ? TypeUtilEntityOmit<
+      TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>,
+      REFKEY
+    >
   : TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>;
 
 type TypeDtoMutateRelationResultPatch2<
@@ -190,7 +260,11 @@ type TypeDtoMutateRelationResultEntityInner<
   TTopLevel extends boolean | undefined = undefined,
 > = [Columns] extends [string | string[]]
   ? TypeDtoMutateRelationResultEntityFromColumns<TRecord, Columns, TMutateTypeTopLevel, TTopLevel>
-  : TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<TRecord, TMutateTypeTopLevel, TColumnsOmitDefault>;
+  : TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<
+      TRecord,
+      TMutateTypeTopLevel,
+      TColumnsOmitDefault
+    >;
 
 type TypeDtoMutateRelationResultEntityFromColumns<
   TRecord,
@@ -199,7 +273,13 @@ type TypeDtoMutateRelationResultEntityFromColumns<
   TTopLevel extends boolean | undefined = undefined,
 > = TypeUtilEntitySelector<
   TRecord,
-  TypeUtilPrepareColumns<TypeDtoMutateRelationResultPrepareColumns<TypeUtilPrepareColumns<Columns>, TMutateTypeTopLevel, TTopLevel>>
+  TypeUtilPrepareColumns<
+    TypeDtoMutateRelationResultPrepareColumns<
+      TypeUtilPrepareColumns<Columns>,
+      TMutateTypeTopLevel,
+      TTopLevel
+    >
+  >
 >;
 
 type TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<
@@ -208,7 +288,9 @@ type TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<
   TColumnsOmitDefault extends string | string[] | undefined = undefined,
 > = TypeUtilEntityOmit<
   TRecord,
-  TypeUtilPrepareColumns<TypeDtoMutateRelationResultPrepareColumnsOmitDefault<TMutateTypeTopLevel, TColumnsOmitDefault>>
+  TypeUtilPrepareColumns<
+    TypeDtoMutateRelationResultPrepareColumnsOmitDefault<TMutateTypeTopLevel, TColumnsOmitDefault>
+  >
 >;
 
 type TypeDtoMutateRelationResultPrepareColumns<

package/src/types/dto/dtoQueryBase.ts

@@ -13,6 +13,10 @@ export class DtoQueryBase {
   @Api.field(v.optional(), z.looseObject({}))
   where?: object;
 
-  @Api.field(v.default(ordersDefault), v.optional(), z.union([z.string(), z.array(z.array(z.string()))]))
+  @Api.field(
+    v.default(ordersDefault),
+    v.optional(),
+    z.union([z.string(), z.array(z.array(z.string()))]),
+  )
   orders?: string | string[][];
 }