@naturalcycles/js-lib 14.84.2 → 14.87.0

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

@@ -1,22 +1,48 @@
-import { Merge } from '../typeFest';
-import { MemoOptions } from './memo.decorator';
+import { CommonLogger } from '../log/commonLogger';
 import { AsyncMemoCache } from './memo.util';
-export declare type AsyncMemoOptions = Merge<MemoOptions, {
+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;
+    /**
+     * 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 false
+     */
+    logHit?: boolean;
+    /**
+     * Default to false
+     */
+    logMiss?: boolean;
+    /**
+     * Set to `false` to skip logging method arguments.
      *
-     * 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).
+     * Defaults to true.
+     */
+    logArgs?: boolean;
+    /**
+     * Default to `console`
      */
-    cacheFactory: () => AsyncMemoCache[];
-}>;
+    logger?: CommonLogger;
+}
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
  * Method CANNOT return `undefined`, as undefined will always be treated as cache MISS and retried.
  * Return `null` instead (it'll be cached).
  */
-export declare const _AsyncMemo: (opt: AsyncMemoOptions) => MethodDecorator;
+export declare const _AsyncMemo: (opt?: AsyncMemoOptions) => MethodDecorator;

package/dist/decorators/asyncMemo.decorator.js

@@ -11,14 +11,14 @@ const memo_util_1 = require("./memo.util");
  * Return `null` instead (it'll be cached).
  */
 // 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 { logHit = false, logMiss = false, noLogArgs = false, logger = console, cacheFactory, cacheKeyFn = memo_util_1.jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = true, } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = async function (...args) {
@@ -31,13 +31,7 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
         }
         let value;
         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"
@@ -46,42 +40,56 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
         if (value !== undefined) {
             // hit!
             if (logHit) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_AsyncMemo hit`);
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_AsyncMemo hit`);
+            }
+            if (value instanceof Error) {
+                throw value;
             }
-            return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+            return value;
         }
         // Here we know it's a MISS, let's execute the real method
         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(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_AsyncMemo miss (${(0, time_util_1._since)(started)})`);
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_AsyncMemo miss (${(0, time_util_1._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/decorators/createPromiseDecorator.d.ts

@@ -2,9 +2,9 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
     decoratorName: string;
     /**
      * Called BEFORE the original function.
-     * Returns void.
+     * If Promise is returned - it will be awaited.
      */
-    beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void;
+    beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void | Promise<void>;
     /**
      * Called just AFTER the original function.
      * The output of this hook will be passed further,

package/dist/decorators/createPromiseDecorator.js

@@ -24,12 +24,11 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
         pd.value = async function (...args) {
             // console.log(`@${cfg.decoratorName} called inside function`)
             const started = Date.now();
-            return (Promise.resolve()
+            try {
                 // Before function
-                .then(() => {
                 // console.log(`@${cfg.decoratorName} Before`)
                 if (cfg.beforeFn) {
-                    return cfg.beforeFn({
+                    await cfg.beforeFn({
                         decoratorParams,
                         args,
                         key,
@@ -38,10 +37,8 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
                         started,
                     });
                 }
-            })
                 // Original function
-                .then(() => originalMethod.apply(this, args))
-                .then(res => {
+                let res = await originalMethod.apply(this, args);
                 // console.log(`${cfg.decoratorName} After`)
                 const resp = {
                     decoratorParams,
@@ -59,8 +56,8 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
                 }
                 cfg.finallyFn?.(resp);
                 return res;
-            })
-                .catch(err => {
+            }
+            catch (err) {
                 console.error(`@${decoratorName} ${methodSignature} catch:`, err);
                 const resp = {
                     decoratorParams,
@@ -82,10 +79,7 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
                 if (!handled) {
                     throw err; // rethrow
                 }
-            })
-            // es2018 only
-            // .finally(() => {})
-            );
+            }
         };
         return pd;
     };

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

@@ -15,4 +15,4 @@ export declare function _getTargetMethodSignature(target: AnyObject, keyStr: str
  * returns:
  * a, b, c
  */
-export declare function _getArgsSignature(args?: any[], noLogArgs?: boolean): string;
+export declare function _getArgsSignature(args?: any[], logArgs?: boolean): string;

package/dist/decorators/decorator.util.js

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

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

@@ -11,13 +11,15 @@ export interface LogMethodOptions {
      */
     avg?: number;
     /**
-     * Skip logging method arguments
+     * Defaults to true.
+     * Set to false to skip logging method arguments
      */
-    noLogArgs?: boolean;
+    logArgs?: boolean;
     /**
-     * Skip logging result length when result is an array.
+     * Defaults to true.
+     * Set to false to skip logging result length when result is an array.
      */
-    noLogResultLength?: boolean;
+    logResultLength?: boolean;
     /**
      * Also log on method start.
      * Example:

package/dist/decorators/logMethod.decorator.js

@@ -23,13 +23,13 @@ function _LogMethod(opt = {}) {
         (0, __1._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:', (0, __1._stringifyAny)(r)];
             }
-            else if (!noLogResultLength) {
+            else if (logResultLength) {
                 logResultFn = r => (Array.isArray(r) ? [`result: ${r.length} items`] : []);
             }
         }
@@ -41,7 +41,7 @@ function _LogMethod(opt = {}) {
             // e.g `NameOfYourClass.methodName`
             // or `NameOfYourClass(instanceId).methodName`
             const methodSignature = (0, decorator_util_1._getMethodSignature)(ctx, keyStr);
-            const argsStr = (0, decorator_util_1._getArgsSignature)(args, noLogArgs);
+            const argsStr = (0, decorator_util_1._getArgsSignature)(args, logArgs);
             const callSignature = `${methodSignature}(${argsStr}) #${++count}`;
             if (logStart)
                 logger.log(`>> ${callSignature}`);

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

@@ -1,22 +1,6 @@
 import { CommonLogger } from '../log/commonLogger';
 import { MemoCache } from './memo.util';
 export interface MemoOptions {
-    /**
-     * Default to false
-     */
-    logHit?: boolean;
-    /**
-     * Default to false
-     */
-    logMiss?: boolean;
-    /**
-     * Skip logging method arguments.
-     */
-    noLogArgs?: boolean;
-    /**
-     * Default to `console`
-     */
-    logger?: CommonLogger;
     /**
      * Provide a custom implementation of MemoCache.
      * Function that creates an instance of `MemoCache`.
@@ -28,19 +12,30 @@ export interface MemoOptions {
      */
     cacheKeyFn?: (args: any[]) => any;
     /**
-     * Don't cache resolved promises.
-     * Setting this to `true` will make the decorator to await the result.
+     * Defaults to true.
+     * Set to false to skip caching errors.
      *
-     * Default false.
+     * True will ensure "max 1 execution", but will "remember" errors.
+     * False will allow >1 execution in case of errors.
      */
-    noCacheResolved?: boolean;
+    cacheErrors?: boolean;
     /**
-     * Don't cache rejected promises.
-     * Setting this to `true` will make the decorator to await the result.
-     *
-     * Default false.
+     * Default to false
+     */
+    logHit?: boolean;
+    /**
+     * Default to false
+     */
+    logMiss?: boolean;
+    /**
+     * Defaults to true.
+     * Set to false to skip logging method arguments.
+     */
+    logArgs?: boolean;
+    /**
+     * Default to `console`
      */
-    noCacheRejected?: boolean;
+    logger?: CommonLogger;
 }
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
@@ -51,5 +46,14 @@ export interface MemoOptions {
  * 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/
  */
 export declare const _Memo: (opt?: MemoOptions) => MethodDecorator;

package/dist/decorators/memo.decorator.js

@@ -1,9 +1,4 @@
 "use strict";
-// 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/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._Memo = void 0;
 const time_util_1 = require("../time/time.util");
@@ -18,6 +13,15 @@ const memo_util_1 = require("./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
 const _Memo = (opt = {}) => (target, key, descriptor) => {
@@ -33,62 +37,52 @@ 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 memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
-    const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = true, } = 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());
         }
         else if (cache.get(ctx).has(cacheKey)) {
             if (logHit) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo hit`);
-            }
-            const res = cache.get(ctx).get(cacheKey);
-            if (awaitPromise) {
-                return res instanceof Error ? Promise.reject(res) : Promise.resolve(res);
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_Memo hit`);
             }
-            else {
-                return res;
+            value = cache.get(ctx).get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
             }
+            return value;
         }
         const started = Date.now();
-        const res = originalFn.apply(ctx, args);
-        if (awaitPromise) {
-            return res
-                .then(res => {
-                // console.log('RESOLVED', res)
-                if (logMiss) {
-                    logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo miss resolved (${(0, time_util_1._since)(started)})`);
-                }
-                if (!noCacheResolved) {
-                    cache.get(ctx).set(cacheKey, res);
-                }
-                return res;
-            })
-                .catch(err => {
-                // console.log('REJECTED', err)
-                if (logMiss) {
-                    logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo miss rejected (${(0, time_util_1._since)(started)})`);
+        try {
+            value = originalFn.apply(ctx, args);
+            try {
+                cache.get(ctx).set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
+            return value;
+        }
+        catch (err) {
+            if (cacheErrors) {
+                try {
+                    cache.get(ctx).set(cacheKey, err);
                 }
-                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));
+                catch (err) {
+                    logger.error(err);
                 }
-                throw err;
-            });
+            }
+            throw err;
         }
-        else {
+        finally {
             if (logMiss) {
-                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo miss (${(0, time_util_1._since)(started)})`);
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_Memo miss (${(0, time_util_1._since)(started)})`);
             }
-            cache.get(ctx).set(cacheKey, res);
-            return res;
         }
     };
     descriptor.value.dropCache = () => {

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

@@ -3,8 +3,8 @@ export declare 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 | undefined;
-    set(k: KEY, v: VALUE): void;
+    get(k: KEY): VALUE | Error | undefined;
+    set(k: KEY, v: VALUE | Error): void;
     /**
      * Clear is only called when `.dropCache()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
@@ -17,8 +17,8 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
      * 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.
      */
-    get(k: KEY): Promisable<VALUE | undefined>;
-    set(k: KEY, v: VALUE): Promisable<void>;
+    get(k: KEY): Promisable<VALUE | Error | undefined>;
+    set(k: KEY, v: VALUE | Error): Promisable<void>;
     /**
      * Clear is only called when `.dropCache()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
@@ -28,7 +28,7 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
 export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE> {
     private m;
     has(k: KEY): boolean;
-    get(k: KEY): VALUE | undefined;
-    set(k: KEY, v: VALUE): void;
+    get(k: KEY): VALUE | Error | undefined;
+    set(k: KEY, v: VALUE | Error): void;
     clear(): void;
 }

package/dist/decorators/memoFn.d.ts

@@ -3,4 +3,9 @@ import { MemoCache } from './memo.util';
 export interface MemoizedFunction {
     cache: MemoCache;
 }
+/**
+ * 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 declare function _memoFn<T extends (...args: any[]) => any>(fn: T, opt?: MemoOptions): T & MemoizedFunction;

package/dist/decorators/memoFn.js

@@ -4,60 +4,55 @@ exports._memoFn = void 0;
 const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
 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.
+ */
 function _memoFn(fn, opt = {}) {
-    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, noCacheRejected = false, noCacheResolved = false, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.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);
+        let value;
         if (cache.has(cacheKey)) {
             if (logHit) {
-                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn hit`);
+                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFn hit`);
             }
-            const res = cache.get(cacheKey);
-            if (awaitPromise) {
-                return res instanceof Error ? Promise.reject(res) : Promise.resolve(res);
-            }
-            else {
-                return res;
+            value = cache.get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
             }
+            return value;
         }
         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}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss resolved (${(0, time_util_1._since)(started)})`);
-                }
-                if (!noCacheResolved) {
-                    cache.set(cacheKey, res);
-                }
-                return res;
-            })
-                .catch(err => {
-                // console.log('REJECTED', err)
-                if (logMiss) {
-                    logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss rejected (${(0, time_util_1._since)(started)})`);
+        try {
+            value = fn.apply(ctx, args);
+            try {
+                cache.set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
+            return value;
+        }
+        catch (err) {
+            if (cacheErrors) {
+                try {
+                    cache.set(cacheKey, err);
                 }
-                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));
+                catch (err) {
+                    logger.error(err);
                 }
-                throw err;
-            });
+            }
+            throw err;
         }
-        else {
+        finally {
             if (logMiss) {
-                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss (${(0, time_util_1._since)(started)})`);
+                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFn miss (${(0, time_util_1._since)(started)})`);
             }
-            cache.set(cacheKey, res);
-            return res;
         }
     };
     Object.assign(memoizedFn, { cache });

package/dist/decorators/memoFnAsync.d.ts

@@ -0,0 +1,10 @@
+import { AsyncMemoOptions } from './asyncMemo.decorator';
+import { AsyncMemoCache } from './memo.util';
+export interface MemoizedAsyncFunction {
+    cache: AsyncMemoCache;
+}
+/**
+ * Only supports Sync functions.
+ * To support Async functions - use _memoFnAsync
+ */
+export declare function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(fn: T, opt?: AsyncMemoOptions): T & MemoizedAsyncFunction;