vona-module-a-caching 5.0.3 → 5.0.4

package/dist/.metadata/index.d.ts

@@ -1,15 +1,30 @@
 /** aopMethod: begin */
+export * from '../bean/aopMethod.cachingClear.ts';
+export * from '../bean/aopMethod.cachingDel.ts';
 export * from '../bean/aopMethod.cachingGet.ts';
+export * from '../bean/aopMethod.cachingSet.ts';
+import type { IAopMethodOptionsCachingClear } from '../bean/aopMethod.cachingClear.ts';
+import type { IAopMethodOptionsCachingDel } from '../bean/aopMethod.cachingDel.ts';
 import type { IAopMethodOptionsCachingGet } from '../bean/aopMethod.cachingGet.ts';
+import type { IAopMethodOptionsCachingSet } from '../bean/aopMethod.cachingSet.ts';
 import 'vona';
 declare module 'vona-module-a-aspect' {
     interface IAopMethodRecord {
+        'a-caching:cachingClear': IAopMethodOptionsCachingClear;
+        'a-caching:cachingDel': IAopMethodOptionsCachingDel;
         'a-caching:cachingGet': IAopMethodOptionsCachingGet;
+        'a-caching:cachingSet': IAopMethodOptionsCachingSet;
     }
 }
 declare module 'vona-module-a-caching' {
+    interface AopMethodCachingClear {
+    }
+    interface AopMethodCachingDel {
+    }
     interface AopMethodCachingGet {
     }
+    interface AopMethodCachingSet {
+    }
 }
 /** aopMethod: end */
 /** scope: begin */

package/dist/.metadata/index.js

@@ -6,7 +6,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 /* eslint-disable */
 /** aopMethod: begin */
+export * from "../bean/aopMethod.cachingClear.js";
+export * from "../bean/aopMethod.cachingDel.js";
 export * from "../bean/aopMethod.cachingGet.js";
+export * from "../bean/aopMethod.cachingSet.js";
 import 'vona';
 /** aopMethod: end */
 /** scope: begin */

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

@@ -0,0 +1,9 @@
+import type { Next } from 'vona';
+import type { IAopMethodExecute, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import type { TypeCachingActionClearOptions } from '../types/caching.ts';
+import { BeanAopMethodBase } from 'vona';
+export interface IAopMethodOptionsCachingClear extends IDecoratorAopMethodOptions, TypeCachingActionClearOptions {
+}
+export declare class AopMethodCachingClear extends BeanAopMethodBase implements IAopMethodExecute {
+    execute(options: IAopMethodOptionsCachingClear, _args: [], next: Next, _receiver: any, _prop: string): Promise<any>;
+}

package/dist/bean/aopMethod.cachingClear.js

@@ -0,0 +1,23 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanAopMethodBase, beanFullNameFromOnionName } from 'vona';
+import { AopMethod } from 'vona-module-a-aspect';
+let AopMethodCachingClear = class AopMethodCachingClear extends BeanAopMethodBase {
+    async execute(options, _args, next, _receiver, _prop) {
+        // next
+        const value = await next();
+        // cache
+        const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
+        await cache.clear(options);
+        // ok
+        return value;
+    }
+};
+AopMethodCachingClear = __decorate([
+    AopMethod()
+], AopMethodCachingClear);
+export { AopMethodCachingClear };

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

@@ -0,0 +1,9 @@
+import type { Next } from 'vona';
+import type { IAopMethodExecute, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import type { TypeCachingActionOptions } from '../types/caching.ts';
+import { BeanAopMethodBase } from 'vona';
+export interface IAopMethodOptionsCachingDel extends IDecoratorAopMethodOptions, TypeCachingActionOptions {
+}
+export declare class AopMethodCachingDel extends BeanAopMethodBase implements IAopMethodExecute {
+    execute(options: IAopMethodOptionsCachingDel, args: [], next: Next, receiver: any, prop: string): Promise<any>;
+}

package/dist/bean/aopMethod.cachingDel.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { isNil } from '@cabloy/utils';
+import { BeanAopMethodBase, beanFullNameFromOnionName } from 'vona';
+import { AopMethod } from 'vona-module-a-aspect';
+import { combineCachingKey } from "../lib/utils.js";
+let AopMethodCachingDel = class AopMethodCachingDel extends BeanAopMethodBase {
+    async execute(options, args, next, receiver, prop) {
+        // next
+        const value = await next();
+        // key
+        const key = combineCachingKey(options, args, receiver, prop);
+        if (isNil(key) || key === false || key === '')
+            return value;
+        // cache
+        const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
+        await cache.del(key, options);
+        // ok
+        return value;
+    }
+};
+AopMethodCachingDel = __decorate([
+    AopMethod()
+], AopMethodCachingDel);
+export { AopMethodCachingDel };

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

@@ -1,8 +1,9 @@
-import type { Next, NextSync } from 'vona';
+import type { Next } from 'vona';
 import type { IAopMethodExecute, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import type { TypeCachingActionOptions } from '../types/caching.ts';
 import { BeanAopMethodBase } from 'vona';
-export interface IAopMethodOptionsCachingGet extends IDecoratorAopMethodOptions {
+export interface IAopMethodOptionsCachingGet extends IDecoratorAopMethodOptions, TypeCachingActionOptions {
 }
 export declare class AopMethodCachingGet extends BeanAopMethodBase implements IAopMethodExecute {
-    execute(_options: IAopMethodOptionsCachingGet, _args: [], next: Next | NextSync, _receiver: any, _prop: string): Promise<any> | any;
+    execute(options: IAopMethodOptionsCachingGet, args: [], next: Next, receiver: any, prop: string): Promise<any>;
 }

package/dist/bean/aopMethod.cachingGet.js

@@ -4,12 +4,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { BeanAopMethodBase } from 'vona';
+import { isNil } from '@cabloy/utils';
+import { BeanAopMethodBase, beanFullNameFromOnionName } from 'vona';
 import { AopMethod } from 'vona-module-a-aspect';
+import { combineCachingKey } from "../lib/utils.js";
 let AopMethodCachingGet = class AopMethodCachingGet extends BeanAopMethodBase {
-    execute(_options, _args, next, _receiver, _prop) {
-        // next
-        return next();
+    async execute(options, args, next, receiver, prop) {
+        // key
+        const key = combineCachingKey(options, args, receiver, prop);
+        if (isNil(key) || key === false || key === '')
+            return next();
+        // cache
+        const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
+        return await cache.get(key, Object.assign({}, options, { get: () => {
+                return next();
+            } }));
     }
 };
 AopMethodCachingGet = __decorate([

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

@@ -0,0 +1,11 @@
+import type { Next } from 'vona';
+import type { IAopMethodExecute, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import type { TypeCacheValueFn, TypeCachingActionOptions } from '../types/caching.ts';
+import { BeanAopMethodBase } from 'vona';
+export interface IAopMethodOptionsCachingSet extends IDecoratorAopMethodOptions, TypeCachingActionOptions {
+    cacheValue?: any;
+    cacheValueFn?: TypeCacheValueFn | string;
+}
+export declare class AopMethodCachingSet extends BeanAopMethodBase implements IAopMethodExecute {
+    execute(options: IAopMethodOptionsCachingSet, args: [], next: Next, receiver: any, prop: string): Promise<any>;
+}

package/dist/bean/aopMethod.cachingSet.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { isNil } from '@cabloy/utils';
+import { BeanAopMethodBase, beanFullNameFromOnionName } from 'vona';
+import { AopMethod } from 'vona-module-a-aspect';
+import { combineCachingKey, combineCachingValue } from "../lib/utils.js";
+let AopMethodCachingSet = class AopMethodCachingSet extends BeanAopMethodBase {
+    async execute(options, args, next, receiver, prop) {
+        // next
+        const value = await next();
+        // key
+        const key = combineCachingKey(options, args, receiver, prop);
+        if (isNil(key) || key === false || key === '')
+            return value;
+        // value
+        const cacheValue = combineCachingValue(options, args, receiver, prop, value);
+        // cache
+        const cache = this.bean.summer.cache(beanFullNameFromOnionName(options.cacheName, 'summerCache'));
+        await cache.set(cacheValue, key, options);
+        // ok
+        return value;
+    }
+};
+AopMethodCachingSet = __decorate([
+    AopMethod()
+], AopMethodCachingSet);
+export { AopMethodCachingSet };

package/dist/index.d.ts

@@ -1 +1,3 @@
 export * from './.metadata/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -1 +1,3 @@
 export * from "./.metadata/index.js";
+export * from "./lib/index.js";
+export * from "./types/index.js";

package/dist/lib/caching.d.ts

@@ -0,0 +1,15 @@
+import type { IAopMethodOptionsCachingClear } from '../bean/aopMethod.cachingClear.ts';
+import type { IAopMethodOptionsCachingDel } from '../bean/aopMethod.cachingDel.ts';
+import type { IAopMethodOptionsCachingGet } from '../bean/aopMethod.cachingGet.ts';
+import type { IAopMethodOptionsCachingSet } from '../bean/aopMethod.cachingSet.ts';
+declare function Get(options?: Partial<IAopMethodOptionsCachingGet>): MethodDecorator;
+declare function Set(options?: Partial<IAopMethodOptionsCachingSet>): MethodDecorator;
+declare function Del(options?: Partial<IAopMethodOptionsCachingDel>): MethodDecorator;
+declare function Clear(options?: Partial<IAopMethodOptionsCachingClear>): MethodDecorator;
+export declare const Caching: {
+    get: typeof Get;
+    set: typeof Set;
+    del: typeof Del;
+    clear: typeof Clear;
+};
+export {};

package/dist/lib/caching.js

@@ -0,0 +1,19 @@
+import { Aspect } from 'vona-module-a-aspect';
+function Get(options) {
+    return Aspect.aopMethod('a-caching:cachingGet', options);
+}
+function Set(options) {
+    return Aspect.aopMethod('a-caching:cachingSet', options);
+}
+function Del(options) {
+    return Aspect.aopMethod('a-caching:cachingDel', options);
+}
+function Clear(options) {
+    return Aspect.aopMethod('a-caching:cachingClear', options);
+}
+export const Caching = {
+    get: Get,
+    set: Set,
+    del: Del,
+    clear: Clear,
+};

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './caching.ts';
+export * from './utils.ts';

package/dist/lib/index.js

@@ -0,0 +1,2 @@
+export * from "./caching.js";
+export * from "./utils.js";

package/dist/lib/utils.d.ts

@@ -0,0 +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;

package/dist/lib/utils.js

@@ -0,0 +1,50 @@
+import { evaluateExpressions, isNil } from '@cabloy/utils';
+import { cast } from 'vona';
+import { getKeyHash } from 'vona-module-a-cache';
+export function combineCachingKey(options, args, receiver, prop) {
+    // 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 options.cacheKeyFn.call(receiver, args, prop, options, receiver);
+    }
+    // cacheKey
+    if (options.cacheKey) {
+        return evaluateExpressions(options.cacheKey, {
+            args,
+            prop,
+            options,
+            self: receiver,
+        });
+    }
+    // default
+    return `${cast(receiver).$beanFullName}_${options.cacheProp ?? prop}_${getKeyHash(args)}`;
+}
+export function combineCachingValue(options, args, receiver, prop, value) {
+    // 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 options.cacheValueFn.call(receiver, value, args, prop, options, receiver);
+    }
+    // cacheValue
+    if (!isNil(options.cacheValue)) {
+        return evaluateExpressions(options.cacheValue, {
+            value,
+            args,
+            prop,
+            options,
+            self: receiver,
+        });
+    }
+    // default
+    return value;
+}

package/dist/types/caching.d.ts

@@ -0,0 +1,11 @@
+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 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'>;

package/dist/types/caching.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './caching.ts';

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./caching.js";

package/package.json

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