chain-simple 1.3.0 → 1.3.3

package/built/index.js

@@ -36,6 +36,7 @@ logger_1.logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
  * @returns {object} object with chainable properties
  */
 function makePropertiesChainable(item, config) {
+    const promiseCallableProps = ['then', 'catch', 'finally'];
     const propsList = [];
     if ((0, sat_utils_1.isObject)(config) && config.getEntityPropList) {
         if (!(0, sat_utils_1.isObject)(config.getEntityPropList) && !(0, sat_utils_1.isArray)(config.getEntityPropList)) {
@@ -78,8 +79,7 @@ function makePropertiesChainable(item, config) {
                     return proxifiedResult;
                 };
             }
-            if (p !== 'then' &&
-                p !== 'catch' &&
+            if (!promiseCallableProps.includes(p) &&
                 (0, sat_utils_1.isUndefined)(Reflect.get(item, p, r)) &&
                 (0, sat_utils_1.isObject)(config) &&
                 (0, sat_utils_1.isFunction)(config.extendProxed)) {
@@ -100,20 +100,30 @@ function makePropertiesChainable(item, config) {
             }
             const isCallable = (0, sat_utils_1.isFunction)(Reflect.get(item, p, r)) || (0, sat_utils_1.isAsyncFunction)(Reflect.get(item, p, r));
             if (!isCallable && !(0, sat_utils_1.isPromise)(proxifiedResult) && item[p] && !proxifiedResult[p]) {
-                logger_1.logger.info('In to not function, not async function, resulter is not a promise and target has prop');
+                logger_1.logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is not a callable.`);
                 return item[p];
             }
             else if (isCallable) {
+                logger_1.logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is a callable.`);
                 return function (...arguments_) {
-                    proxifiedResult = (0, sat_utils_1.isPromise)(proxifiedResult)
-                        ? proxifiedResult.then(function () {
+                    logger_1.logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is called with args: `, ...arguments);
+                    if ((0, sat_utils_1.isPromise)(proxifiedResult)) {
+                        logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise`);
+                        proxifiedResult = proxifiedResult.then(function (r) {
+                            logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, r);
                             return item[p].call(item, ...arguments_);
-                        })
-                        : item[p].call(item, ...arguments_);
+                        });
+                    }
+                    else {
+                        logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is not a promise`);
+                        logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, proxifiedResult);
+                        proxifiedResult = item[p].call(item, ...arguments_);
+                    }
                     return proxed;
                 };
             }
-            else if ((p === 'then' || p === 'catch') && (0, sat_utils_1.isPromise)(proxifiedResult)) {
+            else if (promiseCallableProps.includes(p) && (0, sat_utils_1.isPromise)(proxifiedResult)) {
+                logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise and next call is a promise method call`);
                 if (!(0, sat_utils_1.isPromise)(proxifiedResult)) {
                     return proxifiedResult;
                 }

package/built/logger.d.ts

@@ -1,10 +1,4 @@
-declare const logger: {
-    logLevel: string;
-    log(...args: any[]): void;
-    info(...args: any[]): void;
-    warn(...args: any[]): void;
-    error(...args: any[]): void;
-    setLogLevel(level: string): void;
-    addCustomLevel(loggerDescription: any, logLevel: string, description: string, consoleOutput: string, descriptionColor: string, messageColor: any): void;
+declare const logger: import("sat-utils").Tlogger & {
+    chainer: (...args: any[]) => void;
 };
 export { logger };

package/built/logger.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const sat_utils_1 = require("sat-utils");
-const logger = (0, sat_utils_1.createLogger)();
+const logger = (0, sat_utils_1.createLogger)().addCustomLevel('chainer', 'CHAIN_LOG', 'CHAIN_LOG', 'info', 'BgBlue', 'BgWhite');
 exports.logger = logger;
 //# sourceMappingURL=logger.js.map

package/lib/index.ts

@@ -50,7 +50,9 @@ type TConfig = {
  * @returns {object} object with chainable properties
  */
 function makePropertiesChainable(item, config?: TConfig) {
+  const promiseCallableProps: any[] = ['then', 'catch', 'finally'];
   const propsList = [];
+
   if (isObject(config) && config.getEntityPropList) {
     if (!isObject(config.getEntityPropList) && !isArray(config.getEntityPropList)) {
       throw new TypeError('config "getEntityPropList" should be an array or an object');
@@ -103,8 +105,7 @@ function makePropertiesChainable(item, config?: TConfig) {
       }
 
       if (
-        p !== 'then' &&
-        p !== 'catch' &&
+        !promiseCallableProps.includes(p) &&
         isUndefined(Reflect.get(item, p, r)) &&
         isObject(config) &&
         isFunction(config.extendProxed)
@@ -126,18 +127,34 @@ function makePropertiesChainable(item, config?: TConfig) {
       const isCallable = isFunction(Reflect.get(item, p, r)) || isAsyncFunction(Reflect.get(item, p, r));
 
       if (!isCallable && !isPromise(proxifiedResult) && item[p] && !proxifiedResult[p]) {
-        logger.info('In to not function, not async function, resulter is not a promise and target has prop');
+        logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is not a callable.`);
+
         return item[p];
       } else if (isCallable) {
+        logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is a callable.`);
+
         return function (...arguments_) {
-          proxifiedResult = isPromise(proxifiedResult)
-            ? proxifiedResult.then(function () {
-                return item[p].call(item, ...arguments_);
-              })
-            : item[p].call(item, ...arguments_);
+          logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is called with args: `, ...arguments);
+
+          if (isPromise(proxifiedResult)) {
+            logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise`);
+            proxifiedResult = proxifiedResult.then(function (r) {
+              logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, r);
+
+              return item[p].call(item, ...arguments_);
+            });
+          } else {
+            logger.chainer(`[CHAIN_SIMPLE]: previous call result is not a promise`);
+            logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, proxifiedResult);
+
+            proxifiedResult = item[p].call(item, ...arguments_);
+          }
+
           return proxed;
         };
-      } else if ((p === 'then' || p === 'catch') && isPromise(proxifiedResult)) {
+      } else if (promiseCallableProps.includes(p) && isPromise(proxifiedResult)) {
+        logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise and next call is a promise method call`);
+
         if (!isPromise(proxifiedResult)) {
           return proxifiedResult;
         }

package/lib/logger.ts

@@ -1,5 +1,5 @@
 import { createLogger } from 'sat-utils';
 
-const logger = createLogger();
+const logger = createLogger().addCustomLevel('chainer', 'CHAIN_LOG', 'CHAIN_LOG', 'info', 'BgBlue', 'BgWhite');
 
 export { logger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chain-simple",
-  "version": "1.3.0",
+  "version": "1.3.3",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
   "main": "built/index.js",
   "directories": {
@@ -55,6 +55,6 @@
     "node": ">=12.18.3"
   },
   "dependencies": {
-    "sat-utils": "1.5.0"
+    "sat-utils": "1.9.0"
   }
 }