chain-simple 1.1.1 → 1.2.2

package/built/index.d.ts

@@ -3,6 +3,14 @@ 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;
+    } | ((item: any) => {
+        [k: string]: any;
+    });
+};
 /**
  * @example
  * const {makePropertiesChainable} = require('chain-simple');
@@ -34,10 +42,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,26 @@ 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);
+                    if ((0, sat_utils_1.isObject)(extension)) {
+                        Object.assign(item, extension);
+                    }
+                    else if ((0, sat_utils_1.isFunction)(extension)) {
+                        // @ts-ignore
+                        const result = extension(item);
+                        Object.assign(item, result);
+                    }
+                }
+                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');

package/lib/index.ts

@@ -12,6 +12,11 @@ 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 } | ((item: any) => { [k: string]: any });
+};
+
 /**
  * @example
  * const {makePropertiesChainable} = require('chain-simple');
@@ -43,7 +48,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 +79,26 @@ 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);
+          if (isObject(extension)) {
+            Object.assign(item, extension);
+          } else if (isFunction(extension)) {
+            // @ts-ignore
+            const result = extension(item);
+            Object.assign(item, result);
+          }
+        } catch (error) {
+          console.error(error);
+        }
+      }
 
       const isCallable = isFunction(Reflect.get(item, p, r)) || isAsyncFunction(Reflect.get(item, p, r));
 
@@ -131,7 +156,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.1",
+  "version": "1.2.2",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
   "main": "built/index.js",
   "directories": {