vona-module-a-orm 5.0.46 → 5.0.48

package/dist/bean/bean.model/bean.model_meta.d.ts

@@ -30,7 +30,7 @@ export declare class BeanModelMeta<TRecord extends {} = {}> extends BeanBase {
     protected _prepareDisableDeletedByOptions(table: keyof ITableRecord, data: any, options?: IModelMethodOptionsGeneral, useRaw?: boolean): any;
     protected _prepareDisableDeletedByOptionsSimple(options?: IModelMethodOptionsGeneral): boolean | undefined;
     protected _checkIfEntityValidByDeleted(entity: any, options?: IModelMethodOptionsGeneral): boolean;
-    protected _checkDisableInstanceByOptions(options?: IModelMethodOptionsGeneral): boolean;
+    protected _checkDisableInstanceByOptions(_options?: IModelMethodOptionsGeneral): boolean;
     protected _checkDisableDeletedByOptions(options?: IModelMethodOptionsGeneral): boolean;
     protected _checkDisableCreateTimeByOptions(options?: IModelUpdateOptionsGeneral<TRecord>): boolean;
     protected _checkDisableUpdateTimeByOptions(options?: IModelUpdateOptionsGeneral<TRecord>): boolean;

package/dist/config/config.d.ts

@@ -35,11 +35,13 @@ export declare function config(_app: VonaApplication): {
                     updateAgeOnGet?: boolean;
                     updateAgeOnHas?: boolean;
                     broadcastOnSet?: import("vona-module-a-cache").TypeBroadcastOnSet;
+                    disableInstance?: boolean;
                 };
                 redis?: {
-                    ttl: number;
+                    ttl?: number;
                     updateAgeOnGet?: boolean;
                     client?: keyof import("vona-module-a-redis").IRedisClientRecord;
+                    disableInstance?: boolean;
                 };
                 enable?: boolean;
                 meta?: Omit<IOnionOptionsMeta, never> | undefined;
@@ -55,11 +57,13 @@ export declare function config(_app: VonaApplication): {
                     updateAgeOnGet?: boolean;
                     updateAgeOnHas?: boolean;
                     broadcastOnSet?: import("vona-module-a-cache").TypeBroadcastOnSet;
+                    disableInstance?: boolean;
                 };
                 redis?: {
-                    ttl: number;
+                    ttl?: number;
                     updateAgeOnGet?: boolean;
                     client?: keyof import("vona-module-a-redis").IRedisClientRecord;
+                    disableInstance?: boolean;
                 };
                 enable?: boolean;
                 meta?: Omit<IOnionOptionsMeta, never> | undefined;

package/dist/index.js

@@ -1362,14 +1362,10 @@ class BeanModelMeta extends BeanBase {
       delete data[columnNameInstance];
     } else {
       delete data.iid;
-      if (!isNil(options?.iid)) {
-        data[columnNameInstance] = options?.iid;
-      } else {
-        if (!this.ctx.instance) {
-          throw new Error('ctx.instance not exists');
-        }
-        data[columnNameInstance] = this.ctx.instance.id;
+      if (!this.ctx.instance) {
+        throw new Error('ctx.instance not exists');
       }
+      data[columnNameInstance] = this.ctx.instance.id;
     }
     return data;
   }
@@ -1398,8 +1394,8 @@ class BeanModelMeta extends BeanBase {
     const deleted = this._prepareDisableDeletedByOptionsSimple(options);
     return isNil(deleted) || Boolean(entity.deleted) === Boolean(deleted);
   }
-  _checkDisableInstanceByOptions(options) {
-    return options?.disableInstance ?? this.disableInstance;
+  _checkDisableInstanceByOptions(_options) {
+    return this.disableInstance;
   }
   _checkDisableDeletedByOptions(options) {
     if (this.disableDeleted) return true;
@@ -2092,7 +2088,7 @@ class ModelCacheBase extends BeanBase {
   }
   getName(table) {
     const clientNameReal = this.$scope.orm.service.database.prepareClientNameReal(this._model.db.clientName);
-    return `${this.$beanFullName}:${clientNameReal}:${table}:${this._cacheType}`;
+    return `${this._model.$beanFullName}:${clientNameReal}:${table}:${this._cacheType}`;
   }
   get options() {
     if (this[SymbolCacheOptions] === undefined) {
@@ -2128,7 +2124,11 @@ class ModelCacheBase extends BeanBase {
     _cacheOptions = deepExtend({
       enable: this.scopeOrm.config.summer.enable,
       meta: this.scopeOrm.config.summer.meta,
+      mem: {
+        disableInstance: this._model.disableInstance
+      },
       redis: {
+        disableInstance: this._model.disableInstance,
         client: this.scopeOrm.config.summer.redis.client
       }
     }, configPreset, _cacheOptions, {
@@ -2364,7 +2364,12 @@ let ServiceRelations = (_dec$a = Service(), _dec2$a = BeanInfo({
           [key]: idsFrom
         }
       });
-      const items = await modelTarget.select(options2, methodOptionsReal);
+      let items;
+      if (idsFrom.length === 0) {
+        items = [];
+      } else {
+        items = await modelTarget.select(options2, methodOptionsReal);
+      }
       for (const entity of entities) {
         entity[relationName] = items.find(item => {
           if (item[key] === cast(entity).id) {
@@ -2438,11 +2443,16 @@ let ServiceRelations = (_dec$a = Service(), _dec2$a = BeanInfo({
     } else if (type === 'belongsToMany') {
       const modelTargetMiddle = this.__getModelTarget(modelMiddle, options?.meta?.middle);
       const idsFrom = entities.map(item => cast(item).id).filter(id => !isNil(id));
-      const itemsMiddle = await modelTargetMiddle.select({
-        where: {
-          [keyFrom]: idsFrom
-        }
-      }, methodOptionsReal);
+      let itemsMiddle;
+      if (idsFrom.length === 0) {
+        itemsMiddle = [];
+      } else {
+        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]);
@@ -2577,12 +2587,17 @@ let ServiceRelations = (_dec$a = Service(), _dec2$a = BeanInfo({
         const entity = entities[index];
         if (entity[relationName] && entity[relationName].length > 0) {
           const idsTo = entity[relationName].map(item => item.id);
-          const itemsMiddle = await cast(modelTargetMiddle).__select_raw(undefined, {
-            where: {
-              [keyFrom]: cast(entity).id,
-              [keyTo]: idsTo
-            }
-          }, methodOptionsReal);
+          let itemsMiddle;
+          if (idsTo.length === 0) {
+            itemsMiddle = [];
+          } else {
+            itemsMiddle = await cast(modelTargetMiddle).__select_raw(undefined, {
+              where: {
+                [keyFrom]: cast(entity).id,
+                [keyTo]: idsTo
+              }
+            }, methodOptionsReal);
+          }
           for (const child of entity[relationName]) {
             const itemMiddle = itemsMiddle.find(item => item[keyTo] === child.id);
             if (!itemMiddle) {
@@ -2835,6 +2850,7 @@ class BeanModelCache extends BeanModelCrud {
     return result;
   }
   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);
   }
@@ -3127,7 +3143,6 @@ class BeanModelCache extends BeanModelCrud {
     const item = await cache.get(id, {
       get: async () => {
         // where: maybe contain aux key
-        // disableInstance: use the model options, not use options by outer
         return await super._get(table, where, {
           disableDeleted: true
         });

package/dist/types/config.d.ts

@@ -1,7 +1,7 @@
 import type { Knex } from 'knex';
 import type { VonaContext } from 'vona';
 import type { IDatabaseClientDialectRecord, IDatabaseClientRecord } from './database.ts';
-export type TypeDefaultClientNameFn = (ctx: VonaContext) => keyof IDatabaseClientRecord;
+export type TypeDefaultClientNameFn = (ctx?: VonaContext) => keyof IDatabaseClientRecord;
 export type TypeDefaultClientName = TypeDefaultClientNameFn | keyof IDatabaseClientRecord;
 export interface ConfigDatabaseClient extends Omit<Knex.Config, 'client'> {
     client: keyof IDatabaseClientDialectRecord;

package/dist/types/model.d.ts

@@ -37,20 +37,18 @@ export interface IBuildModelCountParams<TRecord, _Model extends BeanModelMeta |
     joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
 }
 export type IModelCountParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelCountParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;
-export type IModelMethodOptions = Omit<IModelMethodOptionsGeneral, 'disableInstance'>;
-export type IModelInsertOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelInsertOptionsGeneral<TRecord, Model>, 'disableInstance'>;
-export type IModelUpdateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelUpdateOptionsGeneral<TRecord, Model>, 'disableInstance'>;
-export type IModelDeleteOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelDeleteOptionsGeneral<TRecord, Model>, 'disableInstance'>;
-export type IModelGetOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelGetOptionsGeneral<TRecord, Model>, 'disableInstance'>;
-export type IModelMutateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelMutateOptionsGeneral<TRecord, Model>, 'disableInstance'>;
+export type IModelMethodOptions = IModelMethodOptionsGeneral;
+export type IModelInsertOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelInsertOptionsGeneral<TRecord, Model>;
+export type IModelUpdateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelUpdateOptionsGeneral<TRecord, Model>;
+export type IModelDeleteOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelDeleteOptionsGeneral<TRecord, Model>;
+export type IModelGetOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelGetOptionsGeneral<TRecord, Model>;
+export type IModelMutateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelMutateOptionsGeneral<TRecord, Model>;
 export interface IModelMethodOptionsGeneral {
     disableDeleted?: boolean;
-    disableInstance?: boolean;
     disableCreateTime?: boolean;
     disableUpdateTime?: boolean;
     disableCacheQuery?: boolean;
     disableCacheEntity?: boolean;
-    iid?: number;
     deleted?: boolean;
 }
 export interface IModelInsertOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined> extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {

package/package.json

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