Pluggable

Usage

Run npm run example

const Pluggable = require('./index')

/// A class extends Pluggable
class Foo extends Pluggable {

  constructor () {
    // need to call super.
    super()
  }

  // a simple method, passing value
  bar (a, b) {
    return a + b
  }

  // a simple method, passing reference
  foobar (obj) {
    obj.name = 'foobar'
    return obj
  }

}

// wrap these methods
// 1. hook name is same as method name
Foo.wrapHook('bar', 'pre post')
// 2. hook name is custom
Foo.wrapHook('foobar', 'foo', 'pre post')


async function test (a, b, obj) {
  try {

    // add hooks before initialize instance.
    // pre hook take all arguments as arguments.
    // all hooks can be async.
    Foo.pre('bar', function (a, b) {
      console.log(`I'm the foo, and I am ${a} and ${b}.`)
    })

    // throw error to stop all plugins and the original call.
    Foo.pre('bar', function (a, b) {
      if (a === b) {
        throw ReferenceError('Just an error')
      }
    })

    /// post hook table result of original call.
    Foo.post('bar', function (result) {
      console.log(`I'm the foo, and I have a result ${result}.`)
    })

    // declare property before initialize instance.
    Foo.declare('declareFoo', [1, 2, 3])

    let foo = new Foo()

    // add hooks after initialize class
    Foo.pre('foo', function (obj) {
      console.log(`I'm the foobar, and I am ${JSON.stringify(obj)}. I will add another field to ${JSON.stringify(obj)}`)
      obj.anotherField = 'Plugin'
    })

    Foo.post('foo', function (result) {
      console.log(`I'm the foobar, and I have a result ${JSON.stringify(result)}.`)
    })

    // wrapped methods become async functions.
    return [await foo.bar(a, b), await foo.foobar(obj)]
  } catch (error) {
    console.error(error)
  }
}

test(1, 2, {test: 1})
  .then(result => {
    console.log(`Finally, I get the result ${JSON.stringify(result)}`)
  })
  .then(() => {
    return test(1, 1)
      .catch(console.log)
  })