Allow options.cache to be a function and pass params to getRetryStrategy

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## `4.0.20`
+
+  * Добавлена возможность передавать функцию в options.cache.
+  * Добавлена передача params в getRetryStrategy.
+
 ## `4.0.19`
 
   * Добавлена возможность использования пользовательских стратегий ретраев.

docs/cache.md

@@ -45,6 +45,8 @@ const cache = new de.Cache();
 Он хранит все просто в памяти, нет ограничений на количество записей.
 Так что для каких-то серьезных ситуаций лучше его не использовать, а использовать [descript-redis-cache](https://www.npmjs.com/package/descript-redis-cache).
 
+`cache` также может быть функцией `({ params }) => Promise<CacheInterface<Result>>`. Если функция выбросит ошибку, то блок продолжит выполнение без кэширования.
+
 ## `options.key`
 
 Обязательный параметр `key` задает ключ хранения.

docs/http_block.md

@@ -441,7 +441,7 @@ block: {
 
 ```js
 block: {
-    getRetryStragety: ( { requestOptions, request } ) => {
+    getRetryStragety: ( { requestOptions, request, params } ) => {
         return new MyAwesomeRetryStrategy({ request, ... });
     },
 },

lib/block.ts

@@ -438,7 +438,7 @@
             blockCancel.throwIfCancelled();
 
             if (typeof step.after === 'function') {
                 resultAfter = await step.after({ cancel, params, context, deps, result: (resultBefore || resultBlock) as any });
                 blockCancel.throwIfCancelled();
 
                 if (resultAfter instanceof BaseBlock) {
@@ -523,8 +523,16 @@
         depsDomain?: DepsDomain;
     }): Promise<BlockResult> {
         let result: BlockResult | undefined = undefined;
+        let cache;
+
+        try {
+            cache = typeof this.options.cache === 'function' ?
+                await this.options.cache({ params }) :
+                this.options.cache;
+        } catch {
+            //  Do nothing
+        }
 
-        const cache = this.options.cache;
         let key;
         const optionsKey = this.options.key;
 

lib/httpBlock.ts

@@ -1,7 +1,7 @@
 import Block from './block';
 import { ERROR_ID, createError } from './error';
 
-import type { DescriptRequestOptions, BlockRequestOptions } from './request';
+import type { DescriptRequestOptions, BlockRequestOptions, GetRetryStrategyParams } from './request';
 import request from './request';
 
 import extend from './extend';
@@ -13,6 +13,7 @@ import type ContextClass from './context';
 import type Cancel from './cancel';
 import type DepsDomain from './depsDomain';
 import type { LoggerInterface } from './logger';
+import { RetryStrategyInterface } from './retryStrategy';
 
 //  ---------------------------------------------------------------------------------------------------------------  //
 
@@ -79,7 +80,7 @@ export interface DescriptHttpBlockDescription<
     HTTPResult,
 > extends Pick<
         DescriptRequestOptions,
-    'isError' | 'isRetryAllowed' | 'retryTimeout' | 'getRetryStrategy'
+    'isError' | 'isRetryAllowed' | 'retryTimeout'
     > {
     // sync with EVALUABLE_PROPS
     agent?: DescriptHttpBlockDescriptionCallback<DescriptRequestOptions['agent'], Params, Context>;
@@ -120,6 +121,9 @@ export interface DescriptHttpBlockDescription<
     parseBody?: (result: { body: DescriptHttpResult['body']; headers: DescriptHttpResult['headers'] }, context: Context) =>
     HTTPResult;
 
+    getRetryStrategy?: (args: {
+        params: Params;
+    } & GetRetryStrategyParams) => RetryStrategyInterface;
 }
 
 const EVALUABLE_PROPS: Array<keyof Pick<DescriptRequestOptions, 'agent' |
@@ -285,11 +289,16 @@ class HttpBlock<
 
         const callbackArgs: CallbackArgs<ParamsOut, Context> = { params, context, deps };
 
+        const blockGetRetryStrategy = block.getRetryStrategy;
+        const getRetryStrategy = typeof blockGetRetryStrategy === 'function' ?
+            (args: GetRetryStrategyParams) => blockGetRetryStrategy({ ...args, params }) :
+            undefined;
+
         let options: DescriptRequestOptions = {
             isError: block.isError,
             isRetryAllowed: block.isRetryAllowed,
             retryTimeout: block.retryTimeout,
-            getRetryStrategy: block.getRetryStrategy,
+            getRetryStrategy,
             body: null,
             ...(
                 EVALUABLE_PROPS.reduce((ret, prop) => {

lib/types.ts

@@ -195,7 +195,7 @@ export interface DescriptBlockOptions<
         deps: DescriptBlockDeps;
     }) => string);
     maxage?: number;
-    cache?: CacheInterface<BlockResult>;
+    cache?: CacheInterface<BlockResult> | ((args: { params: ParamsOut }) => Promise<CacheInterface<BlockResult>>);
 
     required?: boolean;
 

package.json

@@ -6,7 +6,7 @@
     },
     "name": "descript",
     "description": "descript",
-    "version": "4.0.19",
+    "version": "4.0.20",
     "homepage": "https://github.com/descript-org/descript",
     "repository": {
         "type": "git",

tests/options.cache.test.ts

@@ -324,4 +324,47 @@ describe('options.cache, options.key, options.maxage', () => {
         }).not.toThrow();
     });
 
+    it('cache can be a function', async() => {
+        const cache = new Cache();
+        const cachedValue = 'cached';
+        const params = { foo: 'bar' };
+
+        await cache.set({ key: 'KEY', value: cachedValue, maxage: 10000 });
+
+        const spy = vi.fn(() => 'result');
+        const cacheFn = vi.fn(() => Promise.resolve(cache));
+        const block = getResultBlock(spy, 50).extend({
+            options: {
+                cache: cacheFn,
+                key: 'KEY',
+                maxage: 10000,
+            },
+        });
+
+        const result = await de.run(block, { params });
+
+        expect(result).toBe(cachedValue);
+        expect(spy.mock.calls).toHaveLength(0);
+        expect(cacheFn).toHaveBeenCalledWith({ params });
+    });
+
+    it('cache function throws, block executes without cache', async() => {
+        const blockValue = 'result';
+
+        const spy = vi.fn(() => blockValue);
+        const cacheFn = vi.fn(() => Promise.reject(de.error('cache error')));
+        const block = getResultBlock(spy, 50).extend({
+            options: {
+                cache: cacheFn,
+                key: 'KEY',
+                maxage: 10000,
+            },
+        });
+
+        const result = await de.run(block);
+
+        expect(result).toBe(blockValue);
+        expect(spy.mock.calls).toHaveLength(1);
+    });
+
 });