Package Exports

to-aop

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (to-aop) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

to-aop

The to-aop module help you with applying Aspect Oriented Programming to JavaScript. It use under the hood ES Proxy for object same as other similar modules. It allow you hook class without creating new instance as well. It use javascript prototype for that.

For example I am using it for adding hooks to production code where all debug code is missing. I don't have got access to instance but I have only class constructor. But usage is unlimited.

Installation

npm i to-aop --save

Usage

You have some common class. For example:

// a.js
export default class A {
  constructor(variable) {
    this.variable = variable;
  }

  method() {
    return this.variable;
  }

  notHookedMethod() {
    return 'not hook';
  }    
}

Applying AOP to class

You can use it for creating hook to your favorite framework or your own application without modification source code.

import { aop, hookName, createHook } from 'to-aop';
import A from './a';

const classHookBefore = createHook(
  hookName.beforeMethod,
  /^(method)$/,
  ({ target, object, property, context, args }) => {
    //call your own hook
    console.log(
      `Instance of ${target.name} call "${property}"
with arguments ${args && args.length ? args : '[]'}.`
    );
  }
);

const classHookAfter = createHook(
  hookName.afterMethod,
  /^(method)$/,
  ({ target, object, property, context, args, payload }) => {
    //call your own hook
    console.log(
      `Instance of ${target.name} call "${property}"
with arguments ${args && args.length ? args : '[]'}
and return value is "${payload}".`
    );
  }
);

const hooks = Object.assign({}, classHookBefore, classHookAfter);

aop(
  A,
  hooks
); // bind hook to class
const a = new A('my hook');

a.method(); // Instance of A call "method" with arguments [] and return value is "my hook".
a.notHookedClassMethod(); // not hook

Applying AOP to instance or object

import { aop, hookName, createHook } from 'to-aop';
import A from './a';

const instanceHook = createHook(
  hookName.afterMethod,
  /^(method)$/,
  ({ target, object, property, context, args, payload }) => {
    console.log(
      `Instance of ${object.constructor.name} call "${property}"
with arguments ${args && args.length ? args : '[]'}
and return value is "${payload}".`
    );
  }
);

const a = new A('my hook');
const hookedInstance = aop(a, instanceHook); // bind hook to instance

hookedInstance.method(); // "Instance of A call "method" with arguments [] and return value is "my hook".
hookedInstance.notHookedClassMethod(); // not hook

Documentation

createHook(hookName, regular, callbackHook)

(string) hookName - set of hooks
(string, regexp, Array, function) regular - condition for filtering
(function) callbackHook - your defined action

aop(target, pattern)

(class, object) - target for hooks
(Object<string, Array>) - pattern of hooks

Hooks API

We implemented base set of hooks which you can use for AOP.

beforeMethod
afterMethod
aroundMethod
beforeGetter
afterGetter
aroundGetter
beforeSetter
afterSetter
aroundSetter

import { hookName } from 'to-aop';

// hookName.(beforeMethod|afterMethod|...)