vona-module-a-orm 5.0.53 → 5.0.55

package/cli/model/metadata/generate.ts

@@ -113,10 +113,12 @@ function __parseRelation(nodeRelation: t.ObjectProperty) {
 function __parseRelationHasOne(args: t.Node[]) {
   // classModel
   const classModel = __parseRelation_classModel(args[0]);
+  // key
+  const key = __parseRelation_key(args[1]);
   // options
   const options = __parseRelation_options(args[2]);
   // combine
-  return `IModelRelationHasOne<${classModel}, ${options.autoload}, ${options.columns}>`;
+  return `IModelRelationHasOne<${classModel}, '${key}', ${options.autoload}, ${options.columns}>`;
 }
 
 function __parseRelationBelongsTo(args: t.Node[]) {
@@ -133,14 +135,14 @@ function __parseRelationBelongsTo(args: t.Node[]) {
 function __parseRelationHasMany(args: t.Node[]) {
   // classModel
   const classModel = __parseRelation_classModel(args[0]);
-  // // key
-  // const key = __parseRelation_key(args[1]);
+  // key
+  const key = __parseRelation_key(args[1]);
   // options
   const options = __parseRelation_options(args[2]);
   // modelJoins
   const modelJoins = __parseRelation_modelJoins(args[3]);
   // combine
-  return `IModelRelationHasMany<${classModel}, ${options.autoload}, ${options.columns},${modelJoins},${options.aggrs},${options.groups}>`;
+  return `IModelRelationHasMany<${classModel}, '${key}', ${options.autoload}, ${options.columns}, ${modelJoins}, ${options.aggrs}, ${options.groups}>`;
 }
 
 function __parseRelationBelongsToMany(args: t.Node[]) {
@@ -237,7 +239,7 @@ function __parseRelation_options(node: t.Node) {
     if (options?.groups) {
       columns = 'undefined';
     } else {
-      columns = '\'*\'';
+      columns = 'undefined'; // '\'*\'';
     }
   } else {
     if (options?.columns.includes('*')) {

package/dist/index.js

@@ -415,14 +415,12 @@ let ServiceTransaction = (_dec$o = Service(), _dec2$o = BeanInfo({
   get connection() {
     return this.transactionFiber?.connection;
   }
-  commit(cb, options) {
-    if (options?.ctxPrefer) {
-      this.ctx?.commit(cb);
-      return;
-    }
+  async commit(cb, options) {
     const fiber = this.transactionFiber;
     if (!fiber) {
-      this.ctx?.commit(cb);
+      if (!options?.ignoreIfNotInTransaction) {
+        await cb();
+      }
     } else {
       fiber.commit(cb);
     }
@@ -577,8 +575,8 @@ let ServiceDb = (_dec$n = Service(), _dec2$n = BeanInfo({
   get dialect() {
     return this.scope.service.database.getDialect(this.dialectName);
   }
-  commit(cb, options) {
-    return this.transaction.commit(cb, options);
+  async commit(cb, options) {
+    return await this.transaction.commit(cb, options);
   }
   compensate(cb) {
     return this.transaction.compensate(cb);
@@ -2254,6 +2252,49 @@ let ServiceCacheQuery = (_dec$c = Service(), _dec2$c = BeanInfo({
   }
 }) || _class$c) || _class$c);
 
+function handleRelationsCollection(relationsStatic, includeWrapper) {
+  // collect
+  const relations = [];
+  // include
+  if (relationsStatic) {
+    for (const key in relationsStatic) {
+      const relationDef = relationsStatic[key];
+      const relationCur = includeWrapper?.include?.[key];
+      let relationReal;
+      let includeReal;
+      let withReal;
+      let autoload;
+      if (relationCur === false) {
+        continue;
+      } else if (relationCur === true) {
+        relationReal = relationDef;
+        autoload = relationDef.options?.autoload;
+      } else if (typeof relationCur === 'object') {
+        relationReal = deepExtend({}, relationDef, {
+          options: relationCur
+        });
+        includeReal = relationCur.include;
+        withReal = relationCur.with;
+      } else if (relationDef.options?.autoload) {
+        relationReal = relationDef;
+        autoload = relationDef.options?.autoload;
+      } else {
+        continue;
+      }
+      relations.push([key, relationReal, includeReal, withReal, autoload]);
+    }
+  }
+  // with
+  if (includeWrapper?.with) {
+    for (const key in includeWrapper.with) {
+      const relationReal = includeWrapper.with[key];
+      if (!relationReal) continue;
+      relations.push([key, relationReal, relationReal.options?.include, relationReal.options?.with, false]);
+    }
+  }
+  return relations;
+}
+
 var _dec$b, _dec2$b, _class$b;
 let ServiceRelations = (_dec$b = Service(), _dec2$b = BeanInfo({
   module: "a-orm"
@@ -2265,21 +2306,25 @@ let ServiceRelations = (_dec$b = Service(), _dec2$b = BeanInfo({
   __init__(model) {
     this._model = model;
   }
-  async handleRelationsOne(entity, includeWrapper, methodOptions) {
+  async handleRelationsOne(relations, entity, includeWrapper, methodOptions) {
     if (!entity) return entity;
     // relations
-    const relations = this.__handleRelationsCollection(includeWrapper);
-    if (!relations) return entity;
+    if (!relations) {
+      relations = this.handleRelationsCollection(includeWrapper);
+    }
+    if (relations.length === 0) return entity;
     for (const relation of relations) {
       await this.__handleRelationOne(entity, relation, methodOptions);
     }
     return entity;
   }
-  async handleRelationsMany(entities, includeWrapper, methodOptions) {
+  async handleRelationsMany(relations, entities, includeWrapper, methodOptions) {
     if (entities.length === 0) return entities;
     // relations
-    const relations = this.__handleRelationsCollection(includeWrapper);
-    if (!relations) return entities;
+    if (!relations) {
+      relations = this.handleRelationsCollection(includeWrapper);
+    }
+    if (relations.length === 0) return entities;
     for (const relation of relations) {
       await this.__handleRelationMany(entities, relation, methodOptions);
     }
@@ -2288,7 +2333,7 @@ let ServiceRelations = (_dec$b = Service(), _dec2$b = BeanInfo({
   async handleRelationsMutate(entitiesResult, entities, includeWrapper, methodOptions) {
     if (entitiesResult.length === 0) return entitiesResult;
     // relations
-    const relations = this.__handleRelationsCollection(includeWrapper);
+    const relations = this.handleRelationsCollection(includeWrapper);
     if (!relations) return entitiesResult;
     for (const relation of relations) {
       entitiesResult = await this.__handleRelationMutate(entitiesResult, entities, relation, methodOptions);
@@ -2298,7 +2343,7 @@ let ServiceRelations = (_dec$b = Service(), _dec2$b = BeanInfo({
   async handleRelationsDelete(ids, includeWrapper, methodOptions) {
     if (ids.length === 0) return;
     // relations
-    const relations = this.__handleRelationsCollection(includeWrapper);
+    const relations = this.handleRelationsCollection(includeWrapper);
     if (!relations) return;
     for (const relation of relations) {
       await this.__handleRelationDelete(ids, relation, methodOptions);
@@ -2756,47 +2801,36 @@ let ServiceRelations = (_dec$b = Service(), _dec2$b = BeanInfo({
     columns = columns.concat(key);
     return [columns, false];
   }
-  __getModelTarget(modelClassTarget, meta) {
-    return this._model.newInstanceTarget(modelClassTarget, meta?.client, meta?.table);
-  }
-  __handleRelationsCollection(includeWrapper) {
-    // collect
-    const relations = [];
-    // include
-    if (this._model.options.relations) {
-      for (const key in this._model.options.relations) {
-        const relationDef = this._model.options.relations[key];
-        const relationCur = includeWrapper?.include?.[key];
-        let relationReal;
-        let includeReal;
-        let withReal;
-        if (relationCur === false) {
-          continue;
-        } else if (relationCur === true) {
-          relationReal = relationDef;
-        } else if (typeof relationCur === 'object') {
-          relationReal = deepExtend({}, relationDef, {
-            options: relationCur
-          });
-          includeReal = relationCur.include;
-          withReal = relationCur.with;
-        } else if (relationDef.options?.autoload) {
-          relationReal = relationDef;
-        } else {
-          continue;
+  prepareColumnsByRelations(relations, options) {
+    if (!options || !options.columns) return [options, undefined];
+    const columns = Array.isArray(options.columns) ? options.columns : [options.columns];
+    if (columns.includes('*')) return [options, undefined];
+    // refKeys
+    const refKeys = [];
+    for (const relation of relations) {
+      const [_relationName, relationReal] = relation;
+      const {
+        type,
+        key
+      } = relationReal;
+      if (type === 'belongsTo') {
+        if (!columns.includes(key)) {
+          columns.push(key);
+          refKeys.push(key);
         }
-        relations.push([key, relationReal, includeReal, withReal]);
-      }
-    }
-    // with
-    if (includeWrapper?.with) {
-      for (const key in includeWrapper.with) {
-        const relationReal = includeWrapper.with[key];
-        if (!relationReal) continue;
-        relations.push([key, relationReal, relationReal.options?.include, relationReal.options?.with]);
       }
     }
-    return relations;
+    options = refKeys.length === 0 ? options : {
+      ...options,
+      columns
+    };
+    return [options, refKeys];
+  }
+  __getModelTarget(modelClassTarget, meta) {
+    return this._model.newInstanceTarget(modelClassTarget, meta?.client, meta?.table);
+  }
+  handleRelationsCollection(includeWrapper) {
+    return handleRelationsCollection(this._model.options.relations, includeWrapper);
   }
 }) || _class$b) || _class$b);
 
@@ -2923,8 +2957,19 @@ class BeanModelCache extends BeanModelCrud {
   }
   async mget(ids, options) {
     if (ids.length === 0) return [];
-    const items = await this.__mget_raw(undefined, ids, options);
-    return await this.relations.handleRelationsMany(items, options, options);
+    const relations = this.relations.handleRelationsCollection(options);
+    const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
+    let items = await this.__mget_raw(undefined, ids, options2);
+    if (items.length === 0) return items;
+    items = await this.relations.handleRelationsMany(relations, items, options, options);
+    if (refKeys) {
+      for (const item of items) {
+        for (const refKey of refKeys) {
+          delete item[refKey];
+        }
+      }
+    }
+    return items;
   }
   async __mget_raw(table, ids, options) {
     // table
@@ -3008,8 +3053,19 @@ class BeanModelCache extends BeanModelCrud {
     };
   }
   async select(params, options, _modelJoins) {
-    const items = await this.__select_raw(undefined, params, options);
-    return await this.relations.handleRelationsMany(items, params, options);
+    const relations = this.relations.handleRelationsCollection(params);
+    const [params2, refKeys] = this.relations.prepareColumnsByRelations(relations, params);
+    let items = await this.__select_raw(undefined, params2, options);
+    if (items.length === 0) return items;
+    items = await this.relations.handleRelationsMany(relations, items, params, options);
+    if (refKeys) {
+      for (const item of items) {
+        for (const refKey of refKeys) {
+          delete item[refKey];
+        }
+      }
+    }
+    return items;
   }
   async __select_raw(table, params, options) {
     // table
@@ -3066,8 +3122,17 @@ class BeanModelCache extends BeanModelCrud {
     return items;
   }
   async get(where, options) {
-    const item = await this.__get_raw(undefined, where, options);
-    return await this.relations.handleRelationsOne(item, options, options);
+    const relations = this.relations.handleRelationsCollection(options);
+    const [options2, refKeys] = this.relations.prepareColumnsByRelations(relations, options);
+    let item = await this.__get_raw(undefined, where, options2);
+    if (!item) return item;
+    item = await this.relations.handleRelationsOne(relations, item, options, options);
+    if (refKeys) {
+      for (const refKey of refKeys) {
+        delete item[refKey];
+      }
+    }
+    return item;
   }
   async __get_raw(table, where, options) {
     // table
@@ -3269,11 +3334,11 @@ class BeanModelCache extends BeanModelCrud {
   }
   async cacheEntityDel(id, table) {
     await this.cacheEntityDelInner(id, table);
-    if (this.db.inTransaction) {
-      this.db.commit(async () => {
-        await this.cacheEntityDelInner(id, table);
-      });
-    }
+    this.db.commit(async () => {
+      await this.cacheEntityDelInner(id, table);
+    }, {
+      ignoreIfNotInTransaction: true
+    });
     this._shardingCacheDoubleDelete({
       beanFullName: this.$beanFullName,
       clientName: this.db.clientName,
@@ -3288,11 +3353,11 @@ class BeanModelCache extends BeanModelCrud {
   }
   async cacheEntityClear(table) {
     await this.cacheEntityClearInner(table);
-    if (this.db.inTransaction) {
-      this.db.commit(async () => {
-        await this.cacheEntityClearInner(table);
-      });
-    }
+    this.db.commit(async () => {
+      await this.cacheEntityClearInner(table);
+    }, {
+      ignoreIfNotInTransaction: true
+    });
     this._shardingCacheDoubleDelete({
       beanFullName: this.$beanFullName,
       clientName: this.db.clientName,
@@ -3307,11 +3372,11 @@ class BeanModelCache extends BeanModelCrud {
   }
   async cacheQueryClear(table) {
     await this.cacheQueryClearInner(table);
-    if (this.db.inTransaction) {
-      this.db.commit(async () => {
-        await this.cacheQueryClearInner(table);
-      });
-    }
+    this.db.commit(async () => {
+      await this.cacheQueryClearInner(table);
+    }, {
+      ignoreIfNotInTransaction: true
+    });
     this._shardingCacheDoubleDelete({
       beanFullName: this.$beanFullName,
       clientName: this.db.clientName,
@@ -3327,13 +3392,9 @@ class BeanModelCache extends BeanModelCrud {
   _shardingCacheDoubleDelete(jobData) {
     const doubleDelete = this.scopeOrm.config.sharding.cache.doubleDelete;
     if (!doubleDelete) return;
-    if (this.db.inTransaction) {
-      this.db.commit(() => {
-        this.scopeOrm.queue.doubleDelete.push(jobData);
-      });
-    } else {
+    this.db.commit(() => {
       this.scopeOrm.queue.doubleDelete.push(jobData);
-    }
+    });
   }
   async _cacheQueryClearModelsClear() {
     const modelsClear = this._getModelsClear();
@@ -3930,7 +3991,6 @@ function _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel) {
     include: includeReal,
     with: withReal
   });
-  const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel);
   if (mutateTypeTopLevel) {
     if (type === 'belongsTo') {
       // donot mutate
@@ -3943,13 +4003,17 @@ function _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel) {
         deleted: z.boolean().optional()
       }));
     } else if (type === 'hasOne') {
+      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
       schema = v.lazy(schemaLazy);
       // optional = true;
     } else {
+      // hasMany
+      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
       schema = v.array(v.lazy(schemaLazy));
     }
     Api.field(v.optional(), schema)(entityClass.prototype, relationName);
   } else {
+    const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
     let schema;
     let optional = false;
     if (type === 'hasOne' || type === 'belongsTo') {
@@ -3972,10 +4036,10 @@ function _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel) {
     }
   }
 }
-function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel) {
+function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation) {
   return () => {
     if (!autoload) {
-      return _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel);
+      return _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
     }
     // dynamic
     const entityClass = getClassEntityFromClassModel(modelTarget);
@@ -3984,16 +4048,16 @@ function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload,
     const dynamicName = `${beanFullName}_${_hashkey}`;
     let entityTarget = getSchemaDynamic(dynamicName);
     if (!entityTarget) {
-      entityTarget = _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel);
+      entityTarget = _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
       entityTarget[SymbolSchemaDynamicRefId] = dynamicName;
       addSchemaDynamic(dynamicName, entityTarget);
     }
     return entityTarget;
   };
 }
-function _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel) {
+function _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation) {
   if (mutateTypeTopLevel) {
-    return _DtoMutate_raw(modelTarget, optionsReal, mutateTypeTopLevel, undefined, false); // columnsOmitDefault: undefined
+    return _DtoMutate_raw(modelTarget, optionsReal, mutateTypeTopLevel, undefined, false, relation); // columnsOmitDefault: undefined
   } else {
     if (optionsReal.groups) {
       return DtoGroup(modelTarget, optionsReal.groups, optionsReal.aggrs, optionsReal.columns);
@@ -4017,50 +4081,11 @@ function _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLe
 }
 function _DtoGet_relations_collection(modelClass, includeWrapper) {
   const beanOptions = appResource.getBean(modelClass);
-  const options = beanOptions.options;
-  // collect
-  const relations = [];
-  // include
-  if (options.relations) {
-    for (const key in options.relations) {
-      const relationDef = options.relations[key];
-      const relationCur = includeWrapper?.include?.[key];
-      let relationReal;
-      let includeReal;
-      let withReal;
-      let autoload;
-      if (relationCur === false) {
-        continue;
-      } else if (relationCur === true) {
-        relationReal = relationDef;
-        autoload = relationDef.options?.autoload;
-      } else if (typeof relationCur === 'object') {
-        relationReal = deepExtend({}, relationDef, {
-          options: relationCur
-        });
-        includeReal = relationCur.include;
-        withReal = relationCur.with;
-      } else if (relationDef.options?.autoload) {
-        relationReal = relationDef;
-        autoload = relationDef.options?.autoload;
-      } else {
-        continue;
-      }
-      relations.push([key, relationReal, includeReal, withReal, autoload]);
-    }
-  }
-  // with
-  if (includeWrapper?.with) {
-    for (const key in includeWrapper.with) {
-      const relationReal = includeWrapper.with[key];
-      if (!relationReal) continue;
-      relations.push([key, relationReal, relationReal.options?.include, relationReal.options?.with, false]);
-    }
-  }
-  return relations;
+  const options = beanOptions?.options;
+  return handleRelationsCollection(options?.relations, includeWrapper);
 }
 
-function _DtoMutate_raw(modelLike, params, mutateTypeTopLevel, columnsOmitDefault, topLevel) {
+function _DtoMutate_raw(modelLike, params, mutateTypeTopLevel, columnsOmitDefault, topLevel, relation) {
   // model
   const modelClass = prepareClassModel(modelLike);
   // entity
@@ -4096,13 +4121,23 @@ function _DtoMutate_raw(modelLike, params, mutateTypeTopLevel, columnsOmitDefaul
   if (!topLevel && mutateTypeTopLevel !== 'create') {
     entityClass = $Class.partial(entityClass, ['id', 'deleted']);
   }
+  if (!topLevel && relation) {
+    const [_relationName, relationReal] = relation;
+    const {
+      type,
+      key
+    } = relationReal;
+    if (type === 'hasOne' || type === 'hasMany') {
+      entityClass = $Class.omit(entityClass, key);
+    }
+  }
   // relations
   _DtoGet_relations(modelClass, entityClass, params, mutateTypeTopLevel);
   return entityClass;
 }
 
 function DtoCreate(modelLike, params) {
-  return _DtoMutate_raw(modelLike, params, 'create', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true);
+  return _DtoMutate_raw(modelLike, params, 'create', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true, undefined);
 }
 
 function DtoQuery(classRef, keys) {
@@ -4122,7 +4157,7 @@ function DtoSelectAndCount(modelLike, params) {
 }
 
 function DtoUpdate(modelLike, params) {
-  return _DtoMutate_raw(modelLike, params, 'update', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true);
+  return _DtoMutate_raw(modelLike, params, 'update', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'], true, undefined);
 }
 
 // not use Partial/$Class.partial, for form render at frontend

package/dist/lib/dto/dtoMutate.d.ts

@@ -4,5 +4,6 @@ import type { IDtoMutateParams, TypeDtoMutateResult, TypeDtoMutateType } from '.
 import type { TypeModelColumnsStrict } from '../../types/modelWhere.ts';
 import type { IModelClassRecord } from '../../types/onion/model.ts';
 import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+import type { IRelationItem } from '../../types/relationsDef.ts';
 export declare function DtoMutate<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, 'mutate', undefined, true>>;
-export declare function _DtoMutate_raw<ModelLike extends BeanModelMeta | (keyof IModelClassRecord), T extends IDtoMutateParams<ModelLike> | undefined = undefined, ColumnsOmitDefault extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T, mutateTypeTopLevel?: TypeDtoMutateType, columnsOmitDefault?: ColumnsOmitDefault, topLevel?: boolean): any;
+export declare function _DtoMutate_raw<ModelLike extends BeanModelMeta | (keyof IModelClassRecord), T extends IDtoMutateParams<ModelLike> | undefined = undefined, ColumnsOmitDefault extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T, mutateTypeTopLevel?: TypeDtoMutateType, columnsOmitDefault?: ColumnsOmitDefault, topLevel?: boolean, relation?: IRelationItem): any;

package/dist/lib/relationsDynamic.d.ts

@@ -2,9 +2,9 @@ import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
 import type { IModelClassRecord } from '../types/onion/model.ts';
 import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from '../types/relations.ts';
 import type { IModelRelationBelongsToDynamic, IModelRelationBelongsToManyDynamic, IModelRelationHasManyDynamic, IModelRelationHasOneDynamic, IModelRelationOptionsManyDynamic, IModelRelationOptionsOneDynamic } from '../types/relationsDefDynamic.ts';
-declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, OPTIONS>;
+declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, KEY, OPTIONS>;
 declare function belongsTo<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined>(_classModelSelf: TypeModelClassLike<MODELSelf>, classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationBelongsToDynamic<MODELSelf, MODEL, OPTIONS>;
-declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): IModelRelationHasManyDynamic<MODEL, OPTIONS, ModelJoins, Group>;
+declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): IModelRelationHasManyDynamic<MODEL, KEY, OPTIONS, ModelJoins, Group>;
 declare function belongsToMany<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined>(classModelMiddle: TypeModelClassLike<MODELMiddle>, classModel: TypeModelClassLike<MODEL>, keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): IModelRelationBelongsToManyDynamic<MODELMiddle, MODEL, OPTIONS, ModelJoins, Group>;
 export declare const $relationDynamic: {
     hasOne: typeof hasOne;

package/dist/lib/relationsMutate.d.ts

@@ -3,8 +3,8 @@ import type { IModelClassRecord } from '../types/onion/model.ts';
 import type { TypeModelClassLike, TypeModelOfModelLike, TypeSymbolKeyEntity } from '../types/relations.ts';
 import type { IModelRelationBelongsToManyDynamic, IModelRelationHasManyDynamic, IModelRelationHasOneDynamic } from '../types/relationsDefDynamic.ts';
 import type { IModelRelationOptionsBelongsToManyMutate, IModelRelationOptionsManyMutate, IModelRelationOptionsOneMutate } from '../types/relationsDefMutate.ts';
-declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneMutate<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, OPTIONS>;
-declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyMutate<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationHasManyDynamic<MODEL, OPTIONS>;
+declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], OPTIONS extends IModelRelationOptionsOneMutate<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, KEY, OPTIONS>;
+declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], OPTIONS extends IModelRelationOptionsManyMutate<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS): IModelRelationHasManyDynamic<MODEL, KEY, OPTIONS>;
 declare function belongsToMany<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsBelongsToManyMutate<TypeModelOfModelLike<MODEL>>>(classModelMiddle: TypeModelClassLike<MODELMiddle>, classModel: TypeModelClassLike<MODEL>, keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationBelongsToManyDynamic<MODELMiddle, MODEL, OPTIONS>;
 export declare const $relationMutate: {
     hasOne: typeof hasOne;

package/dist/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import type { IModelRelationIncludeWrapper } from '../types/model.ts';
+import type { IRelationItem } from '../types/relationsDef.ts';
+export declare function handleRelationsCollection(relationsStatic?: Record<string, any>, includeWrapper?: IModelRelationIncludeWrapper): IRelationItem[];

package/dist/service/db_.d.ts

@@ -21,6 +21,6 @@ export declare class ServiceDb extends BeanBase {
     get connection(): import("knex").Knex<any, any[]>;
     get dialectName(): keyof IDatabaseClientDialectRecord;
     get dialect(): BeanDatabaseDialectBase;
-    commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions): void;
+    commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions): Promise<void>;
     compensate(cb: FunctionAny): void;
 }

package/dist/service/relations_.d.ts

@@ -1,12 +1,13 @@
 import type { TableIdentity } from 'table-identity';
 import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
 import type { IModelMethodOptions, IModelRelationIncludeWrapper } from '../types/model.ts';
+import type { IRelationItem } from '../types/relationsDef.ts';
 import { BeanBase } from 'vona';
 export declare class ServiceRelations extends BeanBase {
     protected _model: BeanModelCache;
     protected __init__(model: BeanModelCache): void;
-    handleRelationsOne<TRecord extends {}>(entity: TRecord | undefined, includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<TRecord | undefined>;
-    handleRelationsMany<TRecord extends {}>(entities: TRecord[], includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<TRecord[]>;
+    handleRelationsOne<TRecord extends {}>(relations: IRelationItem[] | undefined, entity: TRecord | undefined, includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<TRecord | undefined>;
+    handleRelationsMany<TRecord extends {}>(relations: IRelationItem[] | undefined, entities: TRecord[], includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<TRecord[]>;
     handleRelationsMutate<TRecord extends {}>(entitiesResult: TRecord[], entities: TRecord[], includeWrapper: IModelRelationIncludeWrapper | undefined, methodOptions: IModelMethodOptions | undefined): Promise<TRecord[]>;
     handleRelationsDelete(ids: TableIdentity[], includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<void>;
     private __handleRelationOne;
@@ -14,6 +15,9 @@ export declare class ServiceRelations extends BeanBase {
     private __handleRelationMutate;
     private __handleRelationDelete;
     private __prepareColumnsAndKey;
+    prepareColumnsByRelations<T extends {
+        columns?: any;
+    }>(relations: IRelationItem[], options?: T): [T | undefined, string[] | undefined];
     private __getModelTarget;
-    private __handleRelationsCollection;
+    handleRelationsCollection(includeWrapper?: IModelRelationIncludeWrapper): IRelationItem[];
 }

package/dist/service/transaction_.d.ts

@@ -11,7 +11,7 @@ export declare class ServiceTransaction extends BeanBase {
     get transactionFiber(): ServiceTransactionFiber | undefined;
     get inTransaction(): boolean;
     get connection(): knex.Knex.Transaction | undefined;
-    commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions): void;
+    commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions): Promise<void>;
     compensate(cb: FunctionAny): void;
     begin<RESULT>(fn: FunctionAsync<RESULT>, options?: ITransactionOptions): Promise<RESULT>;
     private _isolationLevelRequired;

package/dist/types/dto/dtoMutate.d.ts

@@ -4,7 +4,7 @@ import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
 import type { IModelRelationIncludeWrapper } from '../model.ts';
 import type { TypeModelColumnsStrict } from '../modelWhere.ts';
 import type { IDecoratorModelOptions, IModelClassRecord } from '../onion/model.ts';
-import type { TypeModelOfModelLike, TypeSymbolKeyEntity, TypeUtilEntityOmit, TypeUtilEntityPartial, TypeUtilEntitySelector, TypeUtilGetColumnsFromRelationAndIncludeWrapper, TypeUtilGetModelOptions, TypeUtilGetParamsColumns, TypeUtilGetParamsInlcude, TypeUtilGetParamsWith, TypeUtilGetRelationEntity, TypeUtilGetRelationModel, TypeUtilGetRelationOptions, TypeUtilGetRelationOptionsAutoload, TypeUtilGetRelationType, TypeUtilPrepareColumns } from '../relations.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity, TypeUtilEntityOmit, TypeUtilEntityPartial, TypeUtilEntitySelector, TypeUtilGetColumnsFromRelationAndIncludeWrapper, TypeUtilGetModelOptions, TypeUtilGetParamsColumns, TypeUtilGetParamsInlcude, TypeUtilGetParamsWith, TypeUtilGetRelationEntity, TypeUtilGetRelationKey, TypeUtilGetRelationModel, TypeUtilGetRelationOptions, TypeUtilGetRelationOptionsAutoload, TypeUtilGetRelationType, TypeUtilPrepareColumns } from '../relations.ts';
 export type TypeDtoMutateType = 'create' | 'update' | 'mutate';
 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> {
@@ -13,7 +13,7 @@ export interface IBuildDtoMutateParamsBasic<TRecord> {
     columns?: TypeModelColumnsStrict<TRecord>;
 }
 export type TypeDtoMutateResult<ModelLike extends BeanModelMeta | (keyof IModelClassRecord), TOptionsRelation, TMutateTypeTopLevel extends TypeDtoMutateType, TColumnsOmitDefault extends string | string[] | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = TypeDtoMutateRelationResult<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], TypeModelOfModelLike<ModelLike>, TOptionsRelation, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel>;
-export type TypeDtoMutateRelationResult<TRecord, TModel extends BeanModelMeta | undefined, TOptionsRelation, TMutateTypeTopLevel extends TypeDtoMutateType, TColumnsOmitDefault extends string | string[] | undefined = undefined, TTopLevel extends boolean | undefined = undefined, TColumns = undefined> = TypeDtoMutateRelationResultEntity<TRecord, TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel> & (TModel extends BeanModelMeta ? (OmitNever<TypeDtoMutateRelationResultMergeInclude<TMutateTypeTopLevel, TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>>> & OmitNever<TypeDtoMutateModelRelationResultMergeWith<TMutateTypeTopLevel, TypeUtilGetParamsWith<TOptionsRelation>>>) : {});
+export type TypeDtoMutateRelationResult<TRecord, TModel extends BeanModelMeta | undefined, TOptionsRelation, TMutateTypeTopLevel extends TypeDtoMutateType, TColumnsOmitDefault extends string | string[] | undefined = undefined, TTopLevel extends boolean | undefined = undefined, TColumns = undefined, REFKEY = undefined> = TypeDtoMutateRelationResultEntity<TRecord, TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel, REFKEY> & (TModel extends BeanModelMeta ? (OmitNever<TypeDtoMutateRelationResultMergeInclude<TMutateTypeTopLevel, TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>>> & OmitNever<TypeDtoMutateModelRelationResultMergeWith<TMutateTypeTopLevel, TypeUtilGetParamsWith<TOptionsRelation>>>) : {});
 type TypeDtoMutateRelationResultMergeInclude<TMutateTypeTopLevel extends TypeDtoMutateType, TModelOptions extends IDecoratorModelOptions, TInclude extends {} | undefined | unknown> = {
     [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]>;
 };
@@ -23,28 +23,19 @@ type TypeDtoMutateModelRelationResultMergeWith<TMutateTypeTopLevel extends TypeD
 type TypeDtoMutateRelationResultMergeIncludeWrapper<TMutateTypeTopLevel extends TypeDtoMutateType, Relation, IncludeWrapper> = IncludeWrapper extends false ? never : IncludeWrapper extends true ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined> : IncludeWrapper extends {} ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, IncludeWrapper> : never;
 type TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel extends TypeDtoMutateType, Relation> = TypeUtilGetRelationOptionsAutoload<Relation> extends true ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined> : never;
 type TypeDtoMutateRelationResultMergeWithRelation<TMutateTypeTopLevel extends TypeDtoMutateType, WithRelation> = WithRelation extends false ? never : WithRelation extends true ? never : WithRelation extends {} ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, WithRelation, TypeUtilGetRelationOptions<WithRelation>> : never;
-type TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel extends TypeDtoMutateType, Relation, IncludeWrapper extends {} | undefined | unknown> = TypeUtilGetDtoMutateEntityByType<TMutateTypeTopLevel, TypeUtilGetRelationEntity<Relation>, TypeUtilGetRelationType<Relation>, TypeUtilGetRelationModel<Relation>, IncludeWrapper, TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>>;
-type TypeUtilGetDtoMutateEntityByType<TMutateTypeTopLevel extends TypeDtoMutateType, TRecord, TYPE, TModel extends BeanModelMeta | undefined, IncludeWrapper extends {} | undefined | unknown, Columns> = TYPE extends 'belongsTo' ? never : TYPE extends 'belongsToMany' ? Array<{
+type TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel extends TypeDtoMutateType, Relation, IncludeWrapper extends {} | undefined | unknown> = TypeUtilGetDtoMutateEntityByType<TMutateTypeTopLevel, TypeUtilGetRelationEntity<Relation>, TypeUtilGetRelationType<Relation>, TypeUtilGetRelationModel<Relation>, IncludeWrapper, TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>, TypeUtilGetRelationKey<Relation>>;
+type TypeUtilGetDtoMutateEntityByType<TMutateTypeTopLevel extends TypeDtoMutateType, TRecord, TYPE, TModel extends BeanModelMeta | undefined, IncludeWrapper extends {} | undefined | unknown, Columns, REFKEY = undefined> = TYPE extends 'belongsTo' ? never : TYPE extends 'belongsToMany' ? Array<{
     id: TableIdentity;
     deleted?: boolean;
-}> | undefined : TYPE extends 'hasMany' ? Array<TypeDtoMutateRelationResult<TRecord, TModel, IncludeWrapper, TMutateTypeTopLevel, undefined, false, Columns>> | undefined : TypeDtoMutateRelationResult<TRecord, TModel, IncludeWrapper, TMutateTypeTopLevel, undefined, false, Columns> | undefined;
-type TypeDtoMutateRelationResultEntity<TRecord, Columns = undefined, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TColumnsOmitDefault extends string | string[] | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = TypeDtoMutateRelationResultPatch<TypeDtoMutateRelationResultEntityInner<TRecord, Columns, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel>, TMutateTypeTopLevel, TTopLevel>;
-type TypeDtoMutateRelationResultPatch<TRecordResult, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = TTopLevel extends false ? TMutateTypeTopLevel extends 'update' | 'mutate' ? TypeUtilEntityPartial<TRecordResult, 'id' | 'deleted'> : TRecordResult : TRecordResult;
+}> | 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;
+type TypeDtoMutateRelationResultEntity<TRecord, Columns = undefined, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TColumnsOmitDefault extends string | string[] | undefined = undefined, TTopLevel extends boolean | undefined = undefined, REFKEY = undefined> = TypeDtoMutateRelationResultPatch<TypeDtoMutateRelationResultEntityInner<TRecord, Columns, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel>, TMutateTypeTopLevel, TTopLevel, REFKEY>;
+type TypeDtoMutateRelationResultPatch<TRecordResult, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TTopLevel extends boolean | undefined = undefined, REFKEY = undefined> = TTopLevel extends false ? TypeUtilEntityOmit<TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>, REFKEY> : TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>;
+type TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = TTopLevel extends false ? TMutateTypeTopLevel extends 'update' | 'mutate' ? TypeUtilEntityPartial<TRecordResult, 'id' | 'deleted'> : TRecordResult : TRecordResult;
 type TypeDtoMutateRelationResultEntityInner<TRecord, Columns = undefined, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TColumnsOmitDefault extends string | string[] | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = [
     Columns
 ] extends [string | string[]] ? TypeDtoMutateRelationResultEntityFromColumns<TRecord, Columns, TMutateTypeTopLevel, TTopLevel> : TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<TRecord, TMutateTypeTopLevel, TColumnsOmitDefault>;
 type TypeDtoMutateRelationResultEntityFromColumns<TRecord, Columns = undefined, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = TypeUtilEntitySelector<TRecord, TypeUtilPrepareColumns<TypeDtoMutateRelationResultPrepareColumns<TypeUtilPrepareColumns<Columns>, TMutateTypeTopLevel, TTopLevel>>>;
 type TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<TRecord, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TColumnsOmitDefault extends string | string[] | undefined = undefined> = TypeUtilEntityOmit<TRecord, TypeUtilPrepareColumns<TypeDtoMutateRelationResultPrepareColumnsOmitDefault<TMutateTypeTopLevel, TColumnsOmitDefault>>>;
 type TypeDtoMutateRelationResultPrepareColumns<TColumns = undefined, TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TTopLevel extends boolean | undefined = undefined> = TTopLevel extends true ? TColumns : TMutateTypeTopLevel extends 'create' ? TypeOmitStringUnion<TColumns, 'deleted' | 'id'> : (TColumns | 'deleted' | 'id');
-type TypeDtoMutateRelationResultPrepareColumnsOmitDefault<TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TColumnsOmitDefault extends string | string[] | undefined = undefined> = TColumnsOmitDefault extends string | string[] ? TColumnsOmitDefault : TMutateTypeTopLevel extends 'create' ? [
-    'id',
-    'iid',
-    'deleted',
-    'createdAt',
-    'updatedAt'
-] : [
-    'iid',
-    'createdAt',
-    'updatedAt'
-];
+type TypeDtoMutateRelationResultPrepareColumnsOmitDefault<TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined, TColumnsOmitDefault extends string | string[] | undefined = undefined> = TColumnsOmitDefault extends string | string[] ? TColumnsOmitDefault : TMutateTypeTopLevel extends 'create' ? ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] : ['iid', 'createdAt', 'updatedAt'];
 export {};

package/dist/types/relations.d.ts

@@ -26,6 +26,9 @@ export type TypeModelParamsRelationOptions<Relation> = boolean | (Omit<TypeUtilG
 export type TypeUtilGetRelationType<Relation> = Relation extends {
     type?: infer TYPE;
 } ? TYPE : undefined;
+export type TypeUtilGetRelationKey<Relation> = Relation extends {
+    key?: infer KEY;
+} ? KEY : undefined;
 export type TypeUtilGetRelationModel<Relation> = Relation extends {
     model?: ((() => Constructable<infer MODEL extends BeanModelMeta>) | Constructable<infer MODEL extends BeanModelMeta>);
 } ? MODEL : Relation extends {

package/dist/types/relationsDef.d.ts

@@ -10,22 +10,22 @@ import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGener
 import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
 import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
 export type TypeModelRelationType = 'hasOne' | 'belongsTo' | 'hasMany' | 'belongsToMany';
-export interface IModelRelationHasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>> {
+export interface IModelRelationHasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity] | undefined = keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>> {
     type?: 'hasOne';
     model?: TypeModelClassLike<MODEL>;
-    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    key?: KEY;
     options?: IModelRelationOptionsOne<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS>;
 }
-export interface IModelRelationBelongsTo<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>> {
+export interface IModelRelationBelongsTo<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>> {
     type?: 'belongsTo';
     model?: TypeModelClassLike<MODEL>;
     key?: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity];
     options?: IModelRelationOptionsOne<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS>;
 }
-export interface IModelRelationHasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined, Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined> {
+export interface IModelRelationHasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity] | undefined = keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined, Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined> {
     type?: 'hasMany';
     model?: TypeModelClassLike<MODEL>;
-    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    key?: KEY;
     options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>;
 }
 export interface IModelRelationBelongsToMany<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined, Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined> {
@@ -36,7 +36,7 @@ export interface IModelRelationBelongsToMany<MODELMiddle extends BeanModelMeta |
     keyTo?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
     options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>;
 }
-export interface IModelRelationOptionsOne<MODEL extends BeanModelMeta, AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>> extends IModelRelationOptionsMetaWrapper {
+export interface IModelRelationOptionsOne<MODEL extends BeanModelMeta, AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>> extends IModelRelationOptionsMetaWrapper {
     autoload?: AUTOLOAD;
     columns?: TypeModelColumnsPatch<MODEL[TypeSymbolKeyEntity], COLUMNS>;
 }
@@ -57,3 +57,4 @@ export interface IModelRelationOptionsMetaWrapper {
     meta?: IModelRelationOptionsMeta;
 }
 export type TypeModelRelationOptionsMetaClient = '_auto_' | '_initial_' | '_inherit_' | keyof IDatabaseClientRecord | ServiceDb;
+export type IRelationItem = [string, any, any, any, boolean];

package/dist/types/relationsDefDynamic.d.ts

@@ -8,10 +8,10 @@ import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGener
 import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
 import type { TypeModelSelectGroupParamsColumnNames } from './relationsGroup.ts';
 import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
-export interface IModelRelationHasOneDynamic<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined> {
+export interface IModelRelationHasOneDynamic<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined> {
     type?: 'hasOne';
     model?: TypeModelClassLike<MODEL>;
-    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    key?: KEY;
     options?: OPTIONS;
 }
 export interface IModelRelationBelongsToDynamic<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined> {
@@ -20,10 +20,10 @@ export interface IModelRelationBelongsToDynamic<MODELSelf extends BeanModelMeta
     key?: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity];
     options?: OPTIONS;
 }
-export interface IModelRelationHasManyDynamic<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> {
+export interface IModelRelationHasManyDynamic<MODEL extends BeanModelMeta | (keyof IModelClassRecord), KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> {
     type?: 'hasMany';
     model?: TypeModelClassLike<MODEL>;
-    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    key?: KEY;
     options?: OPTIONS;
 }
 export interface IModelRelationBelongsToManyDynamic<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> {

package/dist/types/transaction.d.ts

@@ -14,5 +14,5 @@ export interface ITransactionOptions {
     propagation?: TypeTransactionPropagation;
 }
 export interface ITransactionConsistencyCommitOptions {
-    ctxPrefer?: boolean;
+    ignoreIfNotInTransaction?: boolean;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-orm",
   "type": "module",
-  "version": "5.0.53",
+  "version": "5.0.55",
   "title": "a-orm",
   "vonaModule": {
     "capabilities": {