@naturalcycles/js-lib 15.98.1 → 15.99.0

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

@@ -31,10 +31,9 @@ export interface AsyncMemoInstance {
 /**
  * Like `@_Memo`, but awaits the method and caches the resolved **value**, not the Promise:
  *
- * - A rejection is NOT cached, so the next call retries the method.
- *   `@_Memo` caches the Promise as-is, so it serves a rejection to every caller until the key is evicted.
  * - The cache is async (`AsyncMemoCache`), so it can be backed by e.g Redis or Datastore
- *   and survive a process restart.
+ *   and survive a process restart. That's the reason to use it over `@_Memo`.
+ * - A rejection is NOT cached, so the next call retries the method (same as `@_Memo`).
  * - Parallel calls with the same key share one in-flight Promise, also while the cache lookup is pending.
  *
  * Cache errors (`get`/`set`) are logged and treated as a cache miss, they never fail the method.

package/dist/decorators/asyncMemo.decorator.js

@@ -6,10 +6,9 @@ import { jsonMemoSerializer, MapAsyncMemoCache } from './memo.util.js';
 /**
  * Like `@_Memo`, but awaits the method and caches the resolved **value**, not the Promise:
  *
- * - A rejection is NOT cached, so the next call retries the method.
- *   `@_Memo` caches the Promise as-is, so it serves a rejection to every caller until the key is evicted.
  * - The cache is async (`AsyncMemoCache`), so it can be backed by e.g Redis or Datastore
- *   and survive a process restart.
+ *   and survive a process restart. That's the reason to use it over `@_Memo`.
+ * - A rejection is NOT cached, so the next call retries the method (same as `@_Memo`).
  * - Parallel calls with the same key share one in-flight Promise, also while the cache lookup is pending.
  *
  * Cache errors (`get`/`set`) are logged and treated as a cache miss, they never fail the method.

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

@@ -35,9 +35,10 @@ export interface MemoInstance {
  * So, error-throwing functions will be called multiple times.
  * Therefor, if the origin function can possibly throw - it should try to be idempotent.
  *
- * For an async method it's the returned **Promise** that is cached, so a rejected Promise IS cached:
- * every caller gets the same rejection until the key is evicted from the cache.
- * Use `@_AsyncMemo` to cache only the resolved value and retry the method on rejection.
+ * For an async method it's the returned **Promise** that is cached, so parallel calls with the same key
+ * share one in-flight Promise. A rejected Promise is evicted from the cache, so the next call retries
+ * the method, same as for a thrown Error.
+ * Use `@_AsyncMemo` for an async-backed cache (e.g Redis), which stores the resolved value instead.
  *
  * 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".

package/dist/decorators/memo.decorator.js

@@ -12,9 +12,10 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
  * So, error-throwing functions will be called multiple times.
  * Therefor, if the origin function can possibly throw - it should try to be idempotent.
  *
- * For an async method it's the returned **Promise** that is cached, so a rejected Promise IS cached:
- * every caller gets the same rejection until the key is evicted from the cache.
- * Use `@_AsyncMemo` to cache only the resolved value and retry the method on rejection.
+ * For an async method it's the returned **Promise** that is cached, so parallel calls with the same key
+ * share one in-flight Promise. A rejected Promise is evicted from the cache, so the next call retries
+ * the method, same as for a thrown Error.
+ * Use `@_AsyncMemo` for an async-backed cache (e.g Redis), which stores the resolved value instead.
  *
  * 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".
@@ -61,6 +62,20 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
         catch (err) {
             logger.error({ err });
         }
+        if (value instanceof Promise) {
+            // Don't cache a rejection: evict it, so the next call retries the method.
+            // The derived Promise is handled, so it adds no unhandled rejection.
+            value.catch(() => {
+                try {
+                    // Only if the key still holds this very Promise (and not a newer one, cached after an eviction)
+                    if (cache.get(cacheKey) === value)
+                        cache.delete(cacheKey);
+                }
+                catch (err) {
+                    logger.error({ err });
+                }
+            });
+        }
         return value;
     };
     _objectAssign(descriptor.value, {

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

@@ -19,6 +19,7 @@ export interface MemoCache<KEY = any, VALUE = any> {
      */
     get: (k: KEY) => VALUE;
     set: (k: KEY, v: VALUE, opt?: MemoCacheOptions) => void;
+    delete: (k: KEY) => void;
     /**
      * Clear is only called when `_getMemoCache().clear()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
@@ -33,6 +34,7 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
      */
     get: (k: KEY) => Promise<VALUE | typeof MISS>;
     set: (k: KEY, v: VALUE, opt?: MemoCacheOptions) => Promise<void>;
+    delete: (k: KEY) => Promise<void>;
     /**
      * Clear is only called when `_getAsyncMemo().clear()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
@@ -44,17 +46,18 @@ export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<K
     has(k: KEY): boolean;
     get(k: KEY): VALUE;
     set(k: KEY, v: VALUE): void;
+    delete(k: KEY): void;
     clear(): void;
 }
 /**
  * Implementation of AsyncMemoCache backed by a synchronous Map.
  * The default cache of `@_AsyncMemo`: in-memory, never expires.
- * Use it over `@_Memo` when a rejection should not be cached (e.g an `init()` that may fail and
- * should be retried). For an **async** backed cache (Redis, Datastore) use another implementation.
+ * For an **async** backed cache (Redis, Datastore) use another implementation.
  */
 export declare class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
     private m;
     get(k: KEY): Promise<VALUE | typeof MISS>;
     set(k: KEY, v: VALUE): Promise<void>;
+    delete(k: KEY): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/decorators/memo.util.js

@@ -63,6 +63,9 @@ export class MapMemoCache {
     set(k, v) {
         this.m.set(k, v);
     }
+    delete(k) {
+        this.m.delete(k);
+    }
     clear() {
         this.m.clear();
     }
@@ -70,8 +73,7 @@ export class MapMemoCache {
 /**
  * Implementation of AsyncMemoCache backed by a synchronous Map.
  * The default cache of `@_AsyncMemo`: in-memory, never expires.
- * Use it over `@_Memo` when a rejection should not be cached (e.g an `init()` that may fail and
- * should be retried). For an **async** backed cache (Redis, Datastore) use another implementation.
+ * For an **async** backed cache (Redis, Datastore) use another implementation.
  */
 export class MapAsyncMemoCache {
     m = new Map();
@@ -85,6 +87,9 @@ export class MapAsyncMemoCache {
     async set(k, v) {
         this.m.set(k, v);
     }
+    async delete(k) {
+        this.m.delete(k);
+    }
     async clear() {
         this.m.clear();
     }

package/dist/decorators/memoized.js

@@ -21,6 +21,20 @@ export function _memoized(fn, opt = {}) {
         catch (err) {
             logger.error({ err });
         }
+        if (value instanceof Promise) {
+            // Don't cache a rejection: evict it, so the next call retries the function.
+            // The derived Promise is handled, so it adds no unhandled rejection.
+            value.catch(() => {
+                try {
+                    // Only if the key still holds this very Promise (and not a newer one, cached after an eviction)
+                    if (cache.get(cacheKey) === value)
+                        cache.delete(cacheKey);
+                }
+                catch (err) {
+                    logger.error({ err });
+                }
+            });
+        }
         return value;
     };
     Object.assign(memoizedFn, { cache });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.98.1",
+  "version": "15.99.0",
   "dependencies": {
     "tslib": "^2"
   },

package/src/decorators/asyncMemo.decorator.ts

@@ -43,10 +43,9 @@ export interface AsyncMemoInstance {
 /**
  * Like `@_Memo`, but awaits the method and caches the resolved **value**, not the Promise:
  *
- * - A rejection is NOT cached, so the next call retries the method.
- *   `@_Memo` caches the Promise as-is, so it serves a rejection to every caller until the key is evicted.
  * - The cache is async (`AsyncMemoCache`), so it can be backed by e.g Redis or Datastore
- *   and survive a process restart.
+ *   and survive a process restart. That's the reason to use it over `@_Memo`.
+ * - A rejection is NOT cached, so the next call retries the method (same as `@_Memo`).
  * - Parallel calls with the same key share one in-flight Promise, also while the cache lookup is pending.
  *
  * Cache errors (`get`/`set`) are logged and treated as a cache miss, they never fail the method.

package/src/decorators/memo.decorator.ts

@@ -47,9 +47,10 @@ export interface MemoInstance {
  * So, error-throwing functions will be called multiple times.
  * Therefor, if the origin function can possibly throw - it should try to be idempotent.
  *
- * For an async method it's the returned **Promise** that is cached, so a rejected Promise IS cached:
- * every caller gets the same rejection until the key is evicted from the cache.
- * Use `@_AsyncMemo` to cache only the resolved value and retry the method on rejection.
+ * For an async method it's the returned **Promise** that is cached, so parallel calls with the same key
+ * share one in-flight Promise. A rejected Promise is evicted from the cache, so the next call retries
+ * the method, same as for a thrown Error.
+ * Use `@_AsyncMemo` for an async-backed cache (e.g Redis), which stores the resolved value instead.
  *
  * 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".
@@ -115,6 +116,19 @@ export const _Memo =
         logger.error({ err })
       }
 
+      if (value instanceof Promise) {
+        // Don't cache a rejection: evict it, so the next call retries the method.
+        // The derived Promise is handled, so it adds no unhandled rejection.
+        value.catch(() => {
+          try {
+            // Only if the key still holds this very Promise (and not a newer one, cached after an eviction)
+            if (cache.get(cacheKey) === value) cache.delete(cacheKey)
+          } catch (err) {
+            logger.error({ err })
+          }
+        })
+      }
+
       return value
     } as any
 

package/src/decorators/memo.util.ts

@@ -28,7 +28,7 @@ export interface MemoCache<KEY = any, VALUE = any> {
    */
   get: (k: KEY) => VALUE
   set: (k: KEY, v: VALUE, opt?: MemoCacheOptions) => void
-
+  delete: (k: KEY) => void
   /**
    * Clear is only called when `_getMemoCache().clear()` is called.
    * Otherwise the Cache is "persistent" (never cleared).
@@ -46,6 +46,7 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
    */
   get: (k: KEY) => Promise<VALUE | typeof MISS>
   set: (k: KEY, v: VALUE, opt?: MemoCacheOptions) => Promise<void>
+  delete: (k: KEY) => Promise<void>
 
   /**
    * Clear is only called when `_getAsyncMemo().clear()` is called.
@@ -115,6 +116,10 @@ export class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALU
     this.m.set(k, v)
   }
 
+  delete(k: KEY): void {
+    this.m.delete(k)
+  }
+
   clear(): void {
     this.m.clear()
   }
@@ -123,8 +128,7 @@ export class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALU
 /**
  * Implementation of AsyncMemoCache backed by a synchronous Map.
  * The default cache of `@_AsyncMemo`: in-memory, never expires.
- * Use it over `@_Memo` when a rejection should not be cached (e.g an `init()` that may fail and
- * should be retried). For an **async** backed cache (Redis, Datastore) use another implementation.
+ * For an **async** backed cache (Redis, Datastore) use another implementation.
  */
 export class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
   private m = new Map<KEY, VALUE>()
@@ -140,6 +144,10 @@ export class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache
     this.m.set(k, v)
   }
 
+  async delete(k: KEY): Promise<void> {
+    this.m.delete(k)
+  }
+
   async clear(): Promise<void> {
     this.m.clear()
   }

package/src/decorators/memoized.ts

@@ -41,6 +41,19 @@ export function _memoized<FN extends AnyFunction>(
       logger.error({ err })
     }
 
+    if (value instanceof Promise) {
+      // Don't cache a rejection: evict it, so the next call retries the function.
+      // The derived Promise is handled, so it adds no unhandled rejection.
+      value.catch(() => {
+        try {
+          // Only if the key still holds this very Promise (and not a newer one, cached after an eviction)
+          if (cache.get(cacheKey) === value) cache.delete(cacheKey)
+        } catch (err) {
+          logger.error({ err })
+        }
+      })
+    }
+
     return value
   }