vona-module-a-caching 5.0.14 → 5.0.16

package/dist/bean/aopMethod.cachingDel.d.ts

@@ -3,6 +3,7 @@ import type { IAopMethodExecute, IDecoratorAopMethodOptions } from 'vona-module-
 import type { TypeCachingActionOptions } from '../types/caching.ts';
 import { BeanAopMethodBase } from 'vona';
 export interface IAopMethodOptionsCachingDel extends IDecoratorAopMethodOptions, TypeCachingActionOptions {
+    intention: 'del' | 'create';
 }
 export declare class AopMethodCachingDel extends BeanAopMethodBase implements IAopMethodExecute {
     execute(options: IAopMethodOptionsCachingDel, args: [], next: Next, receiver: any, prop: string): Promise<any>;

package/dist/index.js

@@ -11,57 +11,82 @@ let AopMethodCachingClear = (_dec$4 = AopMethod(), _dec2$4 = BeanInfo({
   async execute(options, _args, next, receiver, prop) {
     if (!options.cacheName) throw new Error(`Should specify cacheName for caching: ${receiver.$beanFullName}#${prop}`);
     // next
-    const value = await next();
+    const result = await next();
     // cache
     const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
     await cache.clear(options);
     // ok
-    return value;
+    return result;
   }
 }) || _class$4) || _class$4);
 
-function combineCachingKey(options, args, receiver, prop) {
+function combineCachingKey(info, options) {
+  const {
+    result,
+    args,
+    prop,
+    receiver,
+    intention
+  } = info;
   // cacheKeyFn
   if (options.cacheKeyFn) {
     if (typeof options.cacheKeyFn === 'string') {
       if (!receiver[options.cacheKeyFn]) {
         throw new Error(`cacheKeyFn not found: ${cast(receiver).$beanFullName}#${options.cacheKeyFn}`);
       }
-      return receiver[options.cacheKeyFn](args, prop, options, receiver);
+      return _hashKey(receiver[options.cacheKeyFn](info, options));
     }
-    return options.cacheKeyFn.call(receiver, args, prop, options, receiver);
+    return _hashKey(options.cacheKeyFn.call(receiver, info, options));
   }
   // cacheKey
   if (options.cacheKey) {
-    return evaluateExpressions(options.cacheKey, {
+    return _hashKey(evaluateExpressions(options.cacheKey, {
       args,
       prop,
+      intention,
       options,
       self: receiver,
       app: cast(receiver).app,
       ctx: cast(receiver).ctx
-    });
+    }));
   }
-  // default
-  return `${cast(receiver).$beanFullName}_${options.cacheProp ?? prop}_${getKeyHash(args)}`;
+  // default: only use first arg
+  let argsPick;
+  if (intention === 'create') {
+    argsPick = [result?.id];
+  } else if (intention === 'set') {
+    argsPick = args.slice(0, args.length - 1);
+  } else {
+    argsPick = args;
+  }
+  const argFirst = argsPick.length === 1 ? argsPick[0] : argsPick;
+  return _hashKey(argFirst);
 }
-function combineCachingValue(options, args, receiver, prop, value) {
+function combineCachingValue(info, options) {
+  const {
+    result,
+    args,
+    prop,
+    receiver,
+    intention
+  } = info;
   // cacheValueFn
   if (!isNil(options.cacheValueFn)) {
     if (typeof options.cacheValueFn === 'string') {
       if (!receiver[options.cacheValueFn]) {
         throw new Error(`cacheValueFn not found: ${cast(receiver).$beanFullName}#${options.cacheValueFn}`);
       }
-      return receiver[options.cacheValueFn](value, args, prop, options, receiver);
+      return receiver[options.cacheValueFn](info, options);
     }
-    return options.cacheValueFn.call(receiver, value, args, prop, options, receiver);
+    return options.cacheValueFn.call(receiver, info, options);
   }
   // cacheValue
   if (!isNil(options.cacheValue)) {
     return evaluateExpressions(options.cacheValue, {
-      value,
+      result,
       args,
       prop,
+      intention,
       options,
       self: receiver,
       app: cast(receiver).app,
@@ -69,10 +94,18 @@ function combineCachingValue(options, args, receiver, prop, value) {
     });
   }
   // default
-  return value;
+  if (intention === 'set') {
+    return args[args.length - 1];
+  } else {
+    return result;
+  }
 }
 function isCachingKeyValid(key) {
-  return !isNil(key) && key !== false && key !== '';
+  return !isNil(key);
+  // return !isNil(key) && key !== false && key !== '';
+}
+function _hashKey(arg) {
+  return isCachingKeyValid(arg) ? getKeyHash(arg) : arg;
 }
 
 var _dec$3, _dec2$3, _class$3;
@@ -82,15 +115,21 @@ let AopMethodCachingDel = (_dec$3 = AopMethod(), _dec2$3 = BeanInfo({
   async execute(options, args, next, receiver, prop) {
     if (!options.cacheName) throw new Error(`Should specify cacheName for caching: ${receiver.$beanFullName}#${prop}`);
     // next
-    const value = await next();
+    const result = await next();
     // key
-    const key = combineCachingKey(options, args, receiver, prop);
-    if (!isCachingKeyValid(key)) return value;
+    const key = combineCachingKey({
+      args,
+      receiver,
+      prop,
+      result,
+      intention: options.intention ?? 'del'
+    }, options);
+    if (!isCachingKeyValid(key)) return result;
     // cache
     const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
     await cache.del(key, options);
     // ok
-    return value;
+    return result;
   }
 }) || _class$3) || _class$3);
 
@@ -101,7 +140,12 @@ let AopMethodCachingGet = (_dec$2 = AopMethod(), _dec2$2 = BeanInfo({
   async execute(options, args, next, receiver, prop) {
     if (!options.cacheName) throw new Error(`Should specify cacheName for caching: ${receiver.$beanFullName}#${prop}`);
     // key
-    const key = combineCachingKey(options, args, receiver, prop);
+    const key = combineCachingKey({
+      args,
+      receiver,
+      prop,
+      intention: 'get'
+    }, options);
     if (!isCachingKeyValid(key)) return next();
     // cache
     const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
@@ -120,17 +164,28 @@ let AopMethodCachingSet = (_dec$1 = AopMethod(), _dec2$1 = BeanInfo({
   async execute(options, args, next, receiver, prop) {
     if (!options.cacheName) throw new Error(`Should specify cacheName for caching: ${receiver.$beanFullName}#${prop}`);
     // next
-    const value = await next();
+    const result = await next();
     // key
-    const key = combineCachingKey(options, args, receiver, prop);
-    if (!isCachingKeyValid(key)) return value;
+    const key = combineCachingKey({
+      args,
+      receiver,
+      prop,
+      intention: 'set'
+    }, options);
+    if (!isCachingKeyValid(key)) return result;
     // value
-    const cacheValue = combineCachingValue(options, args, receiver, prop, value);
+    const cacheValue = combineCachingValue({
+      args,
+      receiver,
+      prop,
+      result,
+      intention: 'set'
+    }, options);
     // cache
     const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
     await cache.set(cacheValue, key, options);
     // ok
-    return value;
+    return result;
   }
 }) || _class$1) || _class$1);
 

package/dist/lib/utils.d.ts

@@ -1,6 +1,5 @@
-import type { BeanBase } from 'vona';
 import type { IAopMethodOptionsCachingSet } from '../bean/aopMethod.cachingSet.ts';
-import type { TypeCachingActionOptions } from '../types/caching.ts';
-export declare function combineCachingKey(options: TypeCachingActionOptions, args: [], receiver: BeanBase, prop: string): any;
-export declare function combineCachingValue(options: IAopMethodOptionsCachingSet, args: [], receiver: BeanBase, prop: string, value: any): any;
+import type { ICachingActionKeyInfo, ICachingActionValueInfo, TypeCachingActionOptions } from '../types/caching.ts';
+export declare function combineCachingKey(info: ICachingActionKeyInfo, options: TypeCachingActionOptions): any;
+export declare function combineCachingValue(info: ICachingActionValueInfo, options: IAopMethodOptionsCachingSet): any;
 export declare function isCachingKeyValid(key: any): boolean;

package/dist/types/caching.d.ts

@@ -1,11 +1,25 @@
 import type { BeanBase } from 'vona';
 import type { ISummerCacheRecord, TSummerCacheActionOptions } from 'vona-module-a-summer';
-export type TypeCacheKeyFn = (args: [], prop: string, options: TypeCachingActionOptions, receiver: BeanBase) => any;
-export type TypeCacheValueFn = (value: any, args: [], prop: string, options: TypeCachingActionOptions, receiver: BeanBase) => any;
+export type TypeCachingActionIntention = 'get' | 'set' | 'del' | 'create';
+export interface ICachingActionKeyInfo {
+    result?: any;
+    args: any[];
+    prop: string;
+    receiver: BeanBase;
+    intention: TypeCachingActionIntention;
+}
+export interface ICachingActionValueInfo {
+    result: any;
+    args: any[];
+    prop: string;
+    receiver: BeanBase;
+    intention: TypeCachingActionIntention;
+}
+export type TypeCacheKeyFn = (info: ICachingActionKeyInfo, options: TypeCachingActionOptions) => any;
+export type TypeCacheValueFn = (info: ICachingActionValueInfo, options: TypeCachingActionOptions) => any;
 export type TypeCachingActionOptions = Pick<TSummerCacheActionOptions<unknown, unknown>, 'mode' | 'ignoreNull' | 'ttl' | 'updateAgeOnGet' | 'broadcastOnSet'> & {
     cacheName: keyof ISummerCacheRecord;
     cacheKey?: any;
     cacheKeyFn?: TypeCacheKeyFn | string;
-    cacheProp?: string;
 };
-export type TypeCachingActionClearOptions = Omit<TypeCachingActionOptions, 'cacheKey' | 'cacheKeyFn' | 'cacheProp'>;
+export type TypeCachingActionClearOptions = Omit<TypeCachingActionOptions, 'cacheKey' | 'cacheKeyFn'>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-caching",
   "type": "module",
-  "version": "5.0.14",
+  "version": "5.0.16",
   "title": "a-caching",
   "vonaModule": {
     "dependencies": {}