chain-simple 1.1.0 → 1.2.1

package/built/index.d.ts

@@ -3,6 +3,12 @@ type TReplaceReturnType<T extends TFn, TNewReturnType> = (...args: Parameters<T>
 export type TChainable<T extends Record<string, TFn>> = {
     [K in keyof T]: TReplaceReturnType<T[K], ReturnType<T[K]> & TChainable<T>>;
 };
+type TConfig = {
+    getEntity?: string;
+    extendProxed?: (propName: any) => {
+        [k: string]: any;
+    };
+};
 /**
  * @example
  * const {makePropertiesChainable} = require('chain-simple');
@@ -34,10 +40,6 @@ export type TChainable<T extends Record<string, TFn>> = {
  * @param {{getEntity: string}} [config] config to describe how to get original not project object
  * @returns {object} object with chainable properties
  */
-declare function makePropertiesChainable(item: any, config?: {
-    getEntity: string;
-}): any;
-declare function makeConstructorInstancePropertiesChainable(constructorFunction: any, config?: {
-    getEntity: string;
-}): any;
+declare function makePropertiesChainable(item: any, config?: TConfig): any;
+declare function makeConstructorInstancePropertiesChainable(constructorFunction: any, config?: TConfig): any;
 export { makePropertiesChainable, makeConstructorInstancePropertiesChainable };

package/built/index.js

@@ -61,6 +61,19 @@ function makePropertiesChainable(item, config) {
                     return proxifiedResult;
                 };
             }
+            if (p !== 'then' &&
+                p !== 'catch' &&
+                (0, sat_utils_1.isUndefined)(Reflect.get(item, p, r)) &&
+                (0, sat_utils_1.isObject)(config) &&
+                (0, sat_utils_1.isFunction)(config.extendProxed)) {
+                try {
+                    const extension = config.extendProxed(p);
+                    Object.assign(item, extension);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
             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');
@@ -81,7 +94,9 @@ function makePropertiesChainable(item, config) {
                     return proxifiedResult;
                 }
                 return function (onRes, onRej) {
-                    return proxifiedResult[p].call(proxifiedResult, onRes, onRej);
+                    const promised = proxifiedResult;
+                    proxifiedResult = item;
+                    return promised[p].call(promised, onRes, onRej);
                 };
             }
             else if (proxifiedResult[p]) {

package/lib/index.ts

@@ -12,6 +12,8 @@ export type TChainable<T extends Record<string, TFn>> = {
   [K in keyof T]: TReplaceReturnType<T[K], ReturnType<T[K]> & TChainable<T>>;
 };
 
+type TConfig = { getEntity?: string; extendProxed?: (propName) => { [k: string]: any } };
+
 /**
  * @example
  * const {makePropertiesChainable} = require('chain-simple');
@@ -43,7 +45,7 @@ export type TChainable<T extends Record<string, TFn>> = {
  * @param {{getEntity: string}} [config] config to describe how to get original not project object
  * @returns {object} object with chainable properties
  */
-function makePropertiesChainable(item, config?: { getEntity: string }) {
+function makePropertiesChainable(item, config?: TConfig) {
   if (!canBeProxed(item)) {
     throw new TypeError('makePropertiesChainable(): first argument should be an entity that can be proxed');
   }
@@ -74,6 +76,20 @@ function makePropertiesChainable(item, config?: { getEntity: string }) {
           return proxifiedResult;
         };
       }
+      if (
+        p !== 'then' &&
+        p !== 'catch' &&
+        isUndefined(Reflect.get(item, p, r)) &&
+        isObject(config) &&
+        isFunction(config.extendProxed)
+      ) {
+        try {
+          const extension = config.extendProxed(p);
+          Object.assign(item, extension);
+        } catch (error) {
+          console.error(error);
+        }
+      }
 
       const isCallable = isFunction(Reflect.get(item, p, r)) || isAsyncFunction(Reflect.get(item, p, r));
 
@@ -95,7 +111,10 @@ function makePropertiesChainable(item, config?: { getEntity: string }) {
         }
 
         return function (onRes, onRej) {
-          return proxifiedResult[p].call(proxifiedResult, onRes, onRej);
+          const promised = proxifiedResult;
+          proxifiedResult = item;
+
+          return promised[p].call(promised, onRes, onRej);
         };
       } else if (proxifiedResult[p]) {
         return proxifiedResult[p];
@@ -128,7 +147,7 @@ function handlerConstructor(config) {
   };
 }
 
-function makeConstructorInstancePropertiesChainable(constructorFunction, config?: { getEntity: string }) {
+function makeConstructorInstancePropertiesChainable(constructorFunction, config?: TConfig) {
   return new Proxy(constructorFunction, handlerConstructor(config));
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chain-simple",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
   "main": "built/index.js",
   "directories": {