method-hooks.js

import { Meteor } from 'meteor/meteor';

const methodHooks = {};

const registerMethodHook = (methodNames, position, fn) => {
  if (!(methodNames instanceof Array)) {
    methodNames = [methodNames];
  }

  for (let i = 0; i < methodNames.length; i++) {
    const methodName = methodNames[i];
    if (methodHooks[methodName] == null) {
      methodHooks[methodName] = {
        before: [],
        after: []
      };
    }
    methodHooks[methodName][position].unshift(fn);
  }
};

Meteor.beforeMethods = function (methodName, fn) {
  return registerMethodHook(methodName, 'before', fn);
};

Meteor.afterMethods = function (methodName, fn) {
  return registerMethodHook(methodName, 'after', fn);
};

const wrap = function ({ beforeHook, afterHook, method, methodName }) {
  return function () {
    const args = Array.prototype.slice.call(arguments);
    this._methodName = methodName;

    if (beforeHook) {
      beforeHook.apply(this, args);
    }

    const result = method.apply(this, args);

    if (afterHook) {
      afterHook.apply(this, args);
    }

    return result;
  }
};

Meteor.startup(function() {

  for (let method in methodHooks) {
    const hooks = methodHooks[method];
    let wrappedMethod = Meteor.server.method_handlers[method];
    for (let i = 0; i < hooks.before.length; i++) {
      const beforeHook = hooks.before[i];
      wrappedMethod = wrap({ beforeHook, method: wrappedMethod, methodName: method });
    }
    for (let j = 0; j < hooks.after.length; j++) {
      const afterHook = hooks.after[j];
      wrappedMethod = wrap({ afterHook, method: wrappedMethod, methodName: method });
    }
    Meteor.server.method_handlers[method] = wrappedMethod;
  }
});