@naturalcycles/js-lib 14.64.0 → 14.65.0

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

@@ -1,3 +1,4 @@
+import { CommonLogger } from '..';
 /**
  * $r - result
  *
@@ -36,6 +37,10 @@ export interface LogMethodOptions {
      * Overrides `logResult`.
      */
     logResultFn?: LogResultFn;
+    /**
+     * Defaults to `console`
+     */
+    logger?: CommonLogger;
 }
 /**
  * Console-logs when method had started, when it finished, time taken and if error happened.

package/dist/decorators/logMethod.decorator.js

@@ -21,11 +21,11 @@ const decorator_util_1 = require("./decorator.util");
 function _LogMethod(opt = {}) {
     return (target, key, descriptor) => {
         if (typeof descriptor.value !== 'function') {
-            throw new TypeError('@LogMillis can be applied only to methods');
+            throw new TypeError('@_LogMethod can be applied only to methods');
         }
         const originalFn = descriptor.value;
         const keyStr = String(key);
-        const { avg, noLogArgs, logStart, logResult, noLogResultLength } = opt;
+        const { avg, noLogArgs, logStart, logResult, noLogResultLength, logger = console } = opt;
         let { logResultFn } = opt;
         if (!logResultFn) {
             if (logResult) {
@@ -46,29 +46,29 @@ function _LogMethod(opt = {}) {
             const argsStr = (0, decorator_util_1._getArgsSignature)(args, noLogArgs);
             const callSignature = `${methodSignature}(${argsStr}) #${++count}`;
             if (logStart)
-                console.log(`>> ${callSignature}`);
+                logger.log(`>> ${callSignature}`);
             try {
                 const res = originalFn.apply(ctx, args);
                 if (res && typeof res.then === 'function') {
                     // Result is a Promise, will wait for resolution or rejection
                     return res
                         .then((r) => {
-                        logFinished(callSignature, started, sma, logResultFn, r);
+                        logFinished(logger, callSignature, started, sma, logResultFn, r);
                         return r;
                     })
                         .catch((err) => {
-                        logFinished(callSignature, started, sma, logResultFn, undefined, err);
+                        logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
                         return Promise.reject(err);
                     });
                 }
                 else {
                     // not a Promise
-                    logFinished(callSignature, started, sma, logResultFn, res);
+                    logFinished(logger, callSignature, started, sma, logResultFn, res);
                     return res;
                 }
             }
             catch (err) {
-                logFinished(callSignature, started, sma, logResultFn, undefined, err);
+                logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
                 throw err; // rethrow
             }
         };
@@ -76,7 +76,7 @@ function _LogMethod(opt = {}) {
     };
 }
 exports._LogMethod = _LogMethod;
-function logFinished(callSignature, started, sma, logResultFn, res, err) {
+function logFinished(logger, callSignature, started, sma, logResultFn, res, err) {
     const millis = Date.now() - started;
     const t = ['<<', callSignature, 'took', (0, time_util_1._ms)(millis)];
     if (sma) {
@@ -88,5 +88,5 @@ function logFinished(callSignature, started, sma, logResultFn, res, err) {
     else if (logResultFn) {
         t.push(...logResultFn(res));
     }
-    console.log(t.filter(Boolean).join(' '));
+    logger.log(t.filter(Boolean).join(' '));
 }

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

@@ -1,11 +1,22 @@
+import { CommonLogger } from '../log/commonLogger';
 import { MemoCache } from './memo.util';
 export interface MemoOptions {
+    /**
+     * Default to false
+     */
     logHit?: boolean;
+    /**
+     * Default to false
+     */
     logMiss?: boolean;
     /**
      * Skip logging method arguments.
      */
     noLogArgs?: boolean;
+    /**
+     * Default to `console`
+     */
+    logger?: CommonLogger;
     /**
      * Provide a custom implementation of MemoCache.
      * Function that creates an instance of `MemoCache`.

package/dist/decorators/memo.decorator.js

@@ -33,7 +33,7 @@ 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, logMiss, noLogArgs, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, noCacheRejected, noCacheResolved, } = opt;
+    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
     const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
@@ -45,7 +45,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
         }
         else if (cache.get(ctx).has(cacheKey)) {
             if (logHit) {
-                console.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memoInstance hit`);
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo hit`);
             }
             const res = cache.get(ctx).get(cacheKey);
             if (awaitPromise) {
@@ -62,7 +62,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
                 .then(res => {
                 // console.log('RESOLVED', res)
                 if (logMiss) {
-                    console.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo miss resolved (${(0, time_util_1._since)(started)})`);
+                    logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo miss resolved (${(0, time_util_1._since)(started)})`);
                 }
                 if (!noCacheResolved) {
                     cache.get(ctx).set(cacheKey, res);
@@ -72,7 +72,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
                 .catch(err => {
                 // console.log('REJECTED', err)
                 if (logMiss) {
-                    console.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo miss rejected (${(0, time_util_1._since)(started)})`);
+                    logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo miss rejected (${(0, time_util_1._since)(started)})`);
                 }
                 if (!noCacheRejected) {
                     // We put it to cache as raw Error, not Promise.reject(err)
@@ -85,14 +85,14 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
         }
         else {
             if (logMiss) {
-                console.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo miss (${(0, time_util_1._since)(started)})`);
+                logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @_Memo miss (${(0, time_util_1._since)(started)})`);
             }
             cache.get(ctx).set(cacheKey, res);
             return res;
         }
     };
     descriptor.value.dropCache = () => {
-        console.log(`${methodSignature} @memo.dropCache()`);
+        logger.log(`${methodSignature} @_Memo.dropCache()`);
         cache.forEach(memoCache => memoCache.clear());
         cache.clear();
     };

package/dist/decorators/memoFn.js

@@ -5,7 +5,7 @@ const time_util_1 = require("../time/time.util");
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 function _memoFn(fn, opt = {}) {
-    const { logHit, logMiss, noLogArgs, noCacheRejected, noCacheResolved, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, noCacheRejected = false, noCacheResolved = false, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
     const fnName = fn.name;
@@ -14,7 +14,7 @@ function _memoFn(fn, opt = {}) {
         const cacheKey = cacheKeyFn(args);
         if (cache.has(cacheKey)) {
             if (logHit) {
-                console.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn hit`);
+                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn hit`);
             }
             const res = cache.get(cacheKey);
             if (awaitPromise) {
@@ -31,7 +31,7 @@ function _memoFn(fn, opt = {}) {
                 .then(res => {
                 // console.log('RESOLVED', res)
                 if (logMiss) {
-                    console.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss resolved (${(0, time_util_1._since)(started)})`);
+                    logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss resolved (${(0, time_util_1._since)(started)})`);
                 }
                 if (!noCacheResolved) {
                     cache.set(cacheKey, res);
@@ -41,7 +41,7 @@ function _memoFn(fn, opt = {}) {
                 .catch(err => {
                 // console.log('REJECTED', err)
                 if (logMiss) {
-                    console.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss rejected (${(0, time_util_1._since)(started)})`);
+                    logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss rejected (${(0, time_util_1._since)(started)})`);
                 }
                 if (!noCacheRejected) {
                     // We put it to cache as raw Error, not Promise.reject(err)
@@ -54,7 +54,7 @@ function _memoFn(fn, opt = {}) {
         }
         else {
             if (logMiss) {
-                console.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo miss (${(0, time_util_1._since)(started)})`);
+                logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) memoFn miss (${(0, time_util_1._since)(started)})`);
             }
             cache.set(cacheKey, res);
             return res;

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

@@ -1,7 +1,9 @@
+import { CommonLogger } from '../log/commonLogger';
 export interface MemoOpts {
     logHit?: boolean;
     logMiss?: boolean;
     noLogArgs?: boolean;
+    logger?: CommonLogger;
 }
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"

package/dist/decorators/memoSimple.decorator.js

@@ -6,12 +6,6 @@
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.memoSimple = void 0;
-/*
-Optimized for 0 arguments (using SingleValueCache).
-Optimized for 1 primitive argument (skips JSON.stringify).
-Otherwise resorts to JSON.stringify.
-Benchmark shows similar perf for ObjectCache and MapCache.
- */
 const decorator_util_1 = require("./decorator.util");
 const memo_util_1 = require("./memo.util");
 // memoSimple decorator is NOT exported. Only used in benchmarks currently
@@ -43,7 +37,7 @@ const memoSimple = (opt = {}) => (target, key, descriptor) => {
   }
    */
     const cache = new memo_util_1.MapMemoCache();
-    const { logHit, logMiss, noLogArgs } = opt;
+    const { logHit, logMiss, noLogArgs, logger = console } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
@@ -51,20 +45,20 @@ const memoSimple = (opt = {}) => (target, key, descriptor) => {
         const cacheKey = (0, memo_util_1.jsonMemoSerializer)(args);
         if (cache.has(cacheKey)) {
             if (logHit) {
-                console.log(`${methodSignature}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo hit`);
+                logger.log(`${methodSignature}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo hit`);
             }
             return cache.get(cacheKey);
         }
         const d = Date.now();
         const res = originalFn.apply(ctx, args);
         if (logMiss) {
-            console.log(`${methodSignature}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo miss (${Date.now() - d} ms)`);
+            logger.log(`${methodSignature}(${(0, decorator_util_1._getArgsSignature)(args, noLogArgs)}) @memo miss (${Date.now() - d} ms)`);
         }
         cache.set(cacheKey, res);
         return res;
     };
     descriptor.value.dropCache = () => {
-        console.log(`${methodSignature} @memo.dropCache()`);
+        logger.log(`${methodSignature} @memo.dropCache()`);
         cache.clear();
     };
     return descriptor;

package/dist/error/error.model.d.ts

@@ -41,7 +41,6 @@ export interface HttpErrorData extends ErrorData {
      *
      * GET /api/some-endpoint
      */
-    endpoint?: string;
     /**
      * Set to true when the error was thrown after response headers were sent.
      */

package/dist/error/tryCatch.d.ts

@@ -1,3 +1,4 @@
+import { CommonLogger } from '../index';
 import { AnyFunction } from '../types';
 export interface TryCatchOptions {
     /**
@@ -13,6 +14,10 @@ export interface TryCatchOptions {
      * @default true
      */
     logError?: boolean;
+    /**
+     * Default to `console`
+     */
+    logger?: CommonLogger;
 }
 /**
  * Decorates a function with "try/catch", so it'll never reject/throw.

package/dist/error/tryCatch.js

@@ -11,23 +11,20 @@ const index_1 = require("../index");
  * @experimental
  */
 function _tryCatch(fn, opt = {}) {
-    const { onError, logError, logSuccess } = {
-        logError: true,
-        ...opt,
-    };
+    const { onError, logError = true, logSuccess = false, logger = console } = opt;
     const fname = fn.name || 'anonymous';
     return async function (...args) {
         const started = Date.now();
         try {
             const r = await fn.apply(this, args);
             if (logSuccess) {
-                console.log(`tryCatch.${fname} succeeded in ${(0, index_1._since)(started)}`);
+                logger.log(`tryCatch.${fname} succeeded in ${(0, index_1._since)(started)}`);
             }
             return r;
         }
         catch (err) {
             if (logError) {
-                console.warn(`tryCatch.${fname} error in ${(0, index_1._since)(started)}:\n${(0, index_1._stringifyAny)(err, {
+                logger.warn(`tryCatch.${fname} error in ${(0, index_1._since)(started)}:\n${(0, index_1._stringifyAny)(err, {
                     includeErrorData: true,
                 })}`);
             }

package/dist/promise/pRetry.d.ts

@@ -1,3 +1,4 @@
+import { CommonLogger } from '..';
 export interface PRetryOptions {
     /**
      * How many attempts to try.
@@ -52,6 +53,10 @@ export interface PRetryOptions {
      * @default false
      */
     logNone?: boolean;
+    /**
+     * Default to `console`
+     */
+    logger?: CommonLogger;
 }
 /**
  * Returns a Function (!), enhanced with retry capabilities.

package/dist/promise/pRetry.js

@@ -8,7 +8,7 @@ const __1 = require("..");
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
 function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate } = opt;
+    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, } = opt;
     let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
     if (opt.logAll) {
         logFirstAttempt = logRetries = logFailures = true;
@@ -26,17 +26,17 @@ function pRetry(fn, opt = {}) {
                 try {
                     attempt++;
                     if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-                        console.log(`${fname} attempt #${attempt}...`);
+                        logger.log(`${fname} attempt #${attempt}...`);
                     }
                     const r = await fn.apply(this, args);
                     if (logSuccess) {
-                        console.log(`${fname} attempt #${attempt} succeeded in ${(0, __1._since)(started)}`);
+                        logger.log(`${fname} attempt #${attempt} succeeded in ${(0, __1._since)(started)}`);
                     }
                     resolve(r);
                 }
                 catch (err) {
                     if (logFailures) {
-                        console.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:\n${(0, __1._stringifyAny)(err, {
+                        logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:\n${(0, __1._stringifyAny)(err, {
                             includeErrorData: true,
                         })}`);
                     }

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

@@ -18,11 +18,11 @@ import { _getArgsSignature, _getMethodSignature } from './decorator.util';
 export function _LogMethod(opt = {}) {
     return (target, key, descriptor) => {
         if (typeof descriptor.value !== 'function') {
-            throw new TypeError('@LogMillis can be applied only to methods');
+            throw new TypeError('@_LogMethod can be applied only to methods');
         }
         const originalFn = descriptor.value;
         const keyStr = String(key);
-        const { avg, noLogArgs, logStart, logResult, noLogResultLength } = opt;
+        const { avg, noLogArgs, logStart, logResult, noLogResultLength, logger = console } = opt;
         let { logResultFn } = opt;
         if (!logResultFn) {
             if (logResult) {
@@ -43,36 +43,36 @@ export function _LogMethod(opt = {}) {
             const argsStr = _getArgsSignature(args, noLogArgs);
             const callSignature = `${methodSignature}(${argsStr}) #${++count}`;
             if (logStart)
-                console.log(`>> ${callSignature}`);
+                logger.log(`>> ${callSignature}`);
             try {
                 const res = originalFn.apply(ctx, args);
                 if (res && typeof res.then === 'function') {
                     // Result is a Promise, will wait for resolution or rejection
                     return res
                         .then((r) => {
-                        logFinished(callSignature, started, sma, logResultFn, r);
+                        logFinished(logger, callSignature, started, sma, logResultFn, r);
                         return r;
                     })
                         .catch((err) => {
-                        logFinished(callSignature, started, sma, logResultFn, undefined, err);
+                        logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
                         return Promise.reject(err);
                     });
                 }
                 else {
                     // not a Promise
-                    logFinished(callSignature, started, sma, logResultFn, res);
+                    logFinished(logger, callSignature, started, sma, logResultFn, res);
                     return res;
                 }
             }
             catch (err) {
-                logFinished(callSignature, started, sma, logResultFn, undefined, err);
+                logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
                 throw err; // rethrow
             }
         };
         return descriptor;
     };
 }
-function logFinished(callSignature, started, sma, logResultFn, res, err) {
+function logFinished(logger, callSignature, started, sma, logResultFn, res, err) {
     const millis = Date.now() - started;
     const t = ['<<', callSignature, 'took', _ms(millis)];
     if (sma) {
@@ -84,5 +84,5 @@ function logFinished(callSignature, started, sma, logResultFn, res, err) {
     else if (logResultFn) {
         t.push(...logResultFn(res));
     }
-    console.log(t.filter(Boolean).join(' '));
+    logger.log(t.filter(Boolean).join(' '));
 }

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

@@ -30,7 +30,7 @@ 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, logMiss, noLogArgs, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, noCacheRejected, noCacheResolved, } = opt;
+    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, noCacheRejected = false, noCacheResolved = false, } = opt;
     const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
@@ -42,7 +42,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
         }
         else if (cache.get(ctx).has(cacheKey)) {
             if (logHit) {
-                console.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @memoInstance hit`);
+                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo hit`);
             }
             const res = cache.get(ctx).get(cacheKey);
             if (awaitPromise) {
@@ -59,7 +59,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
                 .then(res => {
                 // console.log('RESOLVED', res)
                 if (logMiss) {
-                    console.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @memo miss resolved (${_since(started)})`);
+                    logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo miss resolved (${_since(started)})`);
                 }
                 if (!noCacheResolved) {
                     cache.get(ctx).set(cacheKey, res);
@@ -69,7 +69,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
                 .catch(err => {
                 // console.log('REJECTED', err)
                 if (logMiss) {
-                    console.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @memo miss rejected (${_since(started)})`);
+                    logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo miss rejected (${_since(started)})`);
                 }
                 if (!noCacheRejected) {
                     // We put it to cache as raw Error, not Promise.reject(err)
@@ -82,14 +82,14 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
         }
         else {
             if (logMiss) {
-                console.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${_since(started)})`);
+                logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo miss (${_since(started)})`);
             }
             cache.get(ctx).set(cacheKey, res);
             return res;
         }
     };
     descriptor.value.dropCache = () => {
-        console.log(`${methodSignature} @memo.dropCache()`);
+        logger.log(`${methodSignature} @_Memo.dropCache()`);
         cache.forEach(memoCache => memoCache.clear());
         cache.clear();
     };

package/dist-esm/decorators/memoFn.js

@@ -2,7 +2,7 @@ import { _since } from '../time/time.util';
 import { _getArgsSignature } from './decorator.util';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util';
 export function _memoFn(fn, opt = {}) {
-    const { logHit, logMiss, noLogArgs, noCacheRejected, noCacheResolved, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, noLogArgs = false, logger = console, noCacheRejected = false, noCacheResolved = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const awaitPromise = Boolean(noCacheRejected || noCacheResolved);
     const fnName = fn.name;
@@ -11,7 +11,7 @@ export function _memoFn(fn, opt = {}) {
         const cacheKey = cacheKeyFn(args);
         if (cache.has(cacheKey)) {
             if (logHit) {
-                console.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn hit`);
+                logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn hit`);
             }
             const res = cache.get(cacheKey);
             if (awaitPromise) {
@@ -28,7 +28,7 @@ export function _memoFn(fn, opt = {}) {
                 .then(res => {
                 // console.log('RESOLVED', res)
                 if (logMiss) {
-                    console.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss resolved (${_since(started)})`);
+                    logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss resolved (${_since(started)})`);
                 }
                 if (!noCacheResolved) {
                     cache.set(cacheKey, res);
@@ -38,7 +38,7 @@ export function _memoFn(fn, opt = {}) {
                 .catch(err => {
                 // console.log('REJECTED', err)
                 if (logMiss) {
-                    console.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss rejected (${_since(started)})`);
+                    logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss rejected (${_since(started)})`);
                 }
                 if (!noCacheRejected) {
                     // We put it to cache as raw Error, not Promise.reject(err)
@@ -51,7 +51,7 @@ export function _memoFn(fn, opt = {}) {
         }
         else {
             if (logMiss) {
-                console.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${_since(started)})`);
+                logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss (${_since(started)})`);
             }
             cache.set(cacheKey, res);
             return res;

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

@@ -3,12 +3,6 @@
 // http://decodize.com/blog/2012/08/27/javascript-memoization-caching-results-for-better-performance/
 // http://inlehmansterms.net/2015/03/01/javascript-memoization/
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
-/*
-Optimized for 0 arguments (using SingleValueCache).
-Optimized for 1 primitive argument (skips JSON.stringify).
-Otherwise resorts to JSON.stringify.
-Benchmark shows similar perf for ObjectCache and MapCache.
- */
 import { _getArgsSignature, _getTargetMethodSignature } from './decorator.util';
 import { jsonMemoSerializer, MapMemoCache } from './memo.util';
 // memoSimple decorator is NOT exported. Only used in benchmarks currently
@@ -40,7 +34,7 @@ export const memoSimple = (opt = {}) => (target, key, descriptor) => {
   }
    */
     const cache = new MapMemoCache();
-    const { logHit, logMiss, noLogArgs } = opt;
+    const { logHit, logMiss, noLogArgs, logger = console } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
@@ -48,20 +42,20 @@ export const memoSimple = (opt = {}) => (target, key, descriptor) => {
         const cacheKey = jsonMemoSerializer(args);
         if (cache.has(cacheKey)) {
             if (logHit) {
-                console.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo hit`);
+                logger.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo hit`);
             }
             return cache.get(cacheKey);
         }
         const d = Date.now();
         const res = originalFn.apply(ctx, args);
         if (logMiss) {
-            console.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${Date.now() - d} ms)`);
+            logger.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${Date.now() - d} ms)`);
         }
         cache.set(cacheKey, res);
         return res;
     };
     descriptor.value.dropCache = () => {
-        console.log(`${methodSignature} @memo.dropCache()`);
+        logger.log(`${methodSignature} @memo.dropCache()`);
         cache.clear();
     };
     return descriptor;

package/dist-esm/error/tryCatch.js

@@ -8,20 +8,20 @@ import { _since, _stringifyAny } from '../index';
  * @experimental
  */
 export function _tryCatch(fn, opt = {}) {
-    const { onError, logError, logSuccess } = Object.assign({ logError: true }, opt);
+    const { onError, logError = true, logSuccess = false, logger = console } = opt;
     const fname = fn.name || 'anonymous';
     return async function (...args) {
         const started = Date.now();
         try {
             const r = await fn.apply(this, args);
             if (logSuccess) {
-                console.log(`tryCatch.${fname} succeeded in ${_since(started)}`);
+                logger.log(`tryCatch.${fname} succeeded in ${_since(started)}`);
             }
             return r;
         }
         catch (err) {
             if (logError) {
-                console.warn(`tryCatch.${fname} error in ${_since(started)}:\n${_stringifyAny(err, {
+                logger.warn(`tryCatch.${fname} error in ${_since(started)}:\n${_stringifyAny(err, {
                     includeErrorData: true,
                 })}`);
             }

package/dist-esm/promise/pRetry.js

@@ -5,7 +5,7 @@ import { _since, _stringifyAny } from '..';
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate } = opt;
+    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, } = opt;
     let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
     if (opt.logAll) {
         logFirstAttempt = logRetries = logFailures = true;
@@ -23,17 +23,17 @@ export function pRetry(fn, opt = {}) {
                 try {
                     attempt++;
                     if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-                        console.log(`${fname} attempt #${attempt}...`);
+                        logger.log(`${fname} attempt #${attempt}...`);
                     }
                     const r = await fn.apply(this, args);
                     if (logSuccess) {
-                        console.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`);
+                        logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`);
                     }
                     resolve(r);
                 }
                 catch (err) {
                     if (logFailures) {
-                        console.warn(`${fname} attempt #${attempt} error in ${_since(started)}:\n${_stringifyAny(err, {
+                        logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:\n${_stringifyAny(err, {
                             includeErrorData: true,
                         })}`);
                     }

package/package.json

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

package/src/decorators/logMethod.decorator.ts

@@ -1,4 +1,4 @@
-import { SimpleMovingAverage, _stringifyAny } from '..'
+import { SimpleMovingAverage, _stringifyAny, CommonLogger } from '..'
 import { _ms } from '../time/time.util'
 import { _getArgsSignature, _getMethodSignature } from './decorator.util'
 
@@ -46,6 +46,11 @@ export interface LogMethodOptions {
    * Overrides `logResult`.
    */
   logResultFn?: LogResultFn
+
+  /**
+   * Defaults to `console`
+   */
+  logger?: CommonLogger
 }
 
 /**
@@ -65,13 +70,13 @@ export interface LogMethodOptions {
 export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
   return (target, key, descriptor) => {
     if (typeof descriptor.value !== 'function') {
-      throw new TypeError('@LogMillis can be applied only to methods')
+      throw new TypeError('@_LogMethod can be applied only to methods')
     }
 
     const originalFn = descriptor.value
     const keyStr = String(key)
 
-    const { avg, noLogArgs, logStart, logResult, noLogResultLength } = opt
+    const { avg, noLogArgs, logStart, logResult, noLogResultLength, logger = console } = opt
     let { logResultFn } = opt
     if (!logResultFn) {
       if (logResult) {
@@ -93,7 +98,7 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
       const methodSignature = _getMethodSignature(ctx, keyStr)
       const argsStr = _getArgsSignature(args, noLogArgs)
       const callSignature = `${methodSignature}(${argsStr}) #${++count}`
-      if (logStart) console.log(`>> ${callSignature}`)
+      if (logStart) logger.log(`>> ${callSignature}`)
 
       try {
         const res = originalFn.apply(ctx, args)
@@ -102,20 +107,20 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
           // Result is a Promise, will wait for resolution or rejection
           return res
             .then((r: any) => {
-              logFinished(callSignature, started, sma, logResultFn, r)
+              logFinished(logger, callSignature, started, sma, logResultFn, r)
               return r
             })
             .catch((err: any) => {
-              logFinished(callSignature, started, sma, logResultFn, undefined, err)
+              logFinished(logger, callSignature, started, sma, logResultFn, undefined, err)
               return Promise.reject(err)
             })
         } else {
           // not a Promise
-          logFinished(callSignature, started, sma, logResultFn, res)
+          logFinished(logger, callSignature, started, sma, logResultFn, res)
           return res
         }
       } catch (err) {
-        logFinished(callSignature, started, sma, logResultFn, undefined, err)
+        logFinished(logger, callSignature, started, sma, logResultFn, undefined, err)
         throw err // rethrow
       }
     } as any
@@ -125,6 +130,7 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
 }
 
 function logFinished(
+  logger: CommonLogger,
   callSignature: string,
   started: number,
   sma?: SimpleMovingAverage,
@@ -146,5 +152,5 @@ function logFinished(
     t.push(...logResultFn(res))
   }
 
-  console.log(t.filter(Boolean).join(' '))
+  logger.log(t.filter(Boolean).join(' '))
 }

package/src/decorators/memo.decorator.ts

@@ -4,13 +4,20 @@
 // http://inlehmansterms.net/2015/03/01/javascript-memoization/
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
 
+import { CommonLogger } from '../log/commonLogger'
 import { _since } from '../time/time.util'
 import { AnyObject } from '../types'
 import { _getArgsSignature, _getMethodSignature, _getTargetMethodSignature } from './decorator.util'
 import { jsonMemoSerializer, MapMemoCache, MemoCache } from './memo.util'
 
 export interface MemoOptions {
+  /**
+   * Default to false
+   */
   logHit?: boolean
+  /**
+   * Default to false
+   */
   logMiss?: boolean
 
   /**
@@ -18,6 +25,11 @@ export interface MemoOptions {
    */
   noLogArgs?: boolean
 
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
+
   /**
    * Provide a custom implementation of MemoCache.
    * Function that creates an instance of `MemoCache`.
@@ -73,13 +85,14 @@ export const _Memo =
     const cache = new Map<AnyObject, MemoCache>()
 
     const {
-      logHit,
-      logMiss,
-      noLogArgs,
+      logHit = false,
+      logMiss = false,
+      noLogArgs = false,
+      logger = console,
       cacheFactory = () => new MapMemoCache(),
       cacheKeyFn = jsonMemoSerializer,
-      noCacheRejected,
-      noCacheResolved,
+      noCacheRejected = false,
+      noCacheResolved = false,
     } = opt
 
     const awaitPromise = Boolean(noCacheRejected || noCacheResolved)
@@ -95,11 +108,8 @@ export const _Memo =
         cache.set(ctx, cacheFactory())
       } else if (cache.get(ctx)!.has(cacheKey)) {
         if (logHit) {
-          console.log(
-            `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
-              args,
-              noLogArgs,
-            )}) @memoInstance hit`,
+          logger.log(
+            `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, noLogArgs)}) @_Memo hit`,
           )
         }
 
@@ -121,11 +131,11 @@ export const _Memo =
           .then(res => {
             // console.log('RESOLVED', res)
             if (logMiss) {
-              console.log(
+              logger.log(
                 `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
                   args,
                   noLogArgs,
-                )}) @memo miss resolved (${_since(started)})`,
+                )}) @_Memo miss resolved (${_since(started)})`,
               )
             }
 
@@ -138,11 +148,11 @@ export const _Memo =
           .catch(err => {
             // console.log('REJECTED', err)
             if (logMiss) {
-              console.log(
+              logger.log(
                 `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
                   args,
                   noLogArgs,
-                )}) @memo miss rejected (${_since(started)})`,
+                )}) @_Memo miss rejected (${_since(started)})`,
               )
             }
 
@@ -157,11 +167,11 @@ export const _Memo =
           })
       } else {
         if (logMiss) {
-          console.log(
+          logger.log(
             `${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(
               args,
               noLogArgs,
-            )}) @memo miss (${_since(started)})`,
+            )}) @_Memo miss (${_since(started)})`,
           )
         }
 
@@ -170,7 +180,7 @@ export const _Memo =
       }
     } as any
     ;(descriptor.value as any).dropCache = () => {
-      console.log(`${methodSignature} @memo.dropCache()`)
+      logger.log(`${methodSignature} @_Memo.dropCache()`)
       cache.forEach(memoCache => memoCache.clear())
       cache.clear()
     }

package/src/decorators/memoFn.ts

@@ -12,11 +12,12 @@ export function _memoFn<T extends (...args: any[]) => any>(
   opt: MemoOptions = {},
 ): T & MemoizedFunction {
   const {
-    logHit,
-    logMiss,
-    noLogArgs,
-    noCacheRejected,
-    noCacheResolved,
+    logHit = false,
+    logMiss = false,
+    noLogArgs = false,
+    logger = console,
+    noCacheRejected = false,
+    noCacheResolved = false,
     cacheFactory = () => new MapMemoCache(),
     cacheKeyFn = jsonMemoSerializer,
   } = opt
@@ -31,7 +32,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
 
     if (cache.has(cacheKey)) {
       if (logHit) {
-        console.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn hit`)
+        logger.log(`${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn hit`)
       }
 
       const res = cache.get(cacheKey)
@@ -52,7 +53,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
         .then(res => {
           // console.log('RESOLVED', res)
           if (logMiss) {
-            console.log(
+            logger.log(
               `${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss resolved (${_since(
                 started,
               )})`,
@@ -68,7 +69,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
         .catch(err => {
           // console.log('REJECTED', err)
           if (logMiss) {
-            console.log(
+            logger.log(
               `${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss rejected (${_since(
                 started,
               )})`,
@@ -86,8 +87,8 @@ export function _memoFn<T extends (...args: any[]) => any>(
         }) as any
     } else {
       if (logMiss) {
-        console.log(
-          `${fnName}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${_since(started)})`,
+        logger.log(
+          `${fnName}(${_getArgsSignature(args, noLogArgs)}) memoFn miss (${_since(started)})`,
         )
       }
 

package/src/decorators/memoSimple.decorator.ts

@@ -11,6 +11,7 @@ Otherwise resorts to JSON.stringify.
 Benchmark shows similar perf for ObjectCache and MapCache.
  */
 
+import { CommonLogger } from '../log/commonLogger'
 import { _getArgsSignature, _getTargetMethodSignature } from './decorator.util'
 import { jsonMemoSerializer, MapMemoCache, MemoCache } from './memo.util'
 
@@ -18,6 +19,7 @@ export interface MemoOpts {
   logHit?: boolean
   logMiss?: boolean
   noLogArgs?: boolean
+  logger?: CommonLogger
 }
 
 // memoSimple decorator is NOT exported. Only used in benchmarks currently
@@ -55,7 +57,7 @@ export const memoSimple =
    */
     const cache: MemoCache = new MapMemoCache()
 
-    const { logHit, logMiss, noLogArgs } = opt
+    const { logHit, logMiss, noLogArgs, logger = console } = opt
     const keyStr = String(key)
     const methodSignature = _getTargetMethodSignature(target, keyStr)
 
@@ -65,7 +67,7 @@ export const memoSimple =
 
       if (cache.has(cacheKey)) {
         if (logHit) {
-          console.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo hit`)
+          logger.log(`${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo hit`)
         }
         return cache.get(cacheKey)
       }
@@ -75,7 +77,7 @@ export const memoSimple =
       const res: any = originalFn.apply(ctx, args)
 
       if (logMiss) {
-        console.log(
+        logger.log(
           `${methodSignature}(${_getArgsSignature(args, noLogArgs)}) @memo miss (${
             Date.now() - d
           } ms)`,
@@ -87,7 +89,7 @@ export const memoSimple =
       return res
     } as any
     ;(descriptor.value as any).dropCache = () => {
-      console.log(`${methodSignature} @memo.dropCache()`)
+      logger.log(`${methodSignature} @memo.dropCache()`)
       cache.clear()
     }
 

package/src/error/error.model.ts

@@ -48,7 +48,7 @@ export interface HttpErrorData extends ErrorData {
    *
    * GET /api/some-endpoint
    */
-  endpoint?: string
+  // endpoint?: string
 
   /**
    * Set to true when the error was thrown after response headers were sent.

package/src/error/tryCatch.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny } from '../index'
+import { _since, _stringifyAny, CommonLogger } from '../index'
 import { AnyFunction } from '../types'
 
 export interface TryCatchOptions {
@@ -17,6 +17,11 @@ export interface TryCatchOptions {
    * @default true
    */
   logError?: boolean
+
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
 }
 
 /**
@@ -28,10 +33,7 @@ export interface TryCatchOptions {
  * @experimental
  */
 export function _tryCatch<T extends AnyFunction>(fn: T, opt: TryCatchOptions = {}): T {
-  const { onError, logError, logSuccess } = {
-    logError: true,
-    ...opt,
-  }
+  const { onError, logError = true, logSuccess = false, logger = console } = opt
 
   const fname = fn.name || 'anonymous'
 
@@ -42,13 +44,13 @@ export function _tryCatch<T extends AnyFunction>(fn: T, opt: TryCatchOptions = {
       const r = await fn.apply(this, args)
 
       if (logSuccess) {
-        console.log(`tryCatch.${fname} succeeded in ${_since(started)}`)
+        logger.log(`tryCatch.${fname} succeeded in ${_since(started)}`)
       }
 
       return r
     } catch (err) {
       if (logError) {
-        console.warn(
+        logger.warn(
           `tryCatch.${fname} error in ${_since(started)}:\n${_stringifyAny(err, {
             includeErrorData: true,
           })}`,

package/src/promise/pRetry.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny } from '..'
+import { _since, _stringifyAny, CommonLogger } from '..'
 
 export interface PRetryOptions {
   /**
@@ -63,6 +63,11 @@ export interface PRetryOptions {
    * @default false
    */
   logNone?: boolean
+
+  /**
+   * Default to `console`
+   */
+  logger?: CommonLogger
 }
 
 /**
@@ -71,7 +76,13 @@ export interface PRetryOptions {
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
-  const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate } = opt
+  const {
+    maxAttempts = 4,
+    delay: initialDelay = 1000,
+    delayMultiplier = 2,
+    predicate,
+    logger = console,
+  } = opt
 
   let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt
 
@@ -95,18 +106,18 @@ export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
         try {
           attempt++
           if ((attempt === 1 && logFirstAttempt) || (attempt > 1 && logRetries)) {
-            console.log(`${fname} attempt #${attempt}...`)
+            logger.log(`${fname} attempt #${attempt}...`)
           }
 
           const r = await fn.apply(this, args)
 
           if (logSuccess) {
-            console.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`)
+            logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`)
           }
           resolve(r)
         } catch (err) {
           if (logFailures) {
-            console.warn(
+            logger.warn(
               `${fname} attempt #${attempt} error in ${_since(started)}:\n${_stringifyAny(err, {
                 includeErrorData: true,
               })}`,