proxy-object-method

rear or prefix proxy util for object method

features

cheap way to add prefix/rear logic for any method in object
register logic by chain
execute prefix/rear logic in concurrence way
custom define when to execute prefix/rear logic
all execute by promise

usage

basic usage `javascript const ProxyObjMethod = require('proxy-object-method'); const target = { main (...args) { console.log(main args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}) return true; } }

newTarget .main(1, 2) .then( result => console.log('function result: ', result), err => console.error('test failed and error:', err) );

/* output:

prefix-a args: 1,2 ret: {} main args: 1,2 ret: {"a":"prefix1"} rear-b args: 1,2 ret: {"a":"prefix1","main":true} function result: true */


- concurrence execute
```javascript
const target = {
  main (...args) {
    console.log(`main args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}`)
    return true;
  }
}

// a1 and a2 will be concurrently executed 
const newTarget = new ProxyObjMethod(target)
 .prefix('main', [
   function a1 (...args) {
     console.log(`prefix-a1 args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}`); 
     return 'prefix2';
   },
   function a2 (...args) {
     console.log(`prefix-a2 args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}`); 
     return 'prefix3';
   }
 ])
 .end();


 newTarget
   .main(1, 2)
   .then(
     result => console.log('function result: ', result),
     err    => console.error('test failed and error:', err)
   );
/*
output:

prefix-a1 args: 1,2 ret: {}
prefix-a2 args: 1,2 ret: {}
main args: 1,2 ret: {"a1":"prefix2","a2":"prefix3"}
function result:  true
*/

custom execution condition `javascript const target = { executable: false, main (...args) { console.log(main args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}) return true; } }

// a1 and a2 will be concurrently executed const newTarget = new ProxyObjMethod(target) .prefix('main', function a (...args) { console.log(prefix-a args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}); return 'prefix2'; } , (target) => target.executable) .end();

// case1: newTarget .main(1, 2) .then( result => console.log('function result: ', result), err => console.error('test failed and error:', err) ); /* output:

main args: 1,2 ret: {} function result: true */

// case2: newTarget.executable = true; newTarget .main(1, 2) .then( result => console.log('function result: ', result), err => console.error('test failed and error:', err) ); /* output:

prefix-a args: 1,2 ret: {} main args: 1,2 ret: {"a":"prefix2"} function result: true */

more explanation

Proxy-object-method use the name of function to store result and will ignore the result without name.

API

proxyObjMethod.prefix(methodName, prefixFuncs, [conditionFn])

Add one or multi prefix function.

Prefix-function will be executed with method's arguments and other front prefix-function's result map. The result map of prefix-function will look like: { [prefixFuncName]: prefixFuncResult }

if there are multi prefix-function, then they will be concurrently executed.

proxyObjMethod.rear(methodName, rearFuncs, [conditionFn])

Add one or multi rear function.

The rear-function works almost as same as prefix-function.

proxyObjMethod.end()

Return the proxy object. The object is single for proxyObjMethod

Package detail