@naturalcycles/js-lib 14.84.2 → 14.85.0

package/dist-esm/decorators/asyncMemo.decorator.js

@@ -1,7 +1,6 @@
-import { __asyncValues } from "tslib";
 import { _since } from '../time/time.util';
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util';
-import { jsonMemoSerializer } from './memo.util';
+import { jsonMemoSerializer, MapMemoCache } from './memo.util';
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
@@ -9,18 +8,17 @@ import { jsonMemoSerializer } from './memo.util';
  * Return `null` instead (it'll be cached).
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-export const _AsyncMemo = (opt) => (target, key, descriptor) => {
+export 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 { logHit = false, logMiss = false, noLogArgs = false, logger = console, cacheFactory, cacheKeyFn = jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheRejections = false, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = async function (...args) {
-        var e_1, _a;
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
         if (!cache.has(ctx)) {
@@ -30,23 +28,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
         }
         let value;
         try {
-            try {
-                for (var _b = __asyncValues(cache.get(ctx)), _c; _c = await _b.next(), !_c.done;) {
-                    const cacheLayer = _c.value;
-                    value = await cacheLayer.get(cacheKey);
-                    if (value !== undefined) {
-                        // it's a hit!
-                        break;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
+            value = await cache.get(ctx).get(cacheKey);
         }
         catch (err) {
             // log error, but don't throw, treat it as a "miss"
@@ -55,7 +37,7 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
         if (value !== undefined) {
             // hit!
             if (logHit) {
-                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_AsyncMemo hit`);
+                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_AsyncMemo hit`);
             }
             return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
         }
@@ -63,34 +45,45 @@ export const _AsyncMemo = (opt) => (target, key, descriptor) => {
         const started = Date.now();
         try {
             value = await originalFn.apply(ctx, args);
-            if (!noCacheResolved) {
-                Promise.all(cache.get(ctx).map(cacheLayer => cacheLayer.set(cacheKey, value))).catch(err => {
+            // 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 (!noCacheRejected) {
+            if (cacheRejections) {
                 // We put it to cache as raw Error, not Promise.reject(err)
-                Promise.all(cache.get(ctx).map(cacheLayer => cacheLayer.set(cacheKey, err))).catch(err => {
-                    // log and ignore the error
-                    logger.error(err);
-                });
+                // This is to support both sync and async functions
+                void (async () => {
+                    try {
+                        await cache.get(ctx).set(cacheKey, err);
+                    }
+                    catch (err) {
+                        // log and ignore the error
+                        logger.error(err);
+                    }
+                })();
             }
             throw err;
         }
         finally {
             if (logMiss) {
-                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_AsyncMemo miss (${_since(started)})`);
+                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_AsyncMemo miss (${_since(started)})`);
             }
         }
     };
     descriptor.value.dropCache = async () => {
         logger.log(`${methodSignature} @_AsyncMemo.dropCache()`);
         try {
-            await Promise.all([...cache.values()].flatMap(c => c.map(c => c.clear())));
+            await Promise.all([...cache.values()].map(c => c.clear()));
             cache.clear();
         }
         catch (err) {

package/dist-esm/decorators/decorator.util.js

@@ -19,8 +19,8 @@ export function _getTargetMethodSignature(target, keyStr) {
  * returns:
  * a, b, c
  */
-export function _getArgsSignature(args = [], noLogArgs = false) {
-    if (noLogArgs)
+export function _getArgsSignature(args = [], logArgs = true) {
+    if (!logArgs)
         return '';
     return args
         .map(arg => {

package/dist-esm/decorators/logMethod.decorator.js

@@ -20,13 +20,13 @@ export function _LogMethod(opt = {}) {
         _assert(typeof descriptor.value === 'function', '@_LogMethod can be applied only to methods');
         const originalFn = descriptor.value;
         const keyStr = String(key);
-        const { avg, noLogArgs, logStart, logResult, noLogResultLength, logger = console } = opt;
+        const { avg, logArgs = true, logStart, logResult, logResultLength = true, logger = console, } = opt;
         let { logResultFn } = opt;
         if (!logResultFn) {
             if (logResult) {
                 logResultFn = r => ['result:', _stringifyAny(r)];
             }
-            else if (!noLogResultLength) {
+            else if (logResultLength) {
                 logResultFn = r => (Array.isArray(r) ? [`result: ${r.length} items`] : []);
             }
         }
@@ -38,7 +38,7 @@ export function _LogMethod(opt = {}) {
             // e.g `NameOfYourClass.methodName`
             // or `NameOfYourClass(instanceId).methodName`
             const methodSignature = _getMethodSignature(ctx, keyStr);
-            const argsStr = _getArgsSignature(args, noLogArgs);
+            const argsStr = _getArgsSignature(args, logArgs);
             const callSignature = `${methodSignature}(${argsStr}) #${++count}`;
             if (logStart)
                 logger.log(`>> ${callSignature}`);

package/dist-esm/decorators/memo.decorator.js

@@ -1,8 +1,3 @@
-// Based on:
-// https://github.com/mgechev/memo-decorator/blob/master/index.ts
-// http://decodize.com/blog/2012/08/27/javascript-memoization-caching-results-for-better-performance/
-// http://inlehmansterms.net/2015/03/01/javascript-memoization/
-// https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
 import { _since } from '../time/time.util';
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util';
@@ -15,6 +10,15 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util';
  * 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)
+ *
+ * Based on:
+ * https://github.com/mgechev/memo-decorator/blob/master/index.ts
+ * http://decodize.com/blog/2012/08/27/javascript-memoization-caching-results-for-better-performance/
+ * http://inlehmansterms.net/2015/03/01/javascript-memoization/
+ * https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export const _Memo = (opt = {}) => (target, key, descriptor) => {
@@ -30,8 +34,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
     // 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 { logHit = false, logMiss = false, noLogArgs = false, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
-    const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheErrors = false, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
@@ -42,50 +45,27 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
         }
         else if (cache.get(ctx).has(cacheKey)) {
             if (logHit) {
-                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo hit`);
-            }
-            const res = cache.get(ctx).get(cacheKey);
-            if (awaitPromise) {
-                return res instanceof Error ? Promise.reject(res) : Promise.resolve(res);
-            }
-            else {
-                return res;
+                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_Memo hit`);
             }
+            return cache.get(ctx).get(cacheKey);
         }
         const started = Date.now();
-        const res = originalFn.apply(ctx, args);
-        if (awaitPromise) {
-            return res
-                .then(res => {
-                // console.log('RESOLVED', res)
-                if (logMiss) {
-                    logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo miss resolved (${_since(started)})`);
-                }
-                if (!noCacheResolved) {
-                    cache.get(ctx).set(cacheKey, res);
-                }
-                return res;
-            })
-                .catch(err => {
-                // console.log('REJECTED', err)
-                if (logMiss) {
-                    logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo miss rejected (${_since(started)})`);
-                }
-                if (!noCacheRejected) {
-                    // We put it to cache as raw Error, not Promise.reject(err)
-                    // So, we'll need to check if it's instanceof Error to reject it or resolve
-                    // Wrap as Error if it's not Error
-                    cache.get(ctx).set(cacheKey, err instanceof Error ? err : new Error(err));
-                }
-                throw err;
-            });
+        let value;
+        try {
+            value = originalFn.apply(ctx, args);
+            cache.get(ctx).set(cacheKey, value);
+            return value;
+        }
+        catch (err) {
+            if (cacheErrors) {
+                cache.get(ctx).set(cacheKey, err);
+            }
+            throw err;
         }
-        else {
+        finally {
             if (logMiss) {
-                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo miss (${_since(started)})`);
+                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_Memo miss (${_since(started)})`);
             }
-            cache.get(ctx).set(cacheKey, res);
-            return res;
         }
     };
     descriptor.value.dropCache = () => {

package/dist-esm/decorators/memoFn.js

@@ -1,60 +1,41 @@
 import { _since } from '../time/time.util';
 import { _getArgsSignature } from './decorator.util';
 import { jsonMemoSerializer, MapMemoCache } from './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.
+ */
 export function _memoFn(fn, opt = {}) {
-    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, noCacheRejected = false, noCacheResolved = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
-    const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
     const fnName = fn.name;
     const memoizedFn = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
         if (cache.has(cacheKey)) {
             if (logHit) {
-                logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn hit`);
-            }
-            const res = cache.get(cacheKey);
-            if (awaitPromise) {
-                return res instanceof Error ? Promise.reject(res) : Promise.resolve(res);
-            }
-            else {
-                return res;
+                logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFn hit`);
             }
+            return cache.get(cacheKey);
         }
         const started = Date.now();
-        const res = fn.apply(ctx, args);
-        if (awaitPromise) {
-            return res
-                .then(res => {
-                // console.log('RESOLVED', res)
-                if (logMiss) {
-                    logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss resolved (${_since(started)})`);
-                }
-                if (!noCacheResolved) {
-                    cache.set(cacheKey, res);
-                }
-                return res;
-            })
-                .catch(err => {
-                // console.log('REJECTED', err)
-                if (logMiss) {
-                    logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss rejected (${_since(started)})`);
-                }
-                if (!noCacheRejected) {
-                    // We put it to cache as raw Error, not Promise.reject(err)
-                    // So, we'll need to check if it's instanceof Error to reject it or resolve
-                    // Wrap as Error if it's not Error
-                    cache.set(cacheKey, err instanceof Error ? err : new Error(err));
-                }
-                throw err;
-            });
+        let value;
+        try {
+            value = fn.apply(ctx, args);
+            cache.set(cacheKey, value);
+            return value;
+        }
+        catch (err) {
+            if (cacheErrors) {
+                cache.set(cacheKey, err);
+            }
+            throw err;
         }
-        else {
+        finally {
             if (logMiss) {
-                logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss (${_since(started)})`);
+                logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFn miss (${_since(started)})`);
             }
-            cache.set(cacheKey, res);
-            return res;
         }
     };
     Object.assign(memoizedFn, { cache });

package/dist-esm/decorators/memoFnAsync.js

@@ -0,0 +1,62 @@
+import { _since } from '../time/time.util';
+import { _getArgsSignature } from './decorator.util';
+import { jsonMemoSerializer, MapMemoCache } from './memo.util';
+/**
+ * Only supports Sync functions.
+ * To support Async functions - use _memoFnAsync
+ */
+export function _memoFnAsync(fn, opt = {}) {
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const cache = cacheFactory();
+    const fnName = fn.name;
+    const memoizedFn = async function (...args) {
+        const ctx = this;
+        const cacheKey = cacheKeyFn(args);
+        let value;
+        try {
+            value = await cache.get(cacheKey);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+        if (value !== undefined) {
+            if (logHit) {
+                logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync hit`);
+            }
+            return value;
+        }
+        const started = Date.now();
+        try {
+            value = await fn.apply(ctx, args);
+            void (async () => {
+                try {
+                    await cache.set(cacheKey, value);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
+            })();
+            return value;
+        }
+        catch (err) {
+            if (cacheRejections) {
+                void (async () => {
+                    try {
+                        await cache.set(cacheKey, err);
+                    }
+                    catch (err) {
+                        logger.error(err);
+                    }
+                })();
+            }
+            throw err;
+        }
+        finally {
+            if (logMiss) {
+                logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync miss (${_since(started)})`);
+            }
+        }
+    };
+    Object.assign(memoizedFn, { cache });
+    return memoizedFn;
+}

package/dist-esm/decorators/memoSimple.decorator.js

@@ -34,7 +34,7 @@ export const memoSimple = (opt = {}) => (target, key, descriptor) => {
   }
    */
     const cache = new MapMemoCache();
-    const { logHit, logMiss, noLogArgs, logger = console } = opt;
+    const { logHit, logMiss, logArgs = true, logger = console } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
@@ -42,14 +42,14 @@ export const memoSimple = (opt = {}) => (target, key, descriptor) => {
         const cacheKey = jsonMemoSerializer(args);
         if (cache.has(cacheKey)) {
             if (logHit) {
-                logger.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo hit`);
+                logger.log(`${methodSignature}(${_getArgsSignature(args, logArgs)}) @memo hit`);
             }
             return cache.get(cacheKey);
         }
         const d = Date.now();
         const res = originalFn.apply(ctx, args);
         if (logMiss) {
-            logger.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${Date.now() - d} ms)`);
+            logger.log(`${methodSignature}(${_getArgsSignature(args, logArgs)}) @memo miss (${Date.now() - d} ms)`);
         }
         cache.set(cacheKey, res);
         return res;

package/dist-esm/index.js

@@ -10,6 +10,7 @@ export * from './decorators/logMethod.decorator';
 export * from './decorators/memo.decorator';
 export * from './decorators/asyncMemo.decorator';
 export * from './decorators/memoFn';
+export * from './decorators/memoFnAsync';
 export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
 export * from './error/app.error';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.84.2",
+  "version": "14.85.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/decorators/asyncMemo.decorator.ts

@@ -1,25 +1,51 @@
+import { CommonLogger } from '../log/commonLogger'
 import { _since } from '../time/time.util'
-import { Merge } from '../typeFest'
 import { AnyObject } from '../types'
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util'
-import { MemoOptions } from './memo.decorator'
-import { AsyncMemoCache, jsonMemoSerializer } from './memo.util'
-
-export type AsyncMemoOptions = Merge<
-  MemoOptions,
-  {
-    /**
-     * Provide a custom implementation of MemoCache.
-     * Function that creates an instance of `MemoCache`.
-     * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`.
-     *
-     * It's an ARRAY of Caches, to allow multiple layers of Cache.
-     * It will check it one by one, starting from the first.
-     * HIT will be returned immediately, MISS will go one level deeper, or returned (if the end of the Cache stack is reached).
-     */
-    cacheFactory: () => AsyncMemoCache[]
-  }
->
+import { AsyncMemoCache, jsonMemoSerializer, MapMemoCache } 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`.
+   */
+  cacheFactory?: () => AsyncMemoCache
+
+  /**
+   * Provide a custom implementation of CacheKey function.
+   */
+  cacheKeyFn?: (args: any[]) => any
+
+  /**
+   * Set to `true` to cache rejected promises (errors).
+   *
+   * Default false.
+   */
+  cacheRejections?: boolean
+
+  /**
+   * Default to false
+   */
+  logHit?: boolean
+
+  /**
+   * Default to false
+   */
+  logMiss?: boolean
+
+  /**
+   * Set to `false` to skip logging method arguments.
+   *
+   * Defaults to true.
+   */
+  logArgs?: boolean
+
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
+}
 
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
@@ -29,7 +55,7 @@ export type AsyncMemoOptions = Merge<
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export const _AsyncMemo =
-  (opt: AsyncMemoOptions): MethodDecorator =>
+  (opt: AsyncMemoOptions = {}): MethodDecorator =>
   (target, key, descriptor) => {
     if (typeof descriptor.value !== 'function') {
       throw new TypeError('Memoization can be applied only to methods')
@@ -38,17 +64,16 @@ export const _AsyncMemo =
     const originalFn = descriptor.value
 
     // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
-    const cache = new Map<AnyObject, AsyncMemoCache[]>()
+    const cache = new Map<AnyObject, AsyncMemoCache>()
 
     const {
       logHit = false,
       logMiss = false,
-      noLogArgs = false,
+      logArgs = true,
       logger = console,
-      cacheFactory,
+      cacheFactory = () => new MapMemoCache(),
       cacheKeyFn = jsonMemoSerializer,
-      noCacheRejected = false,
-      noCacheResolved = false,
+      cacheRejections = false,
     } = opt
 
     const keyStr = String(key)
@@ -68,13 +93,7 @@ export const _AsyncMemo =
       let value: any
 
       try {
-        for await (const cacheLayer of cache.get(ctx)!) {
-          value = await cacheLayer.get(cacheKey)
-          if (value !== undefined) {
-            // it's a hit!
-            break
-          }
-        }
+        value = await cache.get(ctx)!.get(cacheKey)
       } catch (err) {
         // log error, but don't throw, treat it as a "miss"
         logger.error(err)
@@ -86,7 +105,7 @@ export const _AsyncMemo =
           logger.log(
             `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
               args,
-              noLogArgs,
+              logArgs,
             )}) @_AsyncMemo hit`,
           )
         }
@@ -100,25 +119,30 @@ export const _AsyncMemo =
       try {
         value = await originalFn.apply(ctx, args)
 
-        if (!noCacheResolved) {
-          Promise.all(cache.get(ctx)!.map(cacheLayer => cacheLayer.set(cacheKey, value))).catch(
-            err => {
-              // log and ignore the error
-              logger.error(err)
-            },
-          )
-        }
+        // 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 (!noCacheRejected) {
+        if (cacheRejections) {
           // We put it to cache as raw Error, not Promise.reject(err)
-          Promise.all(cache.get(ctx)!.map(cacheLayer => cacheLayer.set(cacheKey, err))).catch(
-            err => {
+          // This is to support both sync and async functions
+          void (async () => {
+            try {
+              await cache.get(ctx)!.set(cacheKey, err)
+            } catch (err) {
               // log and ignore the error
               logger.error(err)
-            },
-          )
+            }
+          })()
         }
 
         throw err
@@ -127,7 +151,7 @@ export const _AsyncMemo =
           logger.log(
             `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
               args,
-              noLogArgs,
+              logArgs,
             )}) @_AsyncMemo miss (${_since(started)})`,
           )
         }
@@ -136,7 +160,7 @@ export const _AsyncMemo =
     ;(descriptor.value as any).dropCache = async () => {
       logger.log(`${methodSignature} @_AsyncMemo.dropCache()`)
       try {
-        await Promise.all([...cache.values()].flatMap(c => c.map(c => c.clear())))
+        await Promise.all([...cache.values()].map(c => c.clear()))
         cache.clear()
       } catch (err) {
         logger.error(err)

package/src/decorators/decorator.util.ts

@@ -23,8 +23,8 @@ export function _getTargetMethodSignature(target: AnyObject, keyStr: string): st
  * returns:
  * a, b, c
  */
-export function _getArgsSignature(args: any[] = [], noLogArgs = false): string {
-  if (noLogArgs) return ''
+export function _getArgsSignature(args: any[] = [], logArgs = true): string {
+  if (!logArgs) return ''
 
   return args
     .map(arg => {