kuzzle 2.19.2 → 2.19.5

package/lib/kuzzle/event/kuzzleEventEmitter.js

@@ -19,25 +19,25 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 // Most of the functions exposed in this file should be viewed as
 // critical section of code.
 
-const assert = require('assert');
+const assert = require("assert");
 
-const EventEmitter = require('eventemitter3');
-const Bluebird = require('bluebird');
-const debug = require('debug')('kuzzle:events');
-const { v4: uuidv4 } = require('uuid');
+const EventEmitter = require("eventemitter3");
+const Bluebird = require("bluebird");
+const debug = require("debug")("kuzzle:events");
+const { v4: uuidv4 } = require("uuid");
 
-const Promback = require('../../util/promback');
-const memoize = require('../../util/memoize');
-const PipeRunner = require('./pipeRunner');
-const kerror = require('../../kerror');
+const Promback = require("../../util/promback");
+const memoize = require("../../util/memoize");
+const PipeRunner = require("./pipeRunner");
+const kerror = require("../../kerror");
 
 class PluginPipeDefinition {
-  constructor (event, handler, pipeId = null) {
+  constructor(event, handler, pipeId = null) {
     this.event = event;
     this.handler = handler;
 
@@ -46,7 +46,7 @@ class PluginPipeDefinition {
 }
 
 class KuzzleEventEmitter extends EventEmitter {
-  constructor (maxConcurrentPipes, pipesBufferSize) {
+  constructor(maxConcurrentPipes, pipesBufferSize) {
     super();
     this.superEmit = super.emit;
     this.pipeRunner = new PipeRunner(maxConcurrentPipes, pipesBufferSize);
@@ -78,10 +78,13 @@ class KuzzleEventEmitter extends EventEmitter {
    * @param  {String}   event
    * @param  {Function} fn
    */
-  onPipe (event, fn) {
-    assert(typeof fn === 'function', `Cannot listen to pipe event ${event}: "${fn}" is not a function`);
+  onPipe(event, fn) {
+    assert(
+      typeof fn === "function",
+      `Cannot listen to pipe event ${event}: "${fn}" is not a function`
+    );
 
-    if (! this.corePipes.has(event)) {
+    if (!this.corePipes.has(event)) {
       this.corePipes.set(event, []);
     }
 
@@ -95,14 +98,19 @@ class KuzzleEventEmitter extends EventEmitter {
    * @param  {String}   event
    * @param  {Function} fn
    */
-  onAsk (event, fn) {
-    assert(typeof fn === 'function', `Cannot listen to ask event "${event}": "${fn}" is not a function`);
-    assert(! this.coreAnswerers.has(event), `Cannot add a listener to the ask event "${event}": event has already an answerer`);
+  onAsk(event, fn) {
+    assert(
+      typeof fn === "function",
+      `Cannot listen to ask event "${event}": "${fn}" is not a function`
+    );
+    assert(
+      !this.coreAnswerers.has(event),
+      `Cannot add a listener to the ask event "${event}": event has already an answerer`
+    );
 
     this.coreAnswerers.set(event, fn);
   }
 
-  
   /**
    * Registers a core 'callback' answerer
    * There can only be 0 or 1 answerer per callback event.
@@ -110,9 +118,15 @@ class KuzzleEventEmitter extends EventEmitter {
    * @param  {String}   event
    * @param  {Function} fn
    */
-  onCall (event, fn) {
-    assert(typeof fn === 'function', `Cannot register callback for event "${event}": "${fn}" is not a function`);
-    assert(! this.coreSyncedAnswerers.has(event), `Cannot register callback for event "${event}": a callback has already been registered`);
+  onCall(event, fn) {
+    assert(
+      typeof fn === "function",
+      `Cannot register callback for event "${event}": "${fn}" is not a function`
+    );
+    assert(
+      !this.coreSyncedAnswerers.has(event),
+      `Cannot register callback for event "${event}": a callback has already been registered`
+    );
 
     this.coreSyncedAnswerers.set(event, fn);
   }
@@ -125,7 +139,7 @@ class KuzzleEventEmitter extends EventEmitter {
    * @param  {string} event
    * @param  {*} data
    */
-  emit (event, data) {
+  emit(event, data) {
     const events = getWildcardEvents(event);
     debug('Triggering event "%s" with data: %o', event, data);
 
@@ -153,13 +167,16 @@ class KuzzleEventEmitter extends EventEmitter {
    * @param  {*} payload
    * @returns {Promise.<*>|null}
    */
-  pipe (event, ...payload) {
+  pipe(event, ...payload) {
     debug('Triggering pipe "%s" with payload: %o', event, payload);
 
     let callback = null;
 
     // safe: a pipe's payload can never contain functions
-    if (payload.length > 0 && typeof payload[payload.length - 1] === 'function') {
+    if (
+      payload.length > 0 &&
+      typeof payload[payload.length - 1] === "function"
+    ) {
       callback = payload.pop();
     }
 
@@ -170,7 +187,7 @@ class KuzzleEventEmitter extends EventEmitter {
       const targets = this.pluginPipes.get(events[i]);
 
       if (targets) {
-        targets.forEach(t => funcs.push(t));
+        targets.forEach((t) => funcs.push(t));
       }
     }
 
@@ -185,8 +202,7 @@ class KuzzleEventEmitter extends EventEmitter {
 
     if (funcs.length === 0) {
       pipeCallback.call(callbackContext, null, ...payload);
-    }
-    else {
+    } else {
       this.pipeRunner.run(funcs, payload, pipeCallback, callbackContext);
     }
 
@@ -196,21 +212,28 @@ class KuzzleEventEmitter extends EventEmitter {
   /**
    * Emits an "ask" event to get information about the provided payload
    */
-  async ask (event, ...payload) {
+  async ask(event, ...payload) {
     debug('Triggering ask "%s" with payload: %o', event, payload);
 
     const fn = this.coreAnswerers.get(event);
 
-    if (! fn) {
-      throw kerror.get('core', 'fatal', 'assertion_failed', `the requested ask event '${event}' doesn't have an answerer`);
+    if (!fn) {
+      throw kerror.get(
+        "core",
+        "fatal",
+        "assertion_failed",
+        `the requested ask event '${event}' doesn't have an answerer`
+      );
     }
 
     const response = await fn(...payload);
 
-    getWildcardEvents(event).forEach(ev => super.emit(ev, {
-      args: payload,
-      response,
-    }));
+    getWildcardEvents(event).forEach((ev) =>
+      super.emit(ev, {
+        args: payload,
+        response,
+      })
+    );
 
     return response;
   }
@@ -218,21 +241,28 @@ class KuzzleEventEmitter extends EventEmitter {
   /**
    * Calls a callback to get information about the provided payload
    */
-  call (event, ...payload) {
+  call(event, ...payload) {
     debug('Triggering callback "%s" with payload: %o', event, payload);
 
     const fn = this.coreSyncedAnswerers.get(event);
 
-    if (! fn) {
-      throw kerror.get('core', 'fatal', 'assertion_failed', `the requested callback event '${event}' doesn't have an answerer`);
+    if (!fn) {
+      throw kerror.get(
+        "core",
+        "fatal",
+        "assertion_failed",
+        `the requested callback event '${event}' doesn't have an answerer`
+      );
     }
 
     const response = fn(...payload);
 
-    getWildcardEvents(event).forEach(ev => super.emit(ev, {
-      args: payload,
-      response,
-    }));
+    getWildcardEvents(event).forEach((ev) =>
+      super.emit(ev, {
+        args: payload,
+        response,
+      })
+    );
 
     return response;
   }
@@ -241,35 +271,32 @@ class KuzzleEventEmitter extends EventEmitter {
    * Registers a plugin hook.
    * Catch any error in the handler and emit the hook:onError event.
    */
-  registerPluginHook (pluginName, event, fn) {
+  registerPluginHook(pluginName, event, fn) {
     this.on(event, (...args) => {
       try {
         const ret = fn(...args, event);
 
-        if (typeof ret === 'object' && typeof ret.catch === 'function') {
-          ret.catch(error => {
-            if (event !== 'hook:onError') {
-              this.emit('hook:onError', { error, event, pluginName });
-            }
-            else {
-              this.emit('plugin:hook:loop-error', { error, pluginName });
+        if (typeof ret === "object" && typeof ret.catch === "function") {
+          ret.catch((error) => {
+            if (event !== "hook:onError") {
+              this.emit("hook:onError", { error, event, pluginName });
+            } else {
+              this.emit("plugin:hook:loop-error", { error, pluginName });
             }
           });
         }
-      }
-      catch (error) {
-        if (event !== 'hook:onError') {
-          this.emit('hook:onError', { error, event, pluginName });
-        }
-        else {
-          this.emit('plugin:hook:loop-error', { error, pluginName });
+      } catch (error) {
+        if (event !== "hook:onError") {
+          this.emit("hook:onError", { error, event, pluginName });
+        } else {
+          this.emit("plugin:hook:loop-error", { error, pluginName });
         }
       }
     });
   }
 
-  registerPluginPipe (event, handler) {
-    if (! this.pluginPipes.has(event)) {
+  registerPluginPipe(event, handler) {
+    if (!this.pluginPipes.has(event)) {
       this.pluginPipes.set(event, []);
     }
 
@@ -282,19 +309,18 @@ class KuzzleEventEmitter extends EventEmitter {
     return definition.pipeId;
   }
 
-  unregisterPluginPipe (pipeId) {
+  unregisterPluginPipe(pipeId) {
     const definition = this.pluginPipeDefinitions.get(pipeId);
 
-    if (! definition) {
-      throw kerror.get('plugin', 'runtime', 'unknown_pipe', pipeId);
+    if (!definition) {
+      throw kerror.get("plugin", "runtime", "unknown_pipe", pipeId);
     }
 
     const handlers = this.pluginPipes.get(definition.event);
     handlers.splice(handlers.indexOf(definition.handler), 1);
     if (handlers.length > 0) {
       this.pluginPipes.set(definition.event, handlers);
-    }
-    else {
+    } else {
       this.pluginPipes.delete(definition.event);
     }
 
@@ -307,7 +333,7 @@ class KuzzleEventEmitter extends EventEmitter {
    * @param  {string}  event
    * @return {Boolean}       [description]
    */
-  hasAskAnswerer (event) {
+  hasAskAnswerer(event) {
     return this.coreAnswerers.has(event);
   }
 }
@@ -321,7 +347,7 @@ class KuzzleEventEmitter extends EventEmitter {
  *
  * @warning Critical section of code
  */
-async function pipeCallback (error, ...updated) {
+async function pipeCallback(error, ...updated) {
   /* eslint-disable no-invalid-this */
   if (error) {
     this.promback.reject(error);
@@ -331,7 +357,7 @@ async function pipeCallback (error, ...updated) {
   const corePipes = this.instance.corePipes.get(this.targetEvent);
 
   if (corePipes) {
-    await Bluebird.map(corePipes, fn => fn(...updated));
+    await Bluebird.map(corePipes, (fn) => fn(...updated));
   }
 
   for (let i = 0; i < this.events.length; i++) {
@@ -354,9 +380,9 @@ async function pipeCallback (error, ...updated) {
  * @param {String} event
  * @returns {Array<String>} wildcard events
  */
-const getWildcardEvents = memoize(event => {
+const getWildcardEvents = memoize((event) => {
   const events = [event];
-  const delimIndex = event.lastIndexOf(':');
+  const delimIndex = event.lastIndexOf(":");
 
   if (delimIndex === -1) {
     return events;
@@ -365,7 +391,7 @@ const getWildcardEvents = memoize(event => {
   const scope = event.slice(0, delimIndex);
   const name = event.slice(delimIndex + 1);
 
-  ['before', 'after'].forEach(prefix => {
+  ["before", "after"].forEach((prefix) => {
     if (name.startsWith(prefix)) {
       events.push(`${scope}:${prefix}*`);
     }

package/lib/kuzzle/event/pipeRunner.js

@@ -19,15 +19,15 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const assert = require('assert');
-const Denque = require('denque');
+const assert = require("assert");
+const Denque = require("denque");
 
-const { KuzzleError } = require('../../kerror/errors');
-const waterfall = require('./waterfall');
+const { KuzzleError } = require("../../kerror/errors");
+const waterfall = require("./waterfall");
 
-const kerror = require('../../kerror').wrap('plugin', 'runtime');
+const kerror = require("../../kerror").wrap("plugin", "runtime");
 
 /**
  * We declare the callback used by waterfall one time instead
@@ -37,22 +37,22 @@ const kerror = require('../../kerror').wrap('plugin', 'runtime');
  * { instance: (pipeRunner instance), callback: (callback after pipes execution) }
  */
 /* eslint-disable no-invalid-this */
-function waterfallCallback (error, result) {
+function waterfallCallback(error, ...result) {
   this.instance.running--;
 
-  if (! this.instance.buffer.isEmpty()) {
+  if (!this.instance.buffer.isEmpty()) {
     setImmediate(this.instance._boundRunNext);
   }
 
   if (error) {
-    const cbError = error instanceof KuzzleError
-      ? error
-      : kerror.getFrom(error, 'unexpected_error', error.message);
+    const cbError =
+      error instanceof KuzzleError
+        ? error
+        : kerror.getFrom(error, "unexpected_error", error.message);
 
     this.callback.call(this.callbackContext, cbError);
-  }
-  else {
-    this.callback.call(this.callbackContext, null, result);
+  } else {
+    this.callback.call(this.callbackContext, null, ...result);
   }
 }
 /* eslint-enable no-invalid-this */
@@ -62,7 +62,7 @@ function waterfallCallback (error, result) {
  * @class PipeChain
  */
 class PipeChain {
-  constructor (chain, args, callback, callbackContext) {
+  constructor(chain, args, callback, callbackContext) {
     this.chain = chain;
     this.args = args;
     this.callback = callback;
@@ -80,13 +80,15 @@ class PipeChain {
  * @param {Number} bufferSize - max number of delayed pipe chains
  */
 class PipeRunner {
-  constructor (concurrent, bufferSize) {
+  constructor(concurrent, bufferSize) {
     assert(
-      typeof concurrent === 'number' && concurrent > 0,
-      'Cannot instantiate pipes executor: invalid maxConcurrentPipes parameter value');
+      typeof concurrent === "number" && concurrent > 0,
+      "Cannot instantiate pipes executor: invalid maxConcurrentPipes parameter value"
+    );
     assert(
-      typeof bufferSize === 'number' && bufferSize > 0,
-      'Cannot instantiate pipes executor: invalid pipesBufferSize parameter value');
+      typeof bufferSize === "number" && bufferSize > 0,
+      "Cannot instantiate pipes executor: invalid pipesBufferSize parameter value"
+    );
 
     this.maxConcurrent = concurrent;
     this.running = 0;
@@ -105,12 +107,11 @@ class PipeRunner {
    * @param {Function} callback - end-of-chain callback
    * @param {Object} callbackContext - functions/callback context
    */
-  run (chain, args, callback, callbackContext) {
+  run(chain, args, callback, callbackContext) {
     if (this.running >= this.maxConcurrent) {
       if (this.buffer.length >= this.maxBufferSize) {
-        callback.call(callbackContext, kerror.get('too_many_pipes'));
-      }
-      else {
+        callback.call(callbackContext, kerror.get("too_many_pipes"));
+      } else {
         this.buffer.push(new PipeChain(chain, args, callback, callbackContext));
       }
 
@@ -129,7 +130,7 @@ class PipeRunner {
     waterfall(chain, args, waterfallCallback, waterfallCallbackCtx);
   }
 
-  _runNext () {
+  _runNext() {
     if (this.buffer.isEmpty() || this.running >= this.maxConcurrent) {
       return;
     }

package/lib/kuzzle/event/waterfall.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 class WaterfallContext {
   /**
@@ -28,7 +28,7 @@ class WaterfallContext {
    * @param  {Function} cb     - end of waterfall callback
    * @param  {Object}   cbCtx  - functions context
    */
-  constructor (chain, args, cb, cbCtx) {
+  constructor(chain, args, cb, cbCtx) {
     this.chain = chain;
     this.cb = cb;
     this.cbCtx = cbCtx;
@@ -41,7 +41,7 @@ class WaterfallContext {
     this.args = args.length ? args : [null];
   }
 
-  hasNext () {
+  hasNext() {
     return this.index < this.chain.length;
   }
 
@@ -49,52 +49,50 @@ class WaterfallContext {
    * Each function in the waterfall chain returns a result. This result should
    * always be the 1st payload argument (updated or left intact, it matters not)
    */
-  set result (result) {
+  set result(result) {
     this.args[0] = result;
   }
 
-  next (cb) {
+  next(cb) {
     this.index++;
     this.chain[this.index - 1](...this.args, cb);
   }
 
-  reject (error) {
+  reject(error) {
     this.cb.call(this.cbCtx, error);
   }
 
   // Resolves with the updated payload
-  resolve () {
+  resolve() {
     this.cb.call(this.cbCtx, null, ...this.args);
   }
 }
 
 /* eslint-disable no-invalid-this */
-function waterfallCB (err, res) {
+function waterfallCB(err, res) {
   if (err) {
     this.reject(err);
-  }
-  else {
+  } else {
     this.result = res;
     waterfallNext(this);
   }
 }
 /* eslint-enable no-invalid-this */
 
-function waterfallNext (ctx) {
-  if (! ctx.hasNext()) {
+function waterfallNext(ctx) {
+  if (!ctx.hasNext()) {
     ctx.resolve();
     return;
   }
 
   try {
     ctx.next(waterfallCB.bind(ctx));
-  }
-  catch (error) {
+  } catch (error) {
     ctx.reject(error);
   }
 }
 
-function waterfall (chain, args, cb, context) {
+function waterfall(chain, args, cb, context) {
   const ctx = new WaterfallContext(chain, args, cb, context);
 
   waterfallNext(ctx);

package/lib/kuzzle/index.js

@@ -19,6 +19,6 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-module.exports = require('./kuzzle');
+module.exports = require("./kuzzle");