chain-simple 1.2.2 → 1.3.2

package/built/index.d.ts

@@ -10,6 +10,9 @@ type TConfig = {
     } | ((item: any) => {
         [k: string]: any;
     });
+    getEntityPropList?: string[] | {
+        [k: string]: any;
+    };
 };
 /**
  * @example

package/built/index.js

@@ -36,6 +36,16 @@ 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)) {
+            throw new TypeError('config "getEntityPropList" should be an array or an object');
+        }
+        propsList.push(...((0, sat_utils_1.isObject)(config.getEntityPropList)
+            ? Object.keys(config.getEntityPropList)
+            : config.getEntityPropList));
+    }
     if (!(0, sat_utils_1.canBeProxed)(item)) {
         throw new TypeError('makePropertiesChainable(): first argument should be an entity that can be proxed');
     }
@@ -45,7 +55,15 @@ function makePropertiesChainable(item, config) {
     let proxifiedResult = item;
     const proxed = new Proxy(item, {
         get(_t, p, r) {
-            if (config && config.getEntity === p) {
+            var _a;
+            if (propsList.length && propsList.includes(p)) {
+                const propValue = (_a = Reflect.getOwnPropertyDescriptor(item, p)) === null || _a === void 0 ? void 0 : _a.value;
+                if ((0, sat_utils_1.isFunction)(propValue) || (0, sat_utils_1.isAsyncFunction)(propValue)) {
+                    return item[p].bind(item);
+                }
+                return item[p];
+            }
+            if ((0, sat_utils_1.isObject)(config) && config.getEntity === p) {
                 return item;
             }
             if (p === Symbol.toStringTag) {
@@ -61,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)) {
@@ -83,20 +100,32 @@ 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_);
+                            .catch(e => console.log(e));
+                    }
+                    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

@@ -1,4 +1,4 @@
-import { isObject, isPromise, isFunction, isAsyncFunction, canBeProxed, isUndefined } from 'sat-utils';
+import { isArray, isObject, isPromise, isFunction, isAsyncFunction, canBeProxed, isUndefined } from 'sat-utils';
 
 import { logger } from './logger';
 
@@ -15,6 +15,7 @@ export type TChainable<T extends Record<string, TFn>> = {
 type TConfig = {
   getEntity?: string;
   extendProxed?: (propName) => { [k: string]: any } | ((item: any) => { [k: string]: any });
+  getEntityPropList?: string[] | { [k: string]: any };
 };
 
 /**
@@ -49,6 +50,21 @@ 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');
+    }
+
+    propsList.push(
+      ...(isObject(config.getEntityPropList)
+        ? Object.keys(config.getEntityPropList)
+        : (config.getEntityPropList as string[])),
+    );
+  }
+
   if (!canBeProxed(item)) {
     throw new TypeError('makePropertiesChainable(): first argument should be an entity that can be proxed');
   }
@@ -60,7 +76,15 @@ function makePropertiesChainable(item, config?: TConfig) {
   let proxifiedResult = item;
   const proxed = new Proxy(item, {
     get(_t, p, r) {
-      if (config && config.getEntity === p) {
+      if (propsList.length && propsList.includes(p)) {
+        const propValue = Reflect.getOwnPropertyDescriptor(item, p)?.value;
+        if (isFunction(propValue) || isAsyncFunction(propValue)) {
+          return item[p].bind(item);
+        }
+        return item[p];
+      }
+
+      if (isObject(config) && config.getEntity === p) {
         return item;
       }
 
@@ -79,9 +103,9 @@ function makePropertiesChainable(item, config?: TConfig) {
           return proxifiedResult;
         };
       }
+
       if (
-        p !== 'then' &&
-        p !== 'catch' &&
+        !promiseCallableProps.includes(p) &&
         isUndefined(Reflect.get(item, p, r)) &&
         isObject(config) &&
         isFunction(config.extendProxed)
@@ -103,18 +127,36 @@ 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 () {
+          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_);
               })
-            : item[p].call(item, ...arguments_);
+              .catch(e => console.log(e));
+          } 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.2.2",
+  "version": "1.3.2",
   "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"
   }
 }