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
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;
}
}
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 'prefix1';
})
.rear('main', function b (...args) {
console.log(`rear-b args: ${args.slice(0, -1)} ret: ${JSON.stringify(args[args.length - 1])}`);
return 'rear1';
})
.end(); // return proxy object
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
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
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