chain-simple 0.0.4 → 1.0.2

package/built/index.d.ts

@@ -1,5 +1,43 @@
-declare function wrapObj(item: any, config?: {
+type TFn = (...args: any) => any;
+type TReplaceReturnType<T extends TFn, TNewReturnType> = (...args: Parameters<T>) => TNewReturnType;
+export type TChainable<T extends Record<string, TFn>> = {
+    [K in keyof T]: TReplaceReturnType<T[K], ReturnType<T[K]> & TChainable<T>>;
+};
+/**
+ * @example
+ * const {makePropertiesChainable} = require('chain-simple');
+ * const obj = {
+ *   async method1() {
+ *    return Promise.resolve(1).then(value => {
+ *      console.log('method1', value);
+ *      return value;
+ *    });
+ *   },
+ *   async method2() {
+ *     return Promise.resolve(2).then(value => {
+ *       console.log('method2', value);
+ *       return value;
+ *     });
+ *   },
+ *   async method3() {
+ *     return Promise.resolve(3).then(value => {
+ *       console.log('method3', value);
+ *       return value;
+ *     });
+ *   },
+ * };
+ * const chainableObj = makePropertiesChainable(obj);
+ * obj.method1().method3().then((val) => console.log(val))
+ *
+ *
+ * @param {!object} item
+ * @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 wrapConstruct(constructorFunction: any): any;
-export { wrapConstruct, wrapObj };
+declare function makeConstructorInstancePropertiesChainable(constructorFunction: any, config?: {
+    getEntity: string;
+}): any;
+export { makePropertiesChainable, makeConstructorInstancePropertiesChainable };

package/built/index.js

@@ -1,13 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapObj = exports.wrapConstruct = void 0;
+exports.makeConstructorInstancePropertiesChainable = exports.makePropertiesChainable = void 0;
 const sat_utils_1 = require("sat-utils");
-sat_utils_1.logger.setLogLevel(process.env.LOG_LEVEL);
-function wrapObj(item, config) {
-    if (!sat_utils_1.canBeProxed(item)) {
+const logger_1 = require("./logger");
+logger_1.logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
+/**
+ * @example
+ * const {makePropertiesChainable} = require('chain-simple');
+ * const obj = {
+ *   async method1() {
+ *    return Promise.resolve(1).then(value => {
+ *      console.log('method1', value);
+ *      return value;
+ *    });
+ *   },
+ *   async method2() {
+ *     return Promise.resolve(2).then(value => {
+ *       console.log('method2', value);
+ *       return value;
+ *     });
+ *   },
+ *   async method3() {
+ *     return Promise.resolve(3).then(value => {
+ *       console.log('method3', value);
+ *       return value;
+ *     });
+ *   },
+ * };
+ * const chainableObj = makePropertiesChainable(obj);
+ * obj.method1().method3().then((val) => console.log(val))
+ *
+ *
+ * @param {!object} item
+ * @param {{getEntity: string}} [config] config to describe how to get original not project object
+ * @returns {object} object with chainable properties
+ */
+function makePropertiesChainable(item, config) {
+    if (!(0, sat_utils_1.canBeProxed)(item)) {
         throw new TypeError('first argument should be an entity that can be proxed');
     }
-    if (!sat_utils_1.isUndefined(config) && !sat_utils_1.isObject(config)) {
+    if (!(0, sat_utils_1.isUndefined)(config) && !(0, sat_utils_1.isObject)(config)) {
         throw new TypeError('second argument should be an object');
     }
     let proxifiedResult = item;
@@ -16,7 +48,7 @@ function wrapObj(item, config) {
             if (config && config.getEntity === p) {
                 return item;
             }
-            sat_utils_1.logger.info(p);
+            logger_1.logger.info(p);
             if (p === Symbol.toStringTag) {
                 return proxifiedResult[Symbol.toStringTag];
             }
@@ -26,70 +58,78 @@ function wrapObj(item, config) {
                 };
             }
             if (p === 'toJSON') {
-                sat_utils_1.logger.info('In to JSON');
+                logger_1.logger.info('In to JSON');
                 return function () {
                     return proxifiedResult;
                 };
             }
-            if (!sat_utils_1.isFunction(item[p]) &&
-                !sat_utils_1.isAsyncFunction(item[p]) &&
-                !sat_utils_1.isPromise(proxifiedResult) &&
+            if (!(0, sat_utils_1.isFunction)(item[p]) &&
+                !(0, sat_utils_1.isAsyncFunction)(item[p]) &&
+                !(0, sat_utils_1.isPromise)(proxifiedResult) &&
                 item[p] &&
                 !proxifiedResult[p]) {
-                sat_utils_1.logger.info('In to not function, not async function, resulter is not a promise and target has prop');
+                logger_1.logger.info('In to not function, not async function, resulter is not a promise and target has prop');
                 return item[p];
             }
-            else if ((sat_utils_1.isFunction(item[p]) || sat_utils_1.isAsyncFunction(item[p])) && sat_utils_1.isPromise(proxifiedResult)) {
-                sat_utils_1.logger.info('In to function or async function and resulter is a promise');
+            else if (((0, sat_utils_1.isFunction)(item[p]) || (0, sat_utils_1.isAsyncFunction)(item[p])) && (0, sat_utils_1.isPromise)(proxifiedResult)) {
+                logger_1.logger.info('In to function or async function and resulter is a promise');
                 return function (...arguments_) {
-                    async function handler() {
+                    const handler = async function () {
                         await proxifiedResult;
                         return item[p](...arguments_);
-                    }
+                    };
+                    Object.defineProperty(handler, 'name', { value: p });
                     proxifiedResult = handler();
                     return proxed;
                 };
             }
-            else if (sat_utils_1.isAsyncFunction(item[p]) && !sat_utils_1.isPromise(proxifiedResult)) {
-                sat_utils_1.logger.info('In to async function and resulter is a promise');
+            else if ((0, sat_utils_1.isAsyncFunction)(item[p]) && !(0, sat_utils_1.isPromise)(proxifiedResult)) {
+                logger_1.logger.info('In to async function and resulter is a promise');
                 return function (...arguments_) {
-                    async function handler() {
+                    const handler = async function () {
                         return item[p](...arguments_);
-                    }
+                    };
+                    Object.defineProperty(handler, 'name', { value: p });
                     proxifiedResult = handler();
                     return proxed;
                 };
             }
-            else if (sat_utils_1.isFunction(item[p]) && !sat_utils_1.isPromise(proxifiedResult)) {
-                sat_utils_1.logger.info('In to function and resulter is not a promise');
+            else if ((0, sat_utils_1.isFunction)(item[p]) && !(0, sat_utils_1.isPromise)(proxifiedResult)) {
+                logger_1.logger.info('In to function and resulter is not a promise');
                 return function (...arguments_) {
                     proxifiedResult = item[p](...arguments_);
                     return proxed;
                 };
             }
-            else if ((p === 'then' || p === 'catch') && sat_utils_1.isPromise(proxifiedResult)) {
-                sat_utils_1.logger.info('In then catch');
+            else if ((p === 'then' || p === 'catch') && (0, sat_utils_1.isPromise)(proxifiedResult)) {
+                logger_1.logger.info('In then catch');
                 /** @info logging */
-                sat_utils_1.logger.info('start call promise: ', p);
-                if (!sat_utils_1.isPromise(proxifiedResult)) {
+                logger_1.logger.info('start call promise: ', p);
+                if (!(0, sat_utils_1.isPromise)(proxifiedResult)) {
                     return proxifiedResult;
                 }
                 return async function (onRes, onRej) {
                     const catcher = p === 'catch' ? onRes : onRej;
-                    proxifiedResult = await proxifiedResult.catch(error => ({ error, ____proxed____error: true }));
-                    if (proxifiedResult && proxifiedResult.____proxed____error) {
+                    proxifiedResult = await proxifiedResult.catch(error => {
+                        return { error, ____proxed____error: true };
+                    });
+                    if (proxifiedResult && proxifiedResult.____proxed____error && (0, sat_utils_1.isFunction)(catcher)) {
                         return catcher(proxifiedResult.error);
                     }
+                    if (proxifiedResult && proxifiedResult.____proxed____error) {
+                        const promised = Promise.reject(proxifiedResult.error);
+                        return promised[p].call(promised, onRes, onRej);
+                    }
                     const promised = Promise.resolve(proxifiedResult);
                     return promised[p].call(promised, onRes, onRej);
                 };
             }
             else if (proxifiedResult[p]) {
-                sat_utils_1.logger.info('In resulter has prop');
+                logger_1.logger.info('In resulter has prop');
                 return proxifiedResult[p];
             }
             if (!(p in item) && p in proxifiedResult) {
-                sat_utils_1.logger.info('In target does not have prop but resulter has prop');
+                logger_1.logger.info('In target does not have prop but resulter has prop');
                 return proxifiedResult[p];
             }
         },
@@ -106,15 +146,17 @@ function wrapObj(item, config) {
     });
     return proxed;
 }
-exports.wrapObj = wrapObj;
-const handlerConstructor = {
-    construct(target, args) {
-        const item = new target(...args);
-        return wrapObj(item);
-    },
-};
-function wrapConstruct(constructorFunction) {
-    return new Proxy(constructorFunction, handlerConstructor);
+exports.makePropertiesChainable = makePropertiesChainable;
+function handlerConstructor(config) {
+    return {
+        construct(target, args) {
+            const item = new target(...args);
+            return makePropertiesChainable(item, config);
+        },
+    };
+}
+function makeConstructorInstancePropertiesChainable(constructorFunction, config) {
+    return new Proxy(constructorFunction, handlerConstructor(config));
 }
-exports.wrapConstruct = wrapConstruct;
+exports.makeConstructorInstancePropertiesChainable = makeConstructorInstancePropertiesChainable;
 //# sourceMappingURL=index.js.map

package/built/logger.d.ts

@@ -0,0 +1,10 @@
+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;
+};
+export { logger };

package/built/logger.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const sat_utils_1 = require("sat-utils");
+const logger = (0, sat_utils_1.createLogger)();
+exports.logger = logger;
+//# sourceMappingURL=logger.js.map

package/lib/index.ts

@@ -0,0 +1,182 @@
+import { isObject, isPromise, isFunction, isAsyncFunction, canBeProxed, isUndefined } from 'sat-utils';
+
+import { logger } from './logger';
+
+logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
+
+type TFn = (...args: any) => any;
+
+type TReplaceReturnType<T extends TFn, TNewReturnType> = (...args: Parameters<T>) => TNewReturnType;
+
+export type TChainable<T extends Record<string, TFn>> = {
+  [K in keyof T]: TReplaceReturnType<T[K], ReturnType<T[K]> & TChainable<T>>;
+};
+
+/**
+ * @example
+ * const {makePropertiesChainable} = require('chain-simple');
+ * const obj = {
+ *   async method1() {
+ *    return Promise.resolve(1).then(value => {
+ *      console.log('method1', value);
+ *      return value;
+ *    });
+ *   },
+ *   async method2() {
+ *     return Promise.resolve(2).then(value => {
+ *       console.log('method2', value);
+ *       return value;
+ *     });
+ *   },
+ *   async method3() {
+ *     return Promise.resolve(3).then(value => {
+ *       console.log('method3', value);
+ *       return value;
+ *     });
+ *   },
+ * };
+ * const chainableObj = makePropertiesChainable(obj);
+ * obj.method1().method3().then((val) => console.log(val))
+ *
+ *
+ * @param {!object} item
+ * @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 }) {
+  if (!canBeProxed(item)) {
+    throw new TypeError('first argument should be an entity that can be proxed');
+  }
+
+  if (!isUndefined(config) && !isObject(config)) {
+    throw new TypeError('second argument should be an object');
+  }
+
+  let proxifiedResult = item;
+  const proxed = new Proxy(item, {
+    get(_t, p) {
+      if (config && config.getEntity === p) {
+        return item;
+      }
+
+      logger.info(p);
+      if (p === Symbol.toStringTag) {
+        return proxifiedResult[Symbol.toStringTag];
+      }
+
+      if (p === 'toString') {
+        return function (...args) {
+          return proxifiedResult.toString(...args);
+        };
+      }
+
+      if (p === 'toJSON') {
+        logger.info('In to JSON');
+        return function () {
+          return proxifiedResult;
+        };
+      }
+      if (
+        !isFunction(item[p]) &&
+        !isAsyncFunction(item[p]) &&
+        !isPromise(proxifiedResult) &&
+        item[p] &&
+        !proxifiedResult[p]
+      ) {
+        logger.info('In to not function, not async function, resulter is not a promise and target has prop');
+        return item[p];
+      } else if ((isFunction(item[p]) || isAsyncFunction(item[p])) && isPromise(proxifiedResult)) {
+        logger.info('In to function or async function and resulter is a promise');
+        return function (...arguments_) {
+          const handler = async function () {
+            await proxifiedResult;
+            return item[p](...arguments_);
+          };
+
+          Object.defineProperty(handler, 'name', { value: p });
+
+          proxifiedResult = handler();
+          return proxed;
+        };
+      } else if (isAsyncFunction(item[p]) && !isPromise(proxifiedResult)) {
+        logger.info('In to async function and resulter is a promise');
+        return function (...arguments_) {
+          const handler = async function () {
+            return item[p](...arguments_);
+          };
+
+          Object.defineProperty(handler, 'name', { value: p });
+
+          proxifiedResult = handler();
+          return proxed;
+        };
+      } else if (isFunction(item[p]) && !isPromise(proxifiedResult)) {
+        logger.info('In to function and resulter is not a promise');
+        return function (...arguments_) {
+          proxifiedResult = item[p](...arguments_);
+          return proxed;
+        };
+      } else if ((p === 'then' || p === 'catch') && isPromise(proxifiedResult)) {
+        logger.info('In then catch');
+        /** @info logging */
+        logger.info('start call promise: ', p);
+        if (!isPromise(proxifiedResult)) {
+          return proxifiedResult;
+        }
+        return async function (onRes, onRej) {
+          const catcher = p === 'catch' ? onRes : onRej;
+
+          proxifiedResult = await proxifiedResult.catch(error => {
+            return { error, ____proxed____error: true };
+          });
+
+          if (proxifiedResult && proxifiedResult.____proxed____error && isFunction(catcher)) {
+            return catcher(proxifiedResult.error);
+          }
+
+          if (proxifiedResult && proxifiedResult.____proxed____error) {
+            const promised = Promise.reject(proxifiedResult.error);
+            return promised[p].call(promised, onRes, onRej);
+          }
+
+          const promised = Promise.resolve(proxifiedResult);
+          return promised[p].call(promised, onRes, onRej);
+        };
+      } else if (proxifiedResult[p]) {
+        logger.info('In resulter has prop');
+        return proxifiedResult[p];
+      }
+      if (!(p in item) && p in proxifiedResult) {
+        logger.info('In target does not have prop but resulter has prop');
+        return proxifiedResult[p];
+      }
+    },
+    /** @info basics */
+
+    getPrototypeOf(_t) {
+      return Object.getPrototypeOf(proxifiedResult);
+    },
+    ownKeys(_t) {
+      return Object.getOwnPropertyNames(proxifiedResult);
+    },
+    getOwnPropertyDescriptor(_t, p) {
+      return Object.getOwnPropertyDescriptor(proxifiedResult, p);
+    },
+  });
+  return proxed;
+}
+
+function handlerConstructor(config) {
+  return {
+    construct(target, args) {
+      const item = new target(...args);
+      return makePropertiesChainable(item, config);
+    },
+  };
+}
+
+function makeConstructorInstancePropertiesChainable(constructorFunction, config?: { getEntity: string }) {
+  return new Proxy(constructorFunction, handlerConstructor(config));
+}
+
+export { makePropertiesChainable, makeConstructorInstancePropertiesChainable };

package/lib/logger.ts

@@ -0,0 +1,5 @@
+import { createLogger } from 'sat-utils';
+
+const logger = createLogger();
+
+export { logger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chain-simple",
-  "version": "0.0.4",
+  "version": "1.0.2",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
   "main": "built/index.js",
   "directories": {
@@ -12,8 +12,8 @@
     "test:verbose": "LOG_LEVEL=VERBOSE mocha ./specs/**/*.spec.ts --require ts-node/register --timeout 30000",
     "test:watch": "mocha ./specs/**/*.spec.ts --require ts-node/register --timeout 30000 --watch",
     "lint": "eslint --ext .ts ./",
-    "build": "rm -rf ./built && tsc",
-    "build:prepublish": "rm -rf ./built && tsc --sourceMap false"
+    "tsc": "rm -rf ./built && tsc",
+    "prepublish": "npm run tsc"
   },
   "keywords": [
     "proxy object",
@@ -48,13 +48,13 @@
     "eslint-plugin-mocha": "^8.0.0",
     "mocha": "^8.2.1",
     "prettier": "^2.6.2",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.1.3"
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.3"
   },
   "engines": {
     "node": ">=12.18.3"
   },
   "dependencies": {
-    "sat-utils": "^0.0.42"
+    "sat-utils": "1.5.0"
   }
 }

package/readme.md

@@ -1,14 +1,14 @@
 # chain-simple
 
-
 ![npm downloads](https://img.shields.io/npm/dm/chain-simple.svg?style=flat-square)
 
 The purpose of this library is - build simple and flexible chainable call of the object` methods
 
-```js
-const {wrapObj} = require('chain-simple');
+```ts
+import { makePropertiesChainable } from 'chain-simple';
+import type { TChainable } from 'chain-simple';
 
-const yourObjectWithMethods = {
+const obj = {
   async method1() {
     return Promise.resolve(1).then(value => {
       console.log('method1', value);
@@ -29,12 +29,42 @@ const yourObjectWithMethods = {
   },
 };
 
-const wrappedObj = wrapObj(yourObjectWithMethods);
+const chainableObj: TChainable<typeof obj> = makePropertiesChainable(obj);
+
+chainableObj
+  .method1()
+  .method3()
+  .then(val => console.log(val)); // method1 1 \n method3 3 \n 3
+```
+
+```js
+const { makePropertiesChainable } = require('chain-simple');
+
+const obj = {
+  async method1() {
+    return Promise.resolve(1).then(value => {
+      console.log('method1', value);
+      return value;
+    });
+  },
+  async method2() {
+    return Promise.resolve(2).then(value => {
+      console.log('method2', value);
+      return value;
+    });
+  },
+  async method3() {
+    return Promise.resolve(3).then(value => {
+      console.log('method3', value);
+      return value;
+    });
+  },
+};
 
-testExample();
-async function testExample() {
-  const result = await wrappedObj.method1().method2().method3().method1();
+const chainableObj: TChainable<typeof obj> = makePropertiesChainable(obj);
 
-  console.log(result);
-}
-```
+chainableObj
+  .method1()
+  .method3()
+  .then(val => console.log(val)); // method1 1 \n method3 3 \n 3
+```