chain-simple 0.0.3 → 0.0.4

package/.eslintrc.js

@@ -1,75 +1,38 @@
 module.exports = {
-  'env': {
-    'browser': true,
-    'commonjs': true,
-    'es6': true,
-    'node': true,
-    'mocha': true
+  plugins: ['sonarjs', 'promise', 'unicorn', 'prettier', 'no-only-tests'],
+  parser: '@typescript-eslint/parser',
+  rules: {
+    'jsdoc/valid-types': 'off',
+    'jsdoc/check-property-names': 'off',
+    'no-await-in-loop': 'off',
+    'unicorn/no-null': 'off',
+    'jsdoc/no-undefined-types': 'off',
+    'unicorn/explicit-length-check': 'off',
+    'no-restricted-syntax': 'off',
+    'func-names': 'off',
+    'no-plusplus': 'off',
+    'unicorn/prevent-abbreviations': 'off',
+    'unicorn/no-reduce': 'off',
+    'no-unused-expressions': 'off',
+    'unicorn/prefer-node-protocol': 'off',
+    'unicorn/import-style': 'off',
+    'no-useless-constructor': 'off',
+    'unicorn/prefer-module': 'off',
+    'unicorn/prefer-spread': 'off',
+    'unicorn/consistent-destructuring': 'off',
+    'import/no-unresolved': 'off',
+    'unicorn/no-this-assignment': 'off',
+    'unicorn/no-array-for-each': 'off',
+    'default-case': 'off',
+    'sonarjs/no-duplicate-string': 'off',
+    'unicorn/no-array-reduce': 'off',
+    'unicorn/filename-case': 'off',
+    'unicorn/no-abusive-eslint-disable': 'off',
+    'no-only-tests/no-only-tests': 'error',
+    'no-console': 'error',
   },
-  'globals': {
-    'describe:': 'readonly'
+  extends: ['plugin:sonarjs/recommended', 'plugin:unicorn/recommended', 'prettier', 'plugin:prettier/recommended'],
+  globals: {
+    browser: 'readonly',
   },
-  'parser': '@typescript-eslint/parser',
-  'plugins': [
-    '@typescript-eslint',
-    'mocha',
-    'chai-expect',
-    'chai-friendly'
-  ],
-  'parserOptions': {
-    'ecmaVersion': 2018
-  },
-  'rules': {
-    '@typescript-eslint/naming-convention': [
-      'error',
-      {
-        'selector': 'typeParameter',
-        'format': ['PascalCase'],
-        'prefix': ['T']
-      }
-    ],
-    'no-undefined': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
-    '@typescript-eslint/no-use-before-define': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/camelcase': 'off',
-    '@typescript-eslint/ban-ts-ignore': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/no-var-requires': 'off',
-    'no-console': 2,
-    'arrow-parens': 2,
-    'require-atomic-updates': 'off',
-    'eol-last': ['error', 'always'],
-    'max-len': ['error', {'code': 140, 'tabWidth': 2}],
-    'prefer-const': ['error', {'destructuring': 'any', 'ignoreReadBeforeAssign': false}],
-    'space-in-parens': [2, 'never'],
-    'no-trailing-spaces': ['error'],
-    'semi': [2, 'always'],
-    'no-multiple-empty-lines': [2, {'max': 2}],
-    'quotes': ['error', 'single', {'allowTemplateLiterals': true}],
-    'valid-jsdoc': ['error', {'requireParamDescription': false, 'requireReturnDescription': false}],
-    'no-shadow': 'off',
-    'space-before-function-paren': ['error', {'anonymous': 'never', 'named': 'never', 'asyncArrow': 'always'}],
-    'require-jsdoc': 'off', //['error', {'require': {'FunctionDeclaration': true, 'MethodDefinition': true}}],
-    'keyword-spacing': ['error'],
-    'chai-friendly/no-unused-expressions': 'off',
-    'no-undef-init': ['error'],
-    'comma-spacing': ['error'],
-    'brace-style': ['error'],
-    '@typescript-eslint/no-unused-vars': 'off',
-    'no-irregular-whitespace': 'off',
-    'mocha/no-mocha-arrows': 'off',
-    'chai-expect/no-inner-compare': 'off',
-    '@typescript-eslint/no-this-alias': 'off'
-  },
-  'extends': [
-    'eslint:recommended',
-    'plugin:mocha/recommended',
-    'plugin:chai-expect/recommended',
-    'plugin:chai-friendly/recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:@typescript-eslint/eslint-recommended'
-  ]
 };

package/.prettierrc

@@ -0,0 +1,11 @@
+{
+	"singleQuote": true,
+	"trailingComma": "all",
+	"arrowParens": "avoid",
+	"printWidth": 120,
+	"tabWidth": 2,
+	"useTabs": false,
+	"semi": true,
+	"bracketSpacing": true,
+	"proseWrap": "never"
+}

package/built/index.d.ts

@@ -1,3 +1,5 @@
-declare function wrapObj(item: any): any;
+declare function wrapObj(item: any, config?: {
+    getEntity: string;
+}): any;
 declare function wrapConstruct(constructorFunction: any): any;
 export { wrapConstruct, wrapObj };

package/built/index.js

@@ -3,26 +3,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapObj = exports.wrapConstruct = void 0;
 const sat_utils_1 = require("sat-utils");
 sat_utils_1.logger.setLogLevel(process.env.LOG_LEVEL);
-function wrapObj(item) {
+function wrapObj(item, config) {
+    if (!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)) {
+        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;
+            }
+            sat_utils_1.logger.info(p);
             if (p === Symbol.toStringTag) {
-                return proxifiedResult;
+                return proxifiedResult[Symbol.toStringTag];
             }
             if (p === 'toString') {
                 return function (...args) {
                     return proxifiedResult.toString(...args);
                 };
             }
-            sat_utils_1.logger.info(p);
             if (p === 'toJSON') {
                 sat_utils_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) && item[p] && !proxifiedResult[p]) {
+            if (!sat_utils_1.isFunction(item[p]) &&
+                !sat_utils_1.isAsyncFunction(item[p]) &&
+                !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');
                 return item[p];
             }
@@ -63,8 +76,7 @@ function wrapObj(item) {
                 }
                 return async function (onRes, onRej) {
                     const catcher = p === 'catch' ? onRes : onRej;
-                    proxifiedResult = await proxifiedResult
-                        .catch((error) => ({ error, ____proxed____error: true }));
+                    proxifiedResult = await proxifiedResult.catch(error => ({ error, ____proxed____error: true }));
                     if (proxifiedResult && proxifiedResult.____proxed____error) {
                         return catcher(proxifiedResult.error);
                     }
@@ -76,7 +88,7 @@ function wrapObj(item) {
                 sat_utils_1.logger.info('In resulter has prop');
                 return proxifiedResult[p];
             }
-            if (!(p in item) && (p in proxifiedResult)) {
+            if (!(p in item) && p in proxifiedResult) {
                 sat_utils_1.logger.info('In target does not have prop but resulter has prop');
                 return proxifiedResult[p];
             }
@@ -90,7 +102,7 @@ function wrapObj(item) {
         },
         getOwnPropertyDescriptor(_t, p) {
             return Object.getOwnPropertyDescriptor(proxifiedResult, p);
-        }
+        },
     });
     return proxed;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chain-simple",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
   "main": "built/index.js",
   "directories": {
@@ -47,6 +47,7 @@
     "eslint-plugin-chai-friendly": "^0.6.0",
     "eslint-plugin-mocha": "^8.0.0",
     "mocha": "^8.2.1",
+    "prettier": "^2.6.2",
     "ts-node": "^9.1.1",
     "typescript": "^4.1.3"
   },
@@ -54,6 +55,6 @@
     "node": ">=12.18.3"
   },
   "dependencies": {
-    "sat-utils": "^0.0.4"
+    "sat-utils": "^0.0.42"
   }
 }

package/readme.md

@@ -1,5 +1,40 @@
 # chain-simple
 
-## BETA
 
 ![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');
+
+const yourObjectWithMethods = {
+  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 wrappedObj = wrapObj(yourObjectWithMethods);
+
+testExample();
+async function testExample() {
+  const result = await wrappedObj.method1().method2().method3().method1();
+
+  console.log(result);
+}
+```