Allow usage of a function with plugin hook, pipe and controller actions

lib/api/core/plugins/pluginContext.js

@@ -95,9 +95,6 @@ class PluginContext {
         }
       });
 
-      /**
-        * @deprecated will be removed in v2, replaced by "sdk" accessor
-        */
       Object.defineProperty(this.accessors, 'execute', {
         enumerable: true,
         get: () => (...args) => execute(kuzzle, ...args)
@@ -184,7 +181,6 @@ class PluginContext {
 }
 
 /**
- * @deprecated will be removed in v2, replaced by "sdk" accessor
  * @param {Kuzzle} kuzzle
  * @param {Request} request
  * @param {Function} [callback]

lib/api/core/plugins/pluginsManager.js

@@ -353,7 +353,7 @@ class PluginsManager {
    * @param {number} warnDelay - delay before a warning is issued
    * @param {number} timeoutDelay - delay after which the function is timed out
    * @param {string} event name
-   * @param {function} fn - function to attach
+   * @param {string|function} fn - function to attach
    */
   registerPipe(plugin, warnDelay, timeoutDelay, event, fn) {
     debug('[%s] register pipe on event "%s"', plugin.manifest.name, event);
@@ -370,7 +370,7 @@ class PluginsManager {
 
       if (warnDelay) {
         pipeWarnTimer = setTimeout(() => {
-          this.trigger('log:warn', `Plugin pipe ${plugin.manifest.name}:${fn} exceeded ${warnDelay}ms to execute.`);
+          this.trigger('log:warn', `Plugin pipe ${plugin.manifest.name}:${fn} for event '${event}' exceeded ${warnDelay}ms to execute.`);
         }, warnDelay);
       }
 
@@ -401,7 +401,14 @@ class PluginsManager {
           }
         };
 
-        const pipeResponse = plugin.object[fn](data, cb);
+        const pipeResponse = (() => {
+          if (typeof fn === 'function') {
+            return fn(data, cb);
+          }
+
+          return plugin.object[fn](data, cb);
+        })();
+
         if (typeof pipeResponse === 'object'
           && pipeResponse !== null
           && typeof pipeResponse.then === 'function'
@@ -425,14 +432,18 @@ class PluginsManager {
    *
    * @param {object} plugin
    * @param {string} event
-   * @param {string} fn - function to attach
+   * @param {string|function} fn - function to attach
    */
   registerHook(plugin, event, fn) {
     debug('[%s] register hook on event "%s"', plugin.manifest.name, event);
 
     this.kuzzle.on(event, message => {
       try {
-        plugin.object[fn](message, event);
+        if (typeof fn === 'function') {
+          fn(message, event);
+        } else {
+          plugin.object[fn](message, event);
+        }
       }
       catch (error) {
         throw new PluginImplementationError(error);
@@ -580,15 +591,15 @@ class PluginsManager {
       _timeout = plugin.config.pipeTimeout;
     }
 
-    _.forEach(plugin.object.pipes, (fn, pipe) => {
+    _.forEach(plugin.object.pipes, (fn, event) => {
       const list = Array.isArray(fn) ? fn : [fn];
 
       for (const target of list) {
-        if (!_.isFunction(plugin.object[target])) {
-          throw new PluginImplementationError(`Unable to configure pipe with method ${plugin.manifest.name}.${target}: function not found`);
+        if (typeof target !== 'function' && typeof plugin.object[target] !== 'function') {
+          throw new PluginImplementationError(`Unable to configure pipe for event '${event}' with provided method. ${target} should be a plugin method name, or a function.`);
         }
 
-        this.registerPipe(plugin, _warnTime, _timeout, pipe, target);
+        this.registerPipe(plugin, _warnTime, _timeout, event, target);
       }
     });
   }
@@ -601,8 +612,8 @@ class PluginsManager {
       const list = Array.isArray(fn) ? fn : [fn];
 
       for (const target of list) {
-        if (!_.isFunction(plugin.object[target])) {
-          throw new PluginImplementationError(`Unable to configure hook with method ${plugin.manifest.name}.${target}: function not found`);
+        if (typeof target !== 'function' && typeof plugin.object[target] !== 'function') {
+          throw new PluginImplementationError(`Unable to configure hook for event '${event}' with provided method. ${target} should be a plugin method name, or a function.`);
         }
 
         this.registerHook(plugin, event, target);
@@ -631,19 +642,19 @@ class PluginsManager {
       Object.keys(description).forEach(action => {
         debug('[%s][%s][%s] starting action controller registration', plugin.manifest.name, controller, action);
 
-        if (typeof description[action] !== 'string' || description[action].length === 0) {
-          throw new PluginImplementationError(`${errorControllerPrefix} Invalid action description (expected non-empty string, got: "${typeof action}")`);
-        }
-
-        if (!_.isFunction(plugin.object[description[action]])) {
-          throw new PluginImplementationError(`${errorControllerPrefix} Action "${plugin.manifest.name + '.' + description[action]}" is not a function`);
+        if (typeof description[action] !== 'function' && typeof plugin.object[description[action]] !== 'function') {
+          throw new PluginImplementationError(`${errorControllerPrefix} Action for '${controller}:${action}' is not a function`);
         }
 
         if (!this.controllers[`${plugin.manifest.name}/${controller}`]) {
           this.controllers[`${plugin.manifest.name}/${controller}`] = {};
         }
 
-        this.controllers[`${plugin.manifest.name}/${controller}`][action] = plugin.object[description[action]].bind(plugin.object);
+        if (typeof description[action] === 'function') {
+          this.controllers[`${plugin.manifest.name}/${controller}`][action] = description[action];
+        } else {
+          this.controllers[`${plugin.manifest.name}/${controller}`][action] = plugin.object[description[action]].bind(plugin.object);
+        }
       });
     });