@naturalcycles/js-lib 14.85.0 → 14.85.1

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

@@ -12,9 +12,12 @@ export interface AsyncMemoOptions {
      */
     cacheKeyFn?: (args: any[]) => any;
     /**
-     * Set to `true` to cache rejected promises (errors).
+     * Default true.
      *
-     * Default false.
+     * 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;
     /**

package/dist/decorators/asyncMemo.decorator.js

@@ -18,7 +18,7 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
     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, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = 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) {
@@ -42,7 +42,10 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_AsyncMemo hit`);
             }
-            return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         // Here we know it's a MISS, let's execute the real method
         const started = Date.now();

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

@@ -12,8 +12,11 @@ export interface MemoOptions {
      */
     cacheKeyFn?: (args: any[]) => any;
     /**
-     * Defaults to false.
-     * Set to true to cache thrown errors.
+     * 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;
     /**

package/dist/decorators/memo.decorator.js

@@ -37,12 +37,13 @@ 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, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = false, } = opt;
+    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());
         }
@@ -50,18 +51,31 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_Memo hit`);
             }
-            return cache.get(ctx).get(cacheKey);
+            value = cache.get(ctx).get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = originalFn.apply(ctx, args);
-            cache.get(ctx).set(cacheKey, value);
+            try {
+                cache.get(ctx).set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.get(ctx).set(cacheKey, err);
+                try {
+                    cache.get(ctx).set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist/decorators/memoFn.js

@@ -10,28 +10,42 @@ const memo_util_1 = require("./memo.util");
  * 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, logArgs = true, logger = console, cacheErrors = 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 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, logArgs)}) memoFn hit`);
             }
-            return cache.get(cacheKey);
+            value = cache.get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = fn.apply(ctx, args);
-            cache.set(cacheKey, value);
+            try {
+                cache.set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.set(cacheKey, err);
+                try {
+                    cache.set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist/decorators/memoFnAsync.js

@@ -9,7 +9,7 @@ const memo_util_1 = require("./memo.util");
  * To support Async functions - use _memoFnAsync
  */
 function _memoFnAsync(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = false, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const fnName = fn.name;
     const memoizedFn = async function (...args) {
@@ -26,6 +26,9 @@ function _memoFnAsync(fn, opt = {}) {
             if (logHit) {
                 logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFnAsync hit`);
             }
+            if (value instanceof Error) {
+                throw value;
+            }
             return value;
         }
         const started = Date.now();

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

@@ -15,7 +15,7 @@ export const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
     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, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheRejections = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheRejections = true, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = async function (...args) {
@@ -39,7 +39,10 @@ export const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_AsyncMemo hit`);
             }
-            return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         // Here we know it's a MISS, let's execute the real method
         const started = Date.now();

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

@@ -34,12 +34,13 @@ 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, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheErrors = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheErrors = true, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
+        let value;
         if (!cache.has(ctx)) {
             cache.set(ctx, cacheFactory());
         }
@@ -47,18 +48,31 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_Memo hit`);
             }
-            return cache.get(ctx).get(cacheKey);
+            value = cache.get(ctx).get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = originalFn.apply(ctx, args);
-            cache.get(ctx).set(cacheKey, value);
+            try {
+                cache.get(ctx).set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.get(ctx).set(cacheKey, err);
+                try {
+                    cache.get(ctx).set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist-esm/decorators/memoFn.js

@@ -7,28 +7,42 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util';
  * 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, logArgs = true, logger = console, cacheErrors = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = true, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     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}(${_getArgsSignature(args, logArgs)}) memoFn hit`);
             }
-            return cache.get(cacheKey);
+            value = cache.get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = fn.apply(ctx, args);
-            cache.set(cacheKey, value);
+            try {
+                cache.set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.set(cacheKey, err);
+                try {
+                    cache.set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist-esm/decorators/memoFnAsync.js

@@ -6,7 +6,7 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util';
  * 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 { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = true, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const fnName = fn.name;
     const memoizedFn = async function (...args) {
@@ -23,6 +23,9 @@ export function _memoFnAsync(fn, opt = {}) {
             if (logHit) {
                 logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync hit`);
             }
+            if (value instanceof Error) {
+                throw value;
+            }
             return value;
         }
         const started = Date.now();

package/package.json

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

package/src/decorators/asyncMemo.decorator.ts

@@ -18,9 +18,12 @@ export interface AsyncMemoOptions {
   cacheKeyFn?: (args: any[]) => any
 
   /**
-   * Set to `true` to cache rejected promises (errors).
+   * Default true.
    *
-   * Default false.
+   * 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
 
@@ -73,7 +76,7 @@ export const _AsyncMemo =
       logger = console,
       cacheFactory = () => new MapMemoCache(),
       cacheKeyFn = jsonMemoSerializer,
-      cacheRejections = false,
+      cacheRejections = true,
     } = opt
 
     const keyStr = String(key)
@@ -110,7 +113,11 @@ export const _AsyncMemo =
           )
         }
 
-        return value instanceof Error ? Promise.reject(value) : Promise.resolve(value)
+        if (value instanceof Error) {
+          throw value
+        }
+
+        return value
       }
 
       // Here we know it's a MISS, let's execute the real method

package/src/decorators/memo.decorator.ts

@@ -18,8 +18,11 @@ export interface MemoOptions {
   cacheKeyFn?: (args: any[]) => any
 
   /**
-   * Defaults to false.
-   * Set to true to cache thrown errors.
+   * 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
 
@@ -89,7 +92,7 @@ export const _Memo =
       logger = console,
       cacheFactory = () => new MapMemoCache(),
       cacheKeyFn = jsonMemoSerializer,
-      cacheErrors = false,
+      cacheErrors = true,
     } = opt
 
     const keyStr = String(key)
@@ -97,8 +100,8 @@ export const _Memo =
 
     descriptor.value = function (this: typeof target, ...args: any[]): any {
       const ctx = this
-
       const cacheKey = cacheKeyFn(args)
+      let value: any
 
       if (!cache.has(ctx)) {
         cache.set(ctx, cacheFactory())
@@ -109,21 +112,34 @@ export const _Memo =
           )
         }
 
-        return cache.get(ctx)!.get(cacheKey)
+        value = cache.get(ctx)!.get(cacheKey)
+
+        if (value instanceof Error) {
+          throw value
+        }
+
+        return value
       }
 
       const started = Date.now()
-      let value: any
 
       try {
         value = originalFn.apply(ctx, args)
 
-        cache.get(ctx)!.set(cacheKey, value)
+        try {
+          cache.get(ctx)!.set(cacheKey, value)
+        } catch (err) {
+          logger.error(err)
+        }
 
         return value
       } catch (err) {
         if (cacheErrors) {
-          cache.get(ctx)!.set(cacheKey, err)
+          try {
+            cache.get(ctx)!.set(cacheKey, err)
+          } catch (err) {
+            logger.error(err)
+          }
         }
 
         throw err

package/src/decorators/memoFn.ts

@@ -21,7 +21,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
     logMiss = false,
     logArgs = true,
     logger = console,
-    cacheErrors = false,
+    cacheErrors = true,
     cacheFactory = () => new MapMemoCache(),
     cacheKeyFn = jsonMemoSerializer,
   } = opt
@@ -32,28 +32,41 @@ export function _memoFn<T extends (...args: any[]) => any>(
   const memoizedFn = function (this: any, ...args: any[]): T {
     const ctx = this
     const cacheKey = cacheKeyFn(args)
+    let value: any
 
     if (cache.has(cacheKey)) {
       if (logHit) {
         logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFn hit`)
       }
 
-      return cache.get(cacheKey)
+      value = cache.get(cacheKey)
+
+      if (value instanceof Error) {
+        throw value
+      }
+
+      return value
     }
 
     const started = Date.now()
 
-    let value: any
-
     try {
       value = fn.apply(ctx, args)
 
-      cache.set(cacheKey, value)
+      try {
+        cache.set(cacheKey, value)
+      } catch (err) {
+        logger.error(err)
+      }
 
       return value
     } catch (err) {
       if (cacheErrors) {
-        cache.set(cacheKey, err)
+        try {
+          cache.set(cacheKey, err)
+        } catch (err) {
+          logger.error(err)
+        }
       }
 
       throw err

package/src/decorators/memoFnAsync.ts

@@ -20,7 +20,7 @@ export function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(
     logMiss = false,
     logArgs = true,
     logger = console,
-    cacheRejections = false,
+    cacheRejections = true,
     cacheFactory = () => new MapMemoCache(),
     cacheKeyFn = jsonMemoSerializer,
   } = opt
@@ -44,6 +44,10 @@ export function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(
         logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync hit`)
       }
 
+      if (value instanceof Error) {
+        throw value
+      }
+
       return value
     }