keystonejs / grappling-hook Goto Github PK

var hook = require('grappling-hook')

hook.attach(MyClass)

hook.mixin(myObj)

MyClass.hookup(event, fn)
// e.g.
MyClass.hookup('save', fn) // registers pre:save and post:save
MyClass.hookup('pre:save', fn) // only allows pre:save

MyClass.hookable(event)
// e.g.
MyClass.hookable('save') // registers pre:save and post:save
MyClass.hookable('pre:save') // only allows pre:save

MyClass[hook](event, fn)
e.g.
MyClass.pre('save', fn)
MyClass.post('save', fn)

MyClass.pre('save', true, function(...args, next, done) {
  next() // middleware continues
  doSomethingAsync(function() {
    done() // hook is complete, save can continue
  })
});

MyClass.getHooks() // { pre: { save: [fn] } }
MyClass.getHooks('save') // { pre: [fn] }
MyClass.getHooks('pre:save') // [fn]
MyClass.hasHooks('pre:save') // shortcut for MyClass.getHooks('pre:save').length ? true : false

MyClass.hooks('pre:save', [args]) // fires a sync event; throws if an async handler is bound
MyClass.hooks('pre:save', [args], callback) // fires an async event; handler is wrapped if sync

field.unhook('pre:save', fn)  // removes `fn` as a `pre:save` hook
field.unhook('pre:save') // removes ALL hooks for `pre:save`
field.unhook('save') // removes ALL `save` hooks
field.unhook() // removes ALL hooks

const _ = require('lodash')
const grappling = require('grappling-hook')

const _privateKey = '_privateKey'
const PROXY = true

class Base {
  constructor(values, descriptor) {
    // Object used to store internals.
    const _private = this[_privateKey] = {}
    // Object with getters and setters bound.
    _private._getset = this
    // Public version of ourselves.
    // Overwritten with proxy if available.
    _private._this = this
    // Object used to store raw values.
    _private._obj = {}
    _private.descriptor = descriptor

    _.each(descriptor, (p, k) => {
      const t = p.toLowerCase()
      Object.defineProperty(_private._getset, k, {
        configurable: true,
        get: () => this[_privateKey]._obj[k],
        set: value => {
          if (typeof value !== t) {
            return
          }
          this[_privateKey]._obj[k] = value
        }
      })
    })

    if (PROXY && typeof Proxy !== 'undefined') {
      const proxy = this[_privateKey]._this = new Proxy(this, {
        // Ensure only public keys are shown
        ownKeys: (target) => {
          return Object.keys(this.toObject())
        },

        // Return keys to iterate
        enumerate: (target) => {
          return Object.keys(this[_privateKey]._this)[Symbol.iterator]()
        },

        // Check to see if key exists
        has: (target, key) => {
          return Boolean(_private._getset[key])
        },

        // Ensure correct prototype is returned.
        getPrototypeOf: () => {
          return _private._getset
        },

        // Ensure readOnly fields are not writeable.
        getOwnPropertyDescriptor: (target, key) => {
          return {
            value: proxy[key],
            writeable: !descriptor[key],
            enumerable: true,
            configurable: true
          }
        },

        // Intercept all get calls.
        get: (target, name, receiver) => {
          return this[name]
        },

        // Intercept all set calls.
        set: (target, name, value, receiver) => {
          if (!descriptor[name]) {
            return false
          }

          this[name] = value
          return true
        },

        // Intercept all delete calls.
        deleteProperty: (target, property) => {
          this[property] = undefined
          return true
        }
      })
    }

    if (_.isObject(values)) {
      let data = values
      this.set(data)
    }

    return _private._this
  }

  _toObject(options, json) {
    let ret = {}

    _.each(this[_privateKey].descriptor, (properties, index) => {
      // Fetch value through the public interface.
      let value = this[_privateKey]._this[index]

      // Clone objects so they can't be modified by reference.
      if (typeof value === 'object' && value) {
        if (_.isArray(value)) {
          value = value.splice(0)
        } else if (_.isDate(value)) {
          value = new Date(value.getTime())
        } else {
          value = _.clone(value)
        }
      }

      // Write to object.
      ret[index] = value
    })

    return ret
  }

  set(path, value) {
    if (_.isObject(path) && !value) {
      value = path
      for (const key in value) {
        if (value.hasOwnProperty(key)) {
          try {
            this[_privateKey]._this[key] = value[key]
          } catch (err) {}
        }
      }
    } else {
      try {
        this[_privateKey]._this[path] = value
      } catch (err) {}
    }
  }

  get(path) {
    return this[path]
  }

  toObject(options) {
    return this._toObject(options)
  }

  inspect() {
    return this.toObject({})
  }

  toString() {
    return this.inspect()
  }

  save(options, fn) {
    if (_.isFunction(options)) {
      fn = options
      options = {}
    }

    if (!fn) {
      fn = _.noop
    }

    process.nextTick(() => {
      console.log('save!')
      console.dir(this.toObject(), { depth: null })
      return fn(null, this)
    })
  }
}

exports.Base = Base

exports.compile = function compile(schema, hooks) {
  class Model extends Base {
    constructor(data) {
      super(data, schema)

      _.forEach(hooks, ho => {
        this.addHooks(ho.name)
        this[ho.hook](ho.name, ho.fn)
      })
    }
  }

  grappling.mixin(Model.prototype)

  return Model
}

var compile = require('./compile').compile

// we only want our models to have foo and bar of the following types
var MyModel1 = compile({
  foo: 'string',
  bar: 'number'
});

var m = new MyModel1({foo: 'something'});
console.log(m) 
m.asdf = 'asdf' // this is not going to work
console.log(m) 
console.log(m.asdf)
m.save(function(err, res) {
  console.log('done!')
});

{ foo: 'something', bar: undefined }
{ foo: 'something', bar: 11 }
undefined // asdf wasn't saved because it's not allowed
save!
{ foo: 'something', bar: 11 }
done!

var MyModel2 = compile({
  foo: 'string',
  bar: 'number'
}, [{
  hook: 'pre',
  name: 'save',
  fn: function(next) {
    console.log('pre save')
    next()
  }
}]);

var m2 = new MyModel2({foo: 'something'});
console.log(m2) 
m2.asdf = 'asdf'
m2.bar = 11
console.log(m2) 
console.log(m2.asdf)
m2.save(function(err, res) {
  console.log('done!')
});

function createParallel(name) {
    return function(next, done) {
        console.log(name + ' setup');
        setTimeout(function() {
            console.log(name + ' done');
            done();
        }, 0);
        next();// <------------------- next is called after the async stuff is fired off
    };
}

instance.pre('test', createParallel("A"), createParallel("B")).callHook('pre:test');

function createParallel(name) {
    return function(next, done) {
        console.log(name + ' setup');
        next(); // <------------------- next is called before the async stuff is fired off
        setTimeout(function() {
            console.log(name + ' done');
            done();
        }, 0);
    };
}

instance.pre('test', createParallel("A"), createParallel("B")).callHook('pre:test');

instance.pre('initPlugins', function (foo, next) {
        foo.push('funky');
        next(null, foo)
})
instance.pre('initPlugins', function (foo, next) {
        foo.push('monkey');
        next(null, foo)
});

instance.callHook('pre:initPlugins', [
     'basic-plugin-1'
], function () {
    // arguments = { '0': undefined }
});

instance.pre('initPlugins', function (foo, next) {
        foo.push('funky');
        next(null, foo)
})
instance.pre('initPlugins', function (foo, next) {
        foo.push('monkey');
        next(foo)
});

instance.callHook('pre:initPlugins', [
     'basic-plugin-1'
], function () {
    // arguments = { '0': [ 'basic-plugin-1', 'funky', 'monkey' ] }
});

var instance = {
  // "method" is SYNC, "fn" is NOT a callback
  method: function(fn) { // <-- grappling assumes this is ASYNC when arg not passed
    if('function' === typeof fn) {
       ... do something with fn
    }
  }
}

grappling.mixin(instance)
  .addHooks('method')
  .pre('method', function() {
    ... do something
  });

instance.method(); 

instance.whatever = 'mofo!';
instance.pre('save', function(a,b){
  console.log(a); //outputs 'foo'
  console.log(b); //outputs 'bar'
  console.log(this.whatever); //outputs 'mofo!'
});
instance.save('foo', 'bar', _.noop);

instance.post('save', function(result, a,b){
  console.log(result); // outputs the results of the `save` operation
  console.log(a); //outputs 'foo'
  console.log(b); //outputs 'bar'
});
instance.save('foo', 'bar', _.noop);