@naturalcycles/js-lib 14.83.1 → 14.85.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,16 +19,14 @@ export function _memoFn<T extends (...args: any[]) => any>(
   const {
     logHit = false,
     logMiss = false,
-    noLogArgs = false,
+    logArgs = true,
     logger = console,
-    noCacheRejected = false,
-    noCacheResolved = false,
+    cacheErrors = false,
     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 {
@@ -32,68 +35,34 @@ export function _memoFn<T extends (...args: any[]) => 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)
-
-      if (awaitPromise) {
-        return res instanceof Error ? (Promise.reject(res) as any) : Promise.resolve(res)
-      } else {
-        return res
-      }
+      return cache.get(cacheKey)
     }
 
     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,
-              )})`,
-            )
-          }
+    let value: any
 
-          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,
-              )})`,
-            )
-          }
+      cache.set(cacheKey, value)
 
-          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) {
+        cache.set(cacheKey, 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,87 @@
+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 = false,
+    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`)
+      }
+
+      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/error/assert.ts

@@ -1,4 +1,4 @@
-import { ErrorData, HttpErrorData, _deepEquals, _stringifyAny } from '..'
+import { ErrorData, _deepEquals, _stringifyAny } from '..'
 import { AppError } from './app.error'
 
 /**
@@ -19,7 +19,7 @@ import { AppError } from './app.error'
 export function _assert(
   condition: any, // will be evaluated as Boolean
   message?: string,
-  errorData?: Partial<HttpErrorData>,
+  errorData?: ErrorData,
 ): asserts condition {
   if (!condition) {
     throw new AssertionError(message || 'see stacktrace', {
@@ -39,7 +39,7 @@ export function _assertEquals<T>(
   actual: any,
   expected: T,
   message?: string,
-  errorData?: Partial<HttpErrorData>,
+  errorData?: ErrorData,
 ): asserts actual is T {
   if (actual !== expected) {
     const msg = [
@@ -67,7 +67,7 @@ export function _assertDeepEquals<T>(
   actual: any,
   expected: T,
   message?: string,
-  errorData?: Partial<HttpErrorData>,
+  errorData?: ErrorData,
 ): asserts actual is T {
   if (!_deepEquals(actual, expected)) {
     const msg = [

package/src/error/error.model.ts

@@ -38,6 +38,8 @@ export interface ErrorData {
    */
   fingerprint?: string[]
 
+  httpStatusCode?: number
+
   /**
    * Open-ended.
    */

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'

package/src/promise/pRetry.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny, AnyFunction, CommonLogger } from '..'
+import { _since, _stringifyAny, AnyFunction, AppError, CommonLogger, ErrorData } from '..'
 import { TimeoutError } from './pTimeout'
 
 export interface PRetryOptions {
@@ -91,6 +91,11 @@ export interface PRetryOptions {
    * @experimental
    */
   keepStackTrace?: boolean
+
+  /**
+   * Will be merged with `err.data` object.
+   */
+  errorData?: ErrorData
 }
 
 /**
@@ -139,7 +144,7 @@ export async function pRetry<T>(
   return await new Promise((resolve, reject) => {
     const rejectWithTimeout = () => {
       timedOut = true // to prevent more tries
-      const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`)
+      const err = new TimeoutError(`"${fname}" timed out after ${timeout} ms`, opt.errorData)
       if (fakeError) {
         // keep original stack
         err.stack = fakeError.stack!.replace('Error: RetryError', 'TimeoutError')
@@ -199,6 +204,11 @@ export async function pRetry<T>(
             })
           }
 
+          ;(err as AppError).data = {
+            ...(err as AppError).data,
+            ...opt.errorData,
+          }
+
           reject(err)
         } else {
           // Retry after delay

package/src/promise/pTimeout.ts

@@ -1,4 +1,5 @@
 import { AppError } from '../error/app.error'
+import { ErrorData } from '../error/error.model'
 import { AnyFunction } from '../types'
 
 export class TimeoutError extends AppError {}
@@ -29,6 +30,11 @@ export interface PTimeoutOptions {
    * @experimental
    */
   keepStackTrace?: boolean
+
+  /**
+   * Will be merged with `err.data` object.
+   */
+  errorData?: ErrorData
 }
 
 /**
@@ -63,12 +69,19 @@ export async function pTimeout<T>(promise: Promise<T>, opt: PTimeoutOptions): Pr
           resolve(onTimeout())
         } catch (err: any) {
           if (fakeError) err.stack = fakeError.stack // keep original stack
+          err.data = {
+            ...err.data,
+            ...opt.errorData,
+          }
           reject(err)
         }
         return
       }
 
-      const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`)
+      const err = new TimeoutError(
+        `"${name || 'pTimeout function'}" timed out after ${timeout} ms`,
+        opt.errorData,
+      )
       if (fakeError) err.stack = fakeError.stack // keep original stack
       reject(err)
     }, timeout)