@naturalcycles/js-lib 14.84.2 → 14.87.0

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.87.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/decorators/asyncMemo.decorator.ts

@@ -1,25 +1,54 @@
+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
+
+  /**
+   * 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.
+   *
+   * Defaults to true.
+   */
+  logArgs?: boolean
+
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
+}
 
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
@@ -29,7 +58,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 +67,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 = true,
     } = opt
 
     const keyStr = String(key)
@@ -68,13 +96,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,12 +108,16 @@ export const _AsyncMemo =
           logger.log(
             `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
               args,
-              noLogArgs,
+              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
@@ -100,25 +126,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 +158,7 @@ export const _AsyncMemo =
           logger.log(
             `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
               args,
-              noLogArgs,
+              logArgs,
             )}) @_AsyncMemo miss (${_since(started)})`,
           )
         }
@@ -136,7 +167,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/createPromiseDecorator.ts

@@ -5,9 +5,9 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
 
   /**
    * 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.
@@ -73,77 +73,71 @@ export function _createPromiseDecorator<RES = any, PARAMS = any>(
       // console.log(`@${cfg.decoratorName} called inside function`)
       const started = Date.now()
 
-      return (
-        Promise.resolve()
-          // Before function
-          .then(() => {
-            // console.log(`@${cfg.decoratorName} Before`)
-            if (cfg.beforeFn) {
-              return cfg.beforeFn({
-                decoratorParams,
-                args,
-                key,
-                target,
-                decoratorName,
-                started,
-              })
-            }
+      try {
+        // Before function
+        // console.log(`@${cfg.decoratorName} Before`)
+        if (cfg.beforeFn) {
+          await cfg.beforeFn({
+            decoratorParams,
+            args,
+            key,
+            target,
+            decoratorName,
+            started,
           })
-          // Original function
-          .then(() => originalMethod.apply(this, args))
-          .then(res => {
-            // console.log(`${cfg.decoratorName} After`)
-            const resp: PromiseDecoratorResp<PARAMS> = {
-              decoratorParams,
-              args,
-              key,
-              target,
-              decoratorName,
-              started,
-            }
-
-            if (cfg.thenFn) {
-              res = cfg.thenFn({
-                ...resp,
-                res,
-              })
-            }
-
-            cfg.finallyFn?.(resp)
-
-            return res
+        }
+
+        // Original function
+        let res = await originalMethod.apply(this, args)
+
+        // console.log(`${cfg.decoratorName} After`)
+        const resp: PromiseDecoratorResp<PARAMS> = {
+          decoratorParams,
+          args,
+          key,
+          target,
+          decoratorName,
+          started,
+        }
+
+        if (cfg.thenFn) {
+          res = cfg.thenFn({
+            ...resp,
+            res,
           })
-          .catch(err => {
-            console.error(`@${decoratorName} ${methodSignature} catch:`, err)
-
-            const resp: PromiseDecoratorResp<PARAMS> = {
-              decoratorParams,
-              args,
-              key,
-              target,
-              decoratorName,
-              started,
-            }
-
-            let handled = false
-
-            if (cfg.catchFn) {
-              cfg.catchFn({
-                ...resp,
-                err,
-              })
-              handled = true
-            }
-
-            cfg.finallyFn?.(resp)
-
-            if (!handled) {
-              throw err // rethrow
-            }
+        }
+
+        cfg.finallyFn?.(resp)
+
+        return res
+      } catch (err) {
+        console.error(`@${decoratorName} ${methodSignature} catch:`, err)
+
+        const resp: PromiseDecoratorResp<PARAMS> = {
+          decoratorParams,
+          args,
+          key,
+          target,
+          decoratorName,
+          started,
+        }
+
+        let handled = false
+
+        if (cfg.catchFn) {
+          cfg.catchFn({
+            ...resp,
+            err,
           })
-        // es2018 only
-        // .finally(() => {})
-      )
+          handled = true
+        }
+
+        cfg.finallyFn?.(resp)
+
+        if (!handled) {
+          throw err // rethrow
+        }
+      }
     }
 
     return pd

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 => {

package/src/decorators/logMethod.decorator.ts

@@ -16,14 +16,16 @@ 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.
@@ -74,12 +76,19 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
     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`] : [])
       }
     }
@@ -94,7 +103,7 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
       // 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}`)