vona-module-a-orm 5.0.53 → 5.0.54

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);
@@ -2265,21 +2263,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 +2290,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 +2300,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,10 +2758,35 @@ let ServiceRelations = (_dec$b = Service(), _dec2$b = BeanInfo({
     columns = columns.concat(key);
     return [columns, false];
   }
+  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);
+        }
+      }
+    }
+    options = refKeys.length === 0 ? options : {
+      ...options,
+      columns
+    };
+    return [options, refKeys];
+  }
   __getModelTarget(modelClassTarget, meta) {
     return this._model.newInstanceTarget(modelClassTarget, meta?.client, meta?.table);
   }
-  __handleRelationsCollection(includeWrapper) {
+  handleRelationsCollection(includeWrapper) {
     // collect
     const relations = [];
     // include
@@ -2923,8 +2950,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 +3046,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 +3115,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 +3327,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 +3346,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 +3365,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 +3385,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();

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/relationsDef.d.ts

@@ -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];

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.54",
   "title": "a-orm",
   "vonaModule": {
     "capabilities": {