@naturalcycles/js-lib 14.84.1 → 14.86.0

package/src/decorators/memoFn.ts

@@ -7,6 +7,11 @@ 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 function _memoFn<T extends (...args: any[]) => any>(
   fn: T,
   opt: MemoOptions = {},
@@ -14,86 +19,63 @@ export function _memoFn<T extends (...args: any[]) => any>(
   const {
     logHit = false,
     logMiss = false,
-    noLogArgs = false,
+    logArgs = true,
     logger = console,
-    noCacheRejected = false,
-    noCacheResolved = false,
+    cacheErrors = true,
     cacheFactory = () => new MapMemoCache(),
     cacheKeyFn = jsonMemoSerializer,
   } = opt
 
   const cache = cacheFactory()
-  const awaitPromise = Boolean(noCacheRejected || noCacheResolved)
   const fnName = fn.name
 
   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, noLogArgs)}) memoFn hit`)
+        logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFn hit`)
       }
 
-      const res = cache.get(cacheKey)
+      value = cache.get(cacheKey)
 
-      if (awaitPromise) {
-        return res instanceof Error ? (Promise.reject(res) as any) : Promise.resolve(res)
-      } else {
-        return res
+      if (value instanceof Error) {
+        throw value
       }
+
+      return value
     }
 
     const started = Date.now()
 
-    const res: any = fn.apply(ctx, args)
-
-    if (awaitPromise) {
-      return (res as Promise<any>)
-        .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)
-          }
+    try {
+      value = fn.apply(ctx, args)
 
-          return res
-        })
-        .catch(err => {
-          // console.log('REJECTED', err)
-          if (logMiss) {
-            logger.log(
-              `${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss rejected (${_since(
-                started,
-              )})`,
-            )
-          }
+      try {
+        cache.set(cacheKey, value)
+      } catch (err) {
+        logger.error(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))
-          }
+      return value
+    } catch (err) {
+      if (cacheErrors) {
+        try {
+          cache.set(cacheKey, err)
+        } catch (err) {
+          logger.error(err)
+        }
+      }
 
-          throw err
-        }) as any
-    } else {
+      throw err
+    } finally {
       if (logMiss) {
         logger.log(
-          `${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss (${_since(started)})`,
+          `${fnName}(${_getArgsSignature(args, logArgs)}) memoFn miss (${_since(started)})`,
         )
       }
-
-      cache.set(cacheKey, res)
-      return res
     }
   }
 

package/src/decorators/memoFnAsync.ts

@@ -0,0 +1,91 @@
+import { _since } from '../time/time.util'
+import { AsyncMemoOptions } from './asyncMemo.decorator'
+import { _getArgsSignature } from './decorator.util'
+import { AsyncMemoCache, jsonMemoSerializer, MapMemoCache } from './memo.util'
+
+export interface MemoizedAsyncFunction {
+  cache: AsyncMemoCache
+}
+
+/**
+ * Only supports Sync functions.
+ * To support Async functions - use _memoFnAsync
+ */
+export function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(
+  fn: T,
+  opt: AsyncMemoOptions = {},
+): T & MemoizedAsyncFunction {
+  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 (this: any, ...args: any[]): Promise<any> {
+    const ctx = this
+    const cacheKey = cacheKeyFn(args)
+    let value: any
+
+    try {
+      value = await cache.get(cacheKey)
+    } catch (err) {
+      logger.error(err)
+    }
+
+    if (value !== undefined) {
+      if (logHit) {
+        logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync hit`)
+      }
+
+      if (value instanceof Error) {
+        throw value
+      }
+
+      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 as T & MemoizedAsyncFunction
+}

package/src/decorators/memoSimple.decorator.ts

@@ -18,7 +18,7 @@ import { jsonMemoSerializer, MapMemoCache, MemoCache } from './memo.util'
 export interface MemoOpts {
   logHit?: boolean
   logMiss?: boolean
-  noLogArgs?: boolean
+  logArgs?: boolean
   logger?: CommonLogger
 }
 
@@ -57,7 +57,7 @@ export const memoSimple =
    */
     const cache: MemoCache = 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)
 
@@ -67,7 +67,7 @@ export const memoSimple =
 
       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)
       }
@@ -78,7 +78,7 @@ export const memoSimple =
 
       if (logMiss) {
         logger.log(
-          `${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${
+          `${methodSignature}(${_getArgsSignature(args, logArgs)}) @memo miss (${
             Date.now() - d
           } ms)`,
         )

package/src/index.ts

@@ -15,6 +15,7 @@ export * from './decorators/memo.decorator'
 export * from './decorators/asyncMemo.decorator'
 import { MemoCache, AsyncMemoCache } from './decorators/memo.util'
 export * from './decorators/memoFn'
+export * from './decorators/memoFnAsync'
 export * from './decorators/retry.decorator'
 export * from './decorators/timeout.decorator'
 export * from './error/app.error'
@@ -118,6 +119,7 @@ import {
   SavedDBEntity,
   StringMap,
   UnixTimestamp,
+  Integer,
   ValueOf,
   ValuesOf,
   AbortableMapper,
@@ -203,6 +205,7 @@ export type {
   ConditionalExcept,
   Class,
   UnixTimestamp,
+  Integer,
   BaseDBEntity,
   SavedDBEntity,
   Saved,

package/src/types.ts

@@ -166,6 +166,11 @@ export type IsoDateTime = string
  */
 export type UnixTimestamp = number
 
+/**
+ * Same as `number`, but with semantic meaning that it's an Integer.
+ */
+export type Integer = number
+
 /**
  * Base interface for any Entity that was saved to DB.
  */