Add event at callback error in subscription (#699)

Add event at callback error in subscription.

An new event type has been created.

Author: ChillPC

doc/7/essentials/events/index.md

@@ -116,6 +116,16 @@ Triggered whenever Kuzzle responds with an error
 
 `@param {object} request - Request that caused the error`
 
+## callbackError
+
+Triggered whenever the notification handler's callback returns a rejected promise
+
+**Callback arguments:**
+
+`@param {Error} error - Error details`
+
+`@param {Notification} notification - Notification of the handler`
+
 ## reconnected
 
 Triggered when the current session has reconnected to Kuzzle after a disconnection, and only if `autoReconnect` is set to `true`.

src/Kuzzle.ts

@@ -73,6 +73,7 @@ export class Kuzzle extends KuzzleEventEmitter {
    * List of every events emitted by the SDK.
    */
   public events = [
+    'callbackError',
     'connected',
     'discarded',
     'disconnected',

src/core/Room.js

@@ -80,7 +80,23 @@ class Room {
       data.volatile && data.volatile.sdkInstanceId === this.kuzzle.protocol.id;
 
     if (this.subscribeToSelf || !fromSelf) {
-      this.callback(data);
+      try {
+        const callbackResponse = this.callback(data);
+
+        if ( callbackResponse !== null
+          && typeof callbackResponse === 'object'
+          && typeof callbackResponse.then === 'function'
+          && typeof callbackResponse.catch === 'function'
+        ) {
+          callbackResponse
+            .catch(error => {
+              this.kuzzle.emit('callbackError', { error, notification: data });
+            });
+        }
+      }
+      catch (error) {
+        this.kuzzle.emit('callbackError', { error, notification: data });
+      }
     }
   }
 }

test/core/room.test.js

@@ -1,13 +1,12 @@
-const
-  Room = require('../../src/core/Room'),
-  { KuzzleEventEmitter } = require('../../src/core/KuzzleEventEmitter'),
-  sinon = require('sinon'),
-  should = require('should');
+const sinon = require('sinon');
+const should = require('should');
+
+const Room = require('../../src/core/Room');
+const { KuzzleEventEmitter } = require('../../src/core/KuzzleEventEmitter');
 
 describe('Room', () => {
-  const
-    eventEmitter = new KuzzleEventEmitter(),
-    options = {opt: 'in'};
+  const eventEmitter = new KuzzleEventEmitter();
+  const options = {opt: 'in'};
 
   let controller;
 
@@ -22,7 +21,8 @@ describe('Room', () => {
           eventEmitter.removeListener(evt, listener);
         },
         tokenExpired: sinon.stub(),
-        protocol: new KuzzleEventEmitter()
+        protocol: new KuzzleEventEmitter(),
+        emit: sinon.stub(),
       },
       tokenExpired: sinon.stub()
     };
@@ -32,9 +32,8 @@ describe('Room', () => {
 
   describe('constructor', () => {
     it('should create a Room instance with good properties', () => {
-      const
-        body = {foo: 'bar'},
-        cb = sinon.stub();
+      const body = {foo: 'bar'};
+      const cb = sinon.stub();
 
       controller.kuzzle.autoResubscribe = 'default';
 
@@ -85,41 +84,37 @@ describe('Room', () => {
     });
 
     it('should handle autoResubscribe option', () => {
-      const
-        body = {foo: 'bar'},
-        cb = sinon.stub();
+      const body = {foo: 'bar'};
+      const cb = sinon.stub();
 
       controller.kuzzle.autoResubscribe = 'default';
 
-      const
-        room1 = new Room(
-          controller, 'index', 'collection', body, cb, {autoResubscribe: true}),
-        room2 = new Room(
-          controller, 'index', 'collection', body, cb,
-          {autoResubscribe: false}),
-        room3 = new Room(
-          controller, 'index', 'collection', body, cb,
-          {autoResubscribe: 'foobar'});
+      const room1 = new Room(
+        controller, 'index', 'collection', body, cb, {autoResubscribe: true});
+      const room2 = new Room(
+        controller, 'index', 'collection', body, cb,
+        {autoResubscribe: false});
+      const room3 = new Room(
+        controller, 'index', 'collection', body, cb,
+        {autoResubscribe: 'foobar'});
 
       should(room1.autoResubscribe).be.a.Boolean().and.be.True();
       should(room2.autoResubscribe).be.a.Boolean().and.be.False();
       should(room3.autoResubscribe).be.equal('default');
     });
 
     it('should handle subscribeToSelf option', () => {
-      const
-        body = {foo: 'bar'},
-        cb = sinon.stub();
-
-      const
-        room1 = new Room(
-          controller, 'index', 'collection', body, cb, {subscribeToSelf: true}),
-        room2 = new Room(
-          controller, 'index', 'collection', body, cb,
-          {subscribeToSelf: false}),
-        room3 = new Room(
-          controller, 'index', 'collection', body, cb,
-          {subscribeToSelf: 'foobar'});
+      const body = {foo: 'bar'};
+      const cb = sinon.stub();
+
+      const room1 = new Room(
+        controller, 'index', 'collection', body, cb, {subscribeToSelf: true});
+      const room2 = new Room(
+        controller, 'index', 'collection', body, cb,
+        {subscribeToSelf: false});
+      const room3 = new Room(
+        controller, 'index', 'collection', body, cb,
+        {subscribeToSelf: 'foobar'});
 
       should(room1.subscribeToSelf).be.a.Boolean().and.be.True();
       should(room2.subscribeToSelf).be.a.Boolean().and.be.False();
@@ -140,17 +135,16 @@ describe('Room', () => {
     });
 
     it('should call realtime/subscribe action with subscribe filters and return a promise that resolve the roomId and channel', () => {
-      const
-        opts = {
-          opt: 'in',
-          scope: 'in',
-          state: 'done',
-          users: 'all',
-          volatile: {bar: 'foo'}
-        },
-        body = {foo: 'bar'},
-        cb = sinon.stub(),
-        room = new Room(controller, 'index', 'collection', body, cb, opts);
+      const opts = {
+        opt: 'in',
+        scope: 'in',
+        state: 'done',
+        users: 'all',
+        volatile: {bar: 'foo'}
+      };
+      const body = {foo: 'bar'};
+      const cb = sinon.stub();
+      const room = new Room(controller, 'index', 'collection', body, cb, opts);
 
       return room.subscribe()
         .then(res => {
@@ -173,17 +167,16 @@ describe('Room', () => {
     });
 
     it('should set "id" and "channel" properties', () => {
-      const
-        opts = {
-          opt: 'in',
-          scope: 'in',
-          state: 'done',
-          users: 'all',
-          volatile: {bar: 'foo'}
-        },
-        body = {foo: 'bar'},
-        cb = sinon.stub(),
-        room = new Room(controller, 'index', 'collection', body, cb, opts);
+      const opts = {
+        opt: 'in',
+        scope: 'in',
+        state: 'done',
+        users: 'all',
+        volatile: {bar: 'foo'}
+      };
+      const body = {foo: 'bar'};
+      const cb = sinon.stub();
+      const room = new Room(controller, 'index', 'collection', body, cb, opts);
 
       return room.subscribe()
         .then(() => {
@@ -193,17 +186,16 @@ describe('Room', () => {
     });
 
     it('should call _channelListener while receiving data on the current channel', () => {
-      const
-        opts = {
-          opt: 'in',
-          scope: 'in',
-          state: 'done',
-          users: 'all',
-          volatile: {bar: 'foo'}
-        },
-        body = {foo: 'bar'},
-        cb = sinon.stub(),
-        room = new Room(controller, 'index', 'collection', body, cb, opts);
+      const opts = {
+        opt: 'in',
+        scope: 'in',
+        state: 'done',
+        users: 'all',
+        volatile: {bar: 'foo'}
+      };
+      const body = {foo: 'bar'};
+      const cb = sinon.stub();
+      const room = new Room(controller, 'index', 'collection', body, cb, opts);
 
       room._channelListener = sinon.stub();
 
@@ -248,9 +240,8 @@ describe('Room', () => {
   });
 
   describe('_channelListener', () => {
-    let
-      cb,
-      room;
+    let cb;
+    let room;
 
     beforeEach(() => {
       cb = sinon.stub();
@@ -333,6 +324,22 @@ describe('Room', () => {
       should(cb).not.be.called();
       should(controller.kuzzle.tokenExpired).be.called();
     });
-  });
 
+    it('should emit an event on callback promise rejection', async () => {
+      const data = {foo: 'bar'};
+      const callbackError = new Error('callbackPromiseRejection');
+
+      cb.rejects(callbackError);
+
+      await room._channelListener(data);
+
+      should(cb)
+        .be.calledOnce()
+        .be.calledWith(data);
+
+      should(controller.kuzzle.emit)
+        .be.calledOnce()
+        .be.calledWithMatch('callbackError', { error: callbackError });
+    });
+  });
 });

test/kuzzle/listenersManagement.test.js

@@ -21,6 +21,7 @@ describe('Kuzzle listeners management', () => {
 
   it('should only listen to allowed events', () => {
     const knownEvents = [
+      'callbackError',
       'connected',
       'discarded',
       'disconnected',