@naturalcycles/js-lib 14.214.0 → 14.216.0

package/dist/decorators/asyncMemo.decorator.d.ts

@@ -1,38 +1,40 @@
 import type { CommonLogger } from '../log/commonLogger';
-import type { AsyncMemoCache } from './memo.util';
+import { AnyAsyncFunction, AnyFunction, AnyObject } from '../types';
+import { AsyncMemoCache } from './memo.util';
 export interface AsyncMemoOptions {
     /**
-     * Provide a custom implementation of MemoCache.
-     * Function that creates an instance of `MemoCache`.
-     * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`.
+     * Provide a custom implementation of AsyncMemoCache.
+     * Function that creates an instance of `AsyncMemoCache`.
      */
-    cacheFactory?: () => AsyncMemoCache;
+    cacheFactory: () => AsyncMemoCache;
     /**
      * Provide a custom implementation of CacheKey function.
      */
     cacheKeyFn?: (args: any[]) => any;
-    /**
-     * Default true.
-     *
-     * Set to `false` to skip caching rejected promises (errors).
-     *
-     * True will ensure "max 1 execution", but will "remember" rejection.
-     * False will allow >1 execution in case of errors.
-     */
-    cacheRejections?: boolean;
     /**
      * Default to `console`
      */
     logger?: CommonLogger;
 }
+export interface AsyncMemoInstance {
+    /**
+     * Clears the cache.
+     */
+    clear: () => Promise<void>;
+    getInstanceCache: () => Map<AnyObject, AsyncMemoCache>;
+    getCache: (instance: AnyAsyncFunction) => AsyncMemoCache | undefined;
+}
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
- * Important: it awaits the method to return the result before caching it.
- *
- * todo: test for "swarm requests", it should return "the same promise" and not cause a swarm origin hit
+ * Implementation is more complex than @_Memo, because it needs to handle "in-flight" Promises
+ * while waiting for cache to resolve, to prevent "async swarm" issue.
  *
- * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
- * Return `null` instead (it'll be cached).
+ * @experimental consider normal @_Memo for most of the cases, it's stable and predictable
+ */
+export declare const _AsyncMemo: (opt: AsyncMemoOptions) => MethodDecorator;
+/**
+ Call it on a method that is decorated with `@_AsyncMemo` to get access to additional functions,
+ e.g `clear` to clear the cache, or get its underlying data.
  */
-export declare const _AsyncMemo: (opt?: AsyncMemoOptions) => MethodDecorator;
+export declare function _getAsyncMemo(method: AnyFunction): AsyncMemoInstance;

package/dist/decorators/asyncMemo.decorator.js

@@ -1,95 +1,118 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._AsyncMemo = void 0;
+exports._getAsyncMemo = exports._AsyncMemo = void 0;
+const assert_1 = require("../error/assert");
+const types_1 = require("../types");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
- * Important: it awaits the method to return the result before caching it.
+ * Implementation is more complex than @_Memo, because it needs to handle "in-flight" Promises
+ * while waiting for cache to resolve, to prevent "async swarm" issue.
  *
- * todo: test for "swarm requests", it should return "the same promise" and not cause a swarm origin hit
- *
- * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
- * Return `null` instead (it'll be cached).
+ * @experimental consider normal @_Memo for most of the cases, it's stable and predictable
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
+const _AsyncMemo = (opt) => (target, key, descriptor) => {
     if (typeof descriptor.value !== 'function') {
         throw new TypeError('Memoization can be applied only to methods');
     }
     const originalFn = descriptor.value;
     // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
-    const cache = new Map();
-    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = true, } = opt;
+    const instanceCache = new Map();
+    // Cache from Instance to Map<key, Promise>
+    // This cache is temporary, with only one purpose - to prevent "async swarm"
+    // It only holds values that are "in-flight", until Promise is resolved
+    // After it's resolved - it's evicted from the cache and moved to the "proper" `instanceCache`
+    const instancePromiseCache = new Map();
+    const { logger = console, cacheFactory, cacheKeyFn = memo_util_1.jsonMemoSerializer } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
-    descriptor.value = async function (...args) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
-        if (!cache.has(ctx)) {
-            cache.set(ctx, cacheFactory());
+        let cache = instanceCache.get(ctx);
+        let promiseCache = instancePromiseCache.get(ctx);
+        if (!cache) {
+            cache = cacheFactory();
+            instanceCache.set(ctx, cache);
             // here, no need to check the cache. It's definitely a miss, because the cacheLayers is just created
             // UPD: no! AsyncMemo supports "persistent caches" (e.g Database-backed cache)
         }
-        let value;
-        try {
-            value = await cache.get(ctx).get(cacheKey);
+        if (!promiseCache) {
+            promiseCache = new Map();
+            instancePromiseCache.set(ctx, promiseCache);
         }
-        catch (err) {
-            // log error, but don't throw, treat it as a "miss"
-            logger.error(err);
+        let promise = promiseCache.get(cacheKey);
+        // If there's already "in-flight" cache request - return that, to avoid "async swarm"
+        if (promise) {
+            // console.log('return promise', promiseCache.size)
+            return promise;
         }
-        if (value !== undefined) {
-            // hit!
-            if (value instanceof Error) {
-                throw value;
+        promise = cache.get(cacheKey).then(async (value) => {
+            if (value !== types_1.MISS) {
+                // console.log('hit', promiseCache.size)
+                promiseCache.delete(cacheKey);
+                return value;
             }
-            return value;
-        }
-        // Here we know it's a MISS, let's execute the real method
-        try {
-            value = await originalFn.apply(ctx, args);
-            // Save the value in the Cache, without awaiting it
-            // This is to support both sync and async functions
-            void (async () => {
-                try {
-                    await cache.get(ctx).set(cacheKey, value);
-                }
-                catch (err) {
-                    // log and ignore the error
-                    logger.error(err);
-                }
-            })();
-            return value;
-        }
-        catch (err) {
-            if (cacheRejections) {
-                // We put it to cache as raw Error, not Promise.reject(err)
-                // This is to support both sync and async functions
+            // Miss
+            // console.log('miss', promiseCache.size)
+            return await onMiss();
+        }, async (err) => {
+            // Log the cache error and proceed "as cache Miss"
+            logger.error(err);
+            return await onMiss();
+        });
+        promiseCache.set(cacheKey, promise);
+        return promise;
+        //
+        async function onMiss() {
+            try {
+                const value = await originalFn.apply(ctx, args);
+                // Save the value in the Cache, in parallel,
+                // not to slow down the main function execution
+                // and not to fail on possible cache issues
                 void (async () => {
                     try {
-                        await cache.get(ctx).set(cacheKey, err);
+                        await cache.set(cacheKey, value);
                     }
                     catch (err) {
-                        // log and ignore the error
-                        logger.error(err);
+                        logger.error(err); // log and ignore the error
+                    }
+                    finally {
+                        // Clear the "in-flight" promise cache entry, as we now have a "permanent" cache entry
+                        promiseCache.delete(cacheKey);
+                        // console.log('cache set and cleared', promiseCache!.size)
                     }
                 })();
+                return value;
+            }
+            catch (err) {
+                promiseCache.delete(cacheKey);
+                throw err;
             }
-            throw err;
-        }
-    };
-    descriptor.value.dropCache = async () => {
-        logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
-        try {
-            await Promise.all([...cache.values()].map(c => c.clear()));
-            cache.clear();
-        }
-        catch (err) {
-            logger.error(err);
         }
     };
+    (0, types_1._objectAssign)(descriptor.value, {
+        clear: async () => {
+            logger.log(`${methodSignature} @_AsyncMemo.clear()`);
+            await Promise.all([...instanceCache.values()].map(c => c.clear()));
+            instanceCache.clear();
+        },
+        getInstanceCache: () => instanceCache,
+        getCache: instance => instanceCache.get(instance),
+    });
     return descriptor;
 };
 exports._AsyncMemo = _AsyncMemo;
+/**
+ Call it on a method that is decorated with `@_AsyncMemo` to get access to additional functions,
+ e.g `clear` to clear the cache, or get its underlying data.
+ */
+function _getAsyncMemo(method) {
+    (0, assert_1._assert)(typeof method?.getInstanceCache === 'function', 'method is not an AsyncMemo instance');
+    return method;
+}
+exports._getAsyncMemo = _getAsyncMemo;

package/dist/decorators/memo.decorator.d.ts

@@ -1,4 +1,5 @@
 import type { CommonLogger } from '../log/commonLogger';
+import { AnyFunction, AnyObject } from '../types';
 import type { MemoCache } from './memo.util';
 export interface MemoOptions {
     /**
@@ -11,31 +12,32 @@ export interface MemoOptions {
      * Provide a custom implementation of CacheKey function.
      */
     cacheKeyFn?: (args: any[]) => any;
-    /**
-     * Defaults to true.
-     * Set to false to skip caching errors.
-     *
-     * True will ensure "max 1 execution", but will "remember" errors.
-     * False will allow >1 execution in case of errors.
-     */
-    cacheErrors?: boolean;
     /**
      * Default to `console`
      */
     logger?: CommonLogger;
 }
+export interface MemoInstance {
+    /**
+     * Clears the cache.
+     */
+    clear: () => void;
+    getInstanceCache: () => Map<AnyObject, MemoCache>;
+    getCache: (instance: AnyFunction) => MemoCache | undefined;
+}
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
  * of the cache is the same. Key, by defaul, is calculated as `JSON.stringify(...args)`.
- * Cache is stored indefinitely in internal Map.
+ * Cache is stored indefinitely in the internal Map.
+ *
+ * If origin function throws an Error - it is NOT cached.
+ * So, error-throwing functions will be called multiple times.
+ * Therefor, if the origin function can possibly throw - it should try to be idempotent.
  *
  * Cache is stored **per instance** - separate cache for separate instances of the class.
  * If you don't want it that way - you can use a static method, then there will be only one "instance".
  *
- * Supports dropping it's cache by calling .dropCache() method of decorated function (useful in unit testing).
- *
- * Doesn't support Async functions, use @_AsyncMemo instead!
- * (or, it will simply return the [unresolved] Promise further, without awaiting it)
+ * Supports dropping it's cache by calling .clear() method of decorated function (useful in unit testing).
  *
  * Based on:
  * https://github.com/mgechev/memo-decorator/blob/master/index.ts
@@ -44,3 +46,8 @@ export interface MemoOptions {
  * https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
  */
 export declare const _Memo: (opt?: MemoOptions) => MethodDecorator;
+/**
+ Call it on a method that is decorated with `@_Memo` to get access to additional functions,
+ e.g `clear` to clear the cache, or get its underlying data.
+ */
+export declare function _getMemo(method: AnyFunction): MemoInstance;

package/dist/decorators/memo.decorator.js

@@ -1,20 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._Memo = void 0;
+exports._getMemo = exports._Memo = void 0;
+const assert_1 = require("../error/assert");
+const types_1 = require("../types");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
  * of the cache is the same. Key, by defaul, is calculated as `JSON.stringify(...args)`.
- * Cache is stored indefinitely in internal Map.
+ * Cache is stored indefinitely in the internal Map.
+ *
+ * If origin function throws an Error - it is NOT cached.
+ * So, error-throwing functions will be called multiple times.
+ * Therefor, if the origin function can possibly throw - it should try to be idempotent.
  *
  * Cache is stored **per instance** - separate cache for separate instances of the class.
  * If you don't want it that way - you can use a static method, then there will be only one "instance".
  *
- * Supports dropping it's cache by calling .dropCache() method of decorated function (useful in unit testing).
- *
- * Doesn't support Async functions, use @_AsyncMemo instead!
- * (or, it will simply return the [unresolved] Promise further, without awaiting it)
+ * Supports dropping it's cache by calling .clear() method of decorated function (useful in unit testing).
  *
  * Based on:
  * https://github.com/mgechev/memo-decorator/blob/master/index.ts
@@ -31,55 +34,54 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     // Map<ctx => MemoCache<cacheKey, result>>
     //
     // Internal map is from cacheKey to result
-    // External map is from ctx (instance of class) to Internal map
+    // External map (instanceCache) is from ctx (instance of class) to Internal map
     // External map is Weak to not cause memory leaks, to allow ctx objects to be garbage collected
     // UPD: tests show that normal Map also doesn't leak (to be tested further)
-    // Normal Map is needed to allow .dropCache()
-    const cache = new Map();
-    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = true, } = opt;
+    // Normal Map is needed to allow .clear()
+    const instanceCache = new Map();
+    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
-        let value;
-        if (!cache.has(ctx)) {
-            cache.set(ctx, cacheFactory());
+        let cache = instanceCache.get(ctx);
+        if (!cache) {
+            cache = cacheFactory();
+            instanceCache.set(ctx, cache);
         }
-        else if (cache.get(ctx).has(cacheKey)) {
-            value = cache.get(ctx).get(cacheKey);
-            if (value instanceof Error) {
-                throw value;
-            }
-            return value;
+        if (cache.has(cacheKey)) {
+            // Hit
+            return cache.get(cacheKey);
         }
+        // Miss
+        const value = originalFn.apply(ctx, args);
         try {
-            value = originalFn.apply(ctx, args);
-            try {
-                cache.get(ctx).set(cacheKey, value);
-            }
-            catch (err) {
-                logger.error(err);
-            }
-            return value;
+            cache.set(cacheKey, value);
         }
         catch (err) {
-            if (cacheErrors) {
-                try {
-                    cache.get(ctx).set(cacheKey, err);
-                }
-                catch (err) {
-                    logger.error(err);
-                }
-            }
-            throw err;
+            logger.error(err);
         }
+        return value;
     };
-    descriptor.value.dropCache = () => {
-        logger.log(`${methodSignature} @_Memo.dropCache()`);
-        cache.forEach(memoCache => memoCache.clear());
-        cache.clear();
-    };
+    (0, types_1._objectAssign)(descriptor.value, {
+        clear: () => {
+            logger.log(`${methodSignature} @_Memo.clear()`);
+            instanceCache.forEach(memoCache => memoCache.clear());
+            instanceCache.clear();
+        },
+        getInstanceCache: () => instanceCache,
+        getCache: instance => instanceCache.get(instance),
+    });
     return descriptor;
 };
 exports._Memo = _Memo;
+/**
+ Call it on a method that is decorated with `@_Memo` to get access to additional functions,
+ e.g `clear` to clear the cache, or get its underlying data.
+ */
+function _getMemo(method) {
+    (0, assert_1._assert)(typeof method?.getInstanceCache === 'function', 'method is not a Memo instance');
+    return method;
+}
+exports._getMemo = _getMemo;

package/dist/decorators/memo.util.d.ts

@@ -1,34 +1,53 @@
-import type { Promisable } from '../typeFest';
+import { MISS } from '..';
 export type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
 export interface MemoCache<KEY = any, VALUE = any> {
     has: (k: KEY) => boolean;
-    get: (k: KEY) => VALUE | Error | undefined;
-    set: (k: KEY, v: VALUE | Error) => void;
     /**
-     * Clear is only called when `.dropCache()` is called.
+     * `get` return signature doesn't contain `undefined`,
+     * because `undefined` is a valid VALUE to store in the Cache.
+     * `undefined` does NOT mean cache miss.
+     * Cache misses are checked by calling `has` method instead.
+     */
+    get: (k: KEY) => VALUE;
+    set: (k: KEY, v: VALUE) => void;
+    /**
+     * Clear is only called when `_getMemoCache().clear()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
      */
     clear: () => void;
 }
 export interface AsyncMemoCache<KEY = any, VALUE = any> {
     /**
-     * `undefined` value returned indicates the ABSENCE of value in the Cache.
-     * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
-     * You CAN store `null` value instead, it will be treated as a HIT.
+     * MISS symbol indicates the ABSENCE of value in the Cache.
+     * You can safely store `undefined` or `null` values in the Cache,
+     * they will not be interpreted as a cache miss, because there is a special MISS symbol for that.
      */
-    get: (k: KEY) => Promisable<VALUE | Error | undefined>;
-    set: (k: KEY, v: VALUE | Error) => Promisable<void>;
+    get: (k: KEY) => Promise<VALUE | typeof MISS>;
+    set: (k: KEY, v: VALUE) => Promise<void>;
     /**
-     * Clear is only called when `.dropCache()` is called.
+     * Clear is only called when `_getAsyncMemo().clear()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
      */
-    clear: () => Promisable<void>;
+    clear: () => Promise<void>;
 }
-export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE> {
+export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {
     private m;
     has(k: KEY): boolean;
-    get(k: KEY): VALUE | Error | undefined;
-    set(k: KEY, v: VALUE | Error): void;
+    get(k: KEY): VALUE;
+    set(k: KEY, v: VALUE): void;
     clear(): void;
 }
+/**
+ * Implementation of AsyncMemoCache backed by a synchronous Map.
+ * Doesn't have a practical use except testing,
+ * because the point of AsyncMemoCache is to have an **async** backed cache.
+ */
+export declare class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
+    private delay;
+    constructor(delay?: number);
+    private m;
+    get(k: KEY): Promise<VALUE | typeof MISS>;
+    set(k: KEY, v: VALUE): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/decorators/memo.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
+exports.MapAsyncMemoCache = exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
 const __1 = require("..");
 const jsonMemoSerializer = args => {
     if (args.length === 0)
@@ -73,3 +73,29 @@ class MapMemoCache {
     }
 }
 exports.MapMemoCache = MapMemoCache;
+/**
+ * Implementation of AsyncMemoCache backed by a synchronous Map.
+ * Doesn't have a practical use except testing,
+ * because the point of AsyncMemoCache is to have an **async** backed cache.
+ */
+class MapAsyncMemoCache {
+    constructor(delay = 0) {
+        this.delay = delay;
+        this.m = new Map();
+    }
+    async get(k) {
+        await (0, __1.pDelay)(this.delay);
+        if (!this.m.has(k))
+            return __1.MISS;
+        return this.m.get(k);
+    }
+    async set(k, v) {
+        await (0, __1.pDelay)(this.delay);
+        this.m.set(k, v);
+    }
+    async clear() {
+        await (0, __1.pDelay)(this.delay);
+        this.m.clear();
+    }
+}
+exports.MapAsyncMemoCache = MapAsyncMemoCache;

package/dist/decorators/memoFn.d.ts

@@ -7,5 +7,7 @@ export interface MemoizedFunction {
  * Only supports Sync functions.
  * To support Async functions - use _memoFnAsync.
  * Technically, you can use it with Async functions, but it'll return the Promise without awaiting it.
+ *
+ * @experimental
  */
 export declare function _memoFn<T extends (...args: any[]) => any>(fn: T, opt?: MemoOptions): T & MemoizedFunction;

package/dist/decorators/memoFn.js

@@ -6,42 +6,26 @@ const memo_util_1 = require("./memo.util");
  * Only supports Sync functions.
  * To support Async functions - use _memoFnAsync.
  * Technically, you can use it with Async functions, but it'll return the Promise without awaiting it.
+ *
+ * @experimental
  */
 function _memoFn(fn, opt = {}) {
-    const { logger = console, cacheErrors = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const memoizedFn = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
-        let value;
         if (cache.has(cacheKey)) {
-            value = cache.get(cacheKey);
-            if (value instanceof Error) {
-                throw value;
-            }
-            return value;
+            return cache.get(cacheKey);
         }
+        const value = fn.apply(ctx, args);
         try {
-            value = fn.apply(ctx, args);
-            try {
-                cache.set(cacheKey, value);
-            }
-            catch (err) {
-                logger.error(err);
-            }
-            return value;
+            cache.set(cacheKey, value);
         }
         catch (err) {
-            if (cacheErrors) {
-                try {
-                    cache.set(cacheKey, err);
-                }
-                catch (err) {
-                    logger.error(err);
-                }
-            }
-            throw err;
+            logger.error(err);
         }
+        return value;
     };
     Object.assign(memoizedFn, { cache });
     return memoizedFn;

package/dist/decorators/memoFnAsync.d.ts

@@ -4,7 +4,6 @@ export interface MemoizedAsyncFunction {
     cache: AsyncMemoCache;
 }
 /**
- * Only supports Sync functions.
- * To support Async functions - use _memoFnAsync
+ * @experimental
  */
-export declare function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(fn: T, opt?: AsyncMemoOptions): T & MemoizedAsyncFunction;
+export declare function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(fn: T, opt: AsyncMemoOptions): T & MemoizedAsyncFunction;

package/dist/decorators/memoFnAsync.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._memoFnAsync = void 0;
+const types_1 = require("../types");
 const memo_util_1 = require("./memo.util");
 /**
- * Only supports Sync functions.
- * To support Async functions - use _memoFnAsync
+ * @experimental
  */
-function _memoFnAsync(fn, opt = {}) {
-    const { logger = console, cacheRejections = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+function _memoFnAsync(fn, opt) {
+    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const memoizedFn = async function (...args) {
         const ctx = this;
@@ -19,37 +19,19 @@ function _memoFnAsync(fn, opt = {}) {
         catch (err) {
             logger.error(err);
         }
-        if (value !== undefined) {
-            if (value instanceof Error) {
-                throw value;
-            }
-            return value;
-        }
-        try {
-            value = await fn.apply(ctx, args);
-            void (async () => {
-                try {
-                    await cache.set(cacheKey, value);
-                }
-                catch (err) {
-                    logger.error(err);
-                }
-            })();
+        if (value !== types_1.MISS) {
             return value;
         }
-        catch (err) {
-            if (cacheRejections) {
-                void (async () => {
-                    try {
-                        await cache.set(cacheKey, err);
-                    }
-                    catch (err) {
-                        logger.error(err);
-                    }
-                })();
+        value = await fn.apply(ctx, args);
+        void (async () => {
+            try {
+                await cache.set(cacheKey, value);
             }
-            throw err;
-        }
+            catch (err) {
+                logger.error(err);
+            }
+        })();
+        return value;
     };
     Object.assign(memoizedFn, { cache });
     return memoizedFn;