kuzzle 2.14.10 → 2.14.14

package/lib/core/realtime/hotelClerk.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,665 +19,461 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-'use strict';
-
-const Bluebird = require('bluebird');
-
-const { Request, RequestContext } = require('../../api/request');
-const kerror = require('../../kerror');
-const debug = require('../../util/debug')('kuzzle:realtime:hotelClerk');
-const {
-  getCollections,
-  toKoncordeIndex,
-} = require('../../util/koncordeCompat');
-
-const realtimeError = kerror.wrap('core', 'realtime');
-
-const CHANNEL_ALLOWED_VALUES = ['all', 'in', 'out', 'none'];
-
-class Channel {
-  constructor (roomId, { scope='all', users='none', propagate=true } = {}) {
-    this.scope = scope;
-    this.users = users;
-    this.cluster = propagate;
-
-    if (! CHANNEL_ALLOWED_VALUES.includes(this.scope)) {
-      throw realtimeError.get('invalid_scope');
-    }
-
-    if (! CHANNEL_ALLOWED_VALUES.includes(this.users)) {
-      throw realtimeError.get('invalid_users');
-    }
-
-    this.name = `${roomId}-${global.kuzzle.hash(this)}`;
-  }
-}
-
-class Subscription {
-  constructor (index, collection, filters, roomId, connectionId, user) {
-    this.index = index;
-    this.collection = collection;
-    this.filters = filters;
-    this.roomId = roomId;
-    this.connectionId = connectionId;
-    this.kuid = user && user._id || null;
-  }
-}
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotelClerk = void 0;
+const bluebird_1 = __importDefault(require("bluebird"));
+const request_1 = require("../../api/request");
+const kerror_1 = __importDefault(require("../../kerror"));
+const debug_1 = __importDefault(require("../../util/debug"));
+const koncordeCompat_1 = require("../../util/koncordeCompat");
+const channel_1 = require("./channel");
+const connectionRooms_1 = require("./connectionRooms");
+const room_1 = require("./room");
+const subscription_1 = require("./subscription");
+const realtimeError = kerror_1.default.wrap('core', 'realtime');
+const debug = (0, debug_1.default)('kuzzle:realtime:hotelClerk');
+/**
+ * The HotelClerk is responsible of keeping the list of rooms and subscriptions
+ * made to those rooms.
+ *
+ * When a subscription is made to a room, the HotelClerk link the connection
+ * to a channel of this room. Each channel represents a specific configuration
+ * about which kind of notification the subscriber should receive (e.g. scope in/out)
+ *
+ * When an user is subscribing, we send him back the channel he is subscribing to.
+ *
+ * Here stop the role of the HotelClerk, then the notifier will select the channels
+ * according to the notification and notify them.
+ */
 class HotelClerk {
-  constructor (realtimeModule) {
-    this.module = realtimeModule;
-
+    constructor(realtimeModule) {
+        /**
+         * Number of created rooms.
+         *
+         * Used with the "subscriptionRooms" configuration limit.
+         */
+        this.roomsCount = 0;
+        /**
+         * Current realtime rooms.
+         *
+         * This object is used by the notifier to list wich channel has to be notified
+         * when a subscription scope is matching.
+         * It's also used to notify channels when an user join/exit a room.
+         *
+         * Map<roomId, Room>
+         */
+        this.rooms = new Map();
+        /**
+         * Current subscribing connections handled by the HotelClerk.
+         *
+         * Each connection can subscribe to many rooms with different volatile data.
+         *
+         * This object is used to keep track of all subscriptions made by a connection
+         * to be able to unsubscribe when a connection is removed.
+         *
+         * Map<connectionId, ConnectionRooms>
+         */
+        this.subscriptions = new Map();
+        this.module = realtimeModule;
+        this.koncorde = global.kuzzle.koncorde;
+    }
     /**
-     * Number of created rooms. Used with the "subscriptionRooms"
-     * configuration limit
+     * Registers the ask events.
      */
-    this.roomsCount = 0;
-
+    async init() {
+        /**
+         * Create a new, empty room.
+         * @param {string} index
+         * @param {string} collection
+         * @param {string} roomId
+         * @returns {boolean} status indicating if the room was created or not
+         */
+        global.kuzzle.onAsk('core:realtime:room:create', (index, collection, roomId) => this.newRoom(index, collection, roomId));
+        /**
+         * Joins an existing room.
+         * @param  {Request} request
+         * @returns {Promise}
+         */
+        global.kuzzle.onAsk('core:realtime:join', request => this.join(request));
+        /**
+         * Return the list of index, collection, rooms (+ their users count)
+         * on all index/collection pairs that the requesting user is allowed to
+         * subscribe
+         *
+         * @param  {User} user
+         * @return {number}
+         * @throws {NotFoundError} If the roomId does not exist
+         */
+        global.kuzzle.onAsk('core:realtime:list', user => this.list(user));
+        /**
+         * Given an index, returns the list of collections having subscriptions
+         * on them.
+         * @param  {string} index
+         * @return {Array.<string>}
+         */
+        global.kuzzle.onAsk('core:realtime:collections:get', index => this.listCollections(index));
+        /**
+         * Removes a user and all their subscriptions.
+         * @param  {string} connectionId
+         */
+        global.kuzzle.onAsk('core:realtime:connection:remove', connectionId => this.removeConnection(connectionId));
+        /**
+         * Adds a new user subscription
+         * @param  {Request} request
+         * @return {Object|null}
+         */
+        global.kuzzle.onAsk('core:realtime:subscribe', request => this.subscribe(request));
+        /**
+         * Unsubscribes a user from a room
+         * @param {string} connectionId
+         * @param {string} roomId
+         * @param {string} kuid
+         * @param {boolean} [notify]
+         */
+        global.kuzzle.onAsk('core:realtime:unsubscribe', (connectionId, roomId, notify) => {
+            return this.unsubscribe(connectionId, roomId, notify);
+        });
+        /**
+         * Clear the hotel clerk and properly disconnect connections.
+         */
+        global.kuzzle.on('kuzzle:shutdown', () => this.clearConnections());
+        /**
+         * Clear subscriptions when a connection is dropped
+         */
+        global.kuzzle.on('connection:remove', connection => {
+            this.removeConnection(connection.id)
+                .catch(err => global.kuzzle.log.info(err));
+        });
+    }
     /**
-     * A simple list of rooms, containing their associated filter and how many
-     * users have subscribed to it
-     *
-     * Example: subscribing to a chat room where the subject is Kuzzle
-     *  rooms = Map<roomId, room>
-     *
-     * Where:
-     *   - the room ID is the filter ID (e.g. 'f45de4d8ef4f3ze4ffzer85d4fgkzm41')
-     *   - room is an object with the following properties:
-     *   {
-     *      // list of users subscribing to this room
-     *      customers: Set([ 'connectionId' ]),
-     *
-     *      // room channels
-     *      channels: {
-     *
-     *        // channel ID
-     *        'roomId-<configurationHash>': {
-     *
-     *          // request scope filter, default: 'all'
-     *          scope: 'all|in|out|none',
+     * Subscribe a connection to a realtime room.
      *
-     *          // filter users notifications, default: 'none'
-     *          users: 'all|in|out|none',
+     * The room will be created if it does not already exists.
      *
-     *          // should propagate notification to the cluster
-     *          // (used for plugin subscriptions)
-     *          cluster: true|false
-     *        }
-     *      },
-     *      index: 'index',
-     *      collection: 'collection',
-     *      // the room unique identifier
-     *      id: 'id',
-     *    }
-     *  }
-     */
-    this.rooms = new Map();
-
-    /**
-     * In addition to this.rooms, this.customers allows managing users and their rooms
-     * Example for a customer who subscribes to the room 'chat-room-kuzzle'
-     * customers = Map.<connection id, customer rooms>
+     * Notify other subscribers on this room about this new subscription
      *
-     * Where a customer room is an object with the following properties:
-     *   Map.<customer ID, Map.<room Id, volatile data>>
+     * @throws Throws if the user has already subscribed to this room name
+     *         (just for rooms with same name, there is no error if the room
+     *         has a different name with same filter) or if there is an error
+     *         during room creation
      */
-    this.customers = new Map();
-  }
-
-  async init () {
+    async subscribe(request) {
+        const { index, collection } = request.input.resource;
+        if (!index) {
+            return kerror_1.default.reject('api', 'assert', 'missing_argument', 'index');
+        }
+        if (!collection) {
+            return kerror_1.default.reject('api', 'assert', 'missing_argument', 'collection');
+        }
+        /*
+         * /!\ This check is a duplicate to the one already made by the
+         * funnel controller. THIS IS INTENTIONAL.
+         *
+         * This is to prevent subscriptions to be made on dead
+         * connections. And between the funnel and here, there is
+         * time for a connection to drop, so while the check
+         * on the funnel is useful for many use cases, this one
+         * is made on the very last moment and is essential to ensure
+         * that no zombie subscription can be performed
+         */
+        if (!global.kuzzle.router.isConnectionAlive(request.context)) {
+            return null;
+        }
+        let normalized;
+        try {
+            normalized = this.koncorde.normalize(request.input.body, (0, koncordeCompat_1.toKoncordeIndex)(index, collection));
+        }
+        catch (e) {
+            throw kerror_1.default.get('api', 'assert', 'koncorde_dsl_error', e.message);
+        }
+        this.createRoom(normalized);
+        const { channel, subscribed } = await this.subscribeToRoom(normalized.id, request);
+        if (subscribed) {
+            global.kuzzle.emit('core:realtime:subscribe:after', normalized.id);
+            // @deprecated -- to be removed in next major version
+            // we have to recreate the old "diff" object
+            await global.kuzzle.pipe('core:hotelClerk:addSubscription', {
+                changed: subscribed,
+                collection,
+                connectionId: request.context.connection.id,
+                filters: normalized.filter,
+                index,
+                roomId: normalized.id,
+            });
+        }
+        const subscription = new subscription_1.Subscription(index, collection, request.input.body, normalized.id, request.context.connection.id, request.context.user);
+        global.kuzzle.emit('core:realtime:user:subscribe:after', subscription);
+        return {
+            channel,
+            roomId: normalized.id,
+        };
+    }
     /**
-     * Create a new, empty room.
-     * @param {string} index
-     * @param {string} collection
-     * @param {string} roomId
-     * @returns {boolean} status indicating if the room was created or not
+     * Returns the list of collections of an index with realtime rooms.
      */
-    global.kuzzle.onAsk(
-      'core:realtime:room:create',
-      (index, collection, roomId) => this.newRoom(index, collection, roomId));
-
+    listCollections(index) {
+        return (0, koncordeCompat_1.getCollections)(this.koncorde, index);
+    }
     /**
-     * Joins an existing room.
-     * @param  {Request} request
-     * @returns {Promise}
+     * Joins an existing realtime room.
+     *
+     * The room may exists on another cluster node, if it's the case, the normalized
+     * filters will be fetched from the cluster.
      */
-    global.kuzzle.onAsk(
-      'core:realtime:join', request => this.join(request));
-
+    async join(request) {
+        const roomId = request.input.body.roomId;
+        if (!this.rooms.has(roomId)) {
+            const normalized = await global.kuzzle.ask('cluster:realtime:filters:get', roomId);
+            if (!normalized) {
+                throw realtimeError.get('room_not_found', roomId);
+            }
+            this.createRoom(normalized);
+        }
+        const { channel, cluster, subscribed } = await this.subscribeToRoom(roomId, request);
+        if (cluster && subscribed) {
+            global.kuzzle.emit('core:realtime:subscribe:after', roomId);
+        }
+        return {
+            channel,
+            roomId,
+        };
+    }
     /**
-     * Return the list of index, collection, rooms (+ their users count)
+     * Return the list of index, collection, rooms and subscribing connections
      * on all index/collection pairs that the requesting user is allowed to
-     * subscribe
-     *
-     * @param  {User} user
-     * @return {number}
-     * @throws {NotFoundError} If the roomId does not exist
+     * subscribe.
      */
-    global.kuzzle.onAsk('core:realtime:list', user => this.list(user));
-
+    async list(user) {
+        // We need the room list from the cluster's full state, NOT the one stored
+        // in Koncorde: the latter also contains subscriptions created by the
+        // framework (or by plugins), and we don't want those to appear in the API
+        const fullStateRooms = await global.kuzzle.ask('cluster:realtime:room:list');
+        const isAllowedRequest = new request_1.KuzzleRequest({
+            action: 'subscribe',
+            controller: 'realtime',
+        }, {});
+        for (const [index, collections] of Object.entries(fullStateRooms)) {
+            isAllowedRequest.input.resource.index = index;
+            const toRemove = await bluebird_1.default.filter(Object.keys(collections), collection => {
+                isAllowedRequest.input.resource.collection = collection;
+                return !user.isActionAllowed(isAllowedRequest);
+            });
+            for (const collection of toRemove) {
+                delete fullStateRooms[index][collection];
+            }
+        }
+        return fullStateRooms;
+    }
     /**
-     * Given an index, returns the list of collections having subscriptions
-     * on them.
-     * @param  {string} index
-     * @return {Array.<string>}
+     * Removes a connections and unsubscribe it from every subscribed rooms.
+     *
+     * Usually called when an user has been disconnected from Kuzzle.
      */
-    global.kuzzle.onAsk(
-      'core:realtime:collections:get',
-      index => this.listCollections(index));
-
+    async removeConnection(connectionId, notify = true) {
+        const connectionRooms = this.subscriptions.get(connectionId);
+        if (!connectionRooms) {
+            // No need to raise an error if the connection does not have room subscriptions
+            return;
+        }
+        await bluebird_1.default.map(connectionRooms.roomIds, (roomId) => (this.unsubscribe(connectionId, roomId, notify).catch(global.kuzzle.log.error)));
+    }
     /**
-     * Removes a user and all their subscriptions.
-     * @param  {string} connectionId
+     * Clear all connections made to this node:
+     *   - trigger appropriate core events
+     *   - send user exit room notifications
      */
-    global.kuzzle.onAsk(
-      'core:realtime:user:remove',
-      connectionId => this.removeUser(connectionId));
-
+    async clearConnections() {
+        await bluebird_1.default.map(this.subscriptions.keys(), (connectionId) => (this.removeConnection(connectionId, false)));
+    }
     /**
-     * Adds a new user subscription
-     * @param  {Request} request
-     * @return {Object|null}
+     * Register a new subscription
+     *  - save the subscription on the provided room with volatile data
+     *  - add the connection to the list of active connections of the room
      */
-    global.kuzzle.onAsk(
-      'core:realtime:subscribe',
-      request => this.subscribe(request));
-
+    registerSubscription(connectionId, roomId, volatile) {
+        debug('Add room %s for connection %s', roomId, connectionId);
+        let connectionRooms = this.subscriptions.get(connectionId);
+        if (!connectionRooms) {
+            connectionRooms = new connectionRooms_1.ConnectionRooms();
+            this.subscriptions.set(connectionId, connectionRooms);
+        }
+        connectionRooms.addRoom(roomId, volatile);
+        this.rooms.get(roomId).addConnection(connectionId);
+    }
     /**
-     * Unsubscribes a user from a room
-     * @param {string} connectionId
-     * @param {string} roomId
-     * @param {string} kuid
-     * @param {boolean} [notify]
+     * Create new room if needed
+     *
+     * @returns {void}
      */
-    global.kuzzle.onAsk(
-      'core:realtime:unsubscribe',
-      (connectionId, roomId, notify) => {
-        return this.unsubscribe(connectionId, roomId, notify);
-      });
-  }
-
-  /**
-   * Link a user connection to a room.
-   * Create a new room if one doesn't already exist.
-   * Notify other subscribers on this room about this new subscription
-   *
-   * @param {Request} request
-   * @return {Promise.<UserNotification|null>}
-   * @throws Throws if the user has already subscribed to this room name
-   *         (just for rooms with same name, there is no error if the room
-   *         has a different name with same filter) or if there is an error
-   *         during room creation
-   */
-  async subscribe (request) {
-    const { index, collection } = request.input.resource;
-
-    if (! index) {
-      return kerror.reject('api', 'assert', 'missing_argument', 'index');
+    createRoom(normalized) {
+        const { index: koncordeIndex, id: roomId } = normalized;
+        const { index, collection } = (0, koncordeCompat_1.fromKoncordeIndex)(koncordeIndex);
+        if (this.rooms.has(normalized.id)) {
+            return;
+        }
+        const roomsLimit = global.kuzzle.config.limits.subscriptionRooms;
+        if (roomsLimit > 0 && this.roomsCount >= roomsLimit) {
+            throw realtimeError.get('too_many_rooms');
+        }
+        this.koncorde.store(normalized);
+        global.kuzzle.emit('core:realtime:room:create:after', normalized);
+        // @deprecated -- to be removed in the next major version of kuzzle
+        global.kuzzle.emit('room:new', { collection, index, roomId });
+        /*
+          In some very rare cases, the room may have been created between
+          the beginning of the function executed at the end of normalize,
+          and this one
+    
+          Before incrementing the rooms count, we have to make sure this
+          is not the case to ensure our counter is right
+          */
+        if (this.newRoom(index, collection, roomId)) {
+            this.roomsCount++;
+        }
     }
-
-    if (! collection) {
-      return kerror.reject('api', 'assert', 'missing_argument', 'collection');
-    }
-
-    /*
-     * /!\ This check is a duplicate to the one already made by the
-     * funnel controller. THIS IS INTENTIONAL.
+    /**
+     * Remove a connection from a room.
+     *
+     * Also delete the rooms if it was the last connection subscribing to it.
      *
-     * This is to prevent subscriptions to be made on dead
-     * connections. And between the funnel and here, there is
-     * time for a connection to drop, so while the check
-     * on the funnel is useful for many use cases, this one
-     * is made on the very last moment and is essential to ensure
-     * that no zombie subscription can be performed
      */
-    if (! global.kuzzle.router.isConnectionAlive(request.context)) {
-      return null;
-    }
-
-    let normalized;
-
-    try {
-      normalized = global.kuzzle.koncorde.normalize(
-        request.input.body,
-        toKoncordeIndex(index, collection));
-    }
-    catch (e) {
-      throw kerror.get('api', 'assert', 'koncorde_dsl_error', e.message);
-    }
-
-    this._createRoom(normalized);
-
-    const { channel, subscribed } = await this._subscribeToRoom(
-      normalized.id,
-      request);
-
-    if (subscribed) {
-      global.kuzzle.emit('core:realtime:subscribe:after', normalized.id);
-
-      // @deprecated -- to be removed in next major version
-      // we have to recreate the old "diff" object -_-
-      await global.kuzzle.pipe('core:hotelClerk:addSubscription', {
-        changed: subscribed,
-        collection,
-        connectionId: request.context.connection.id,
-        filters: normalized.filter,
-        index,
-        roomId: normalized.id,
-      });
-    }
-
-    const subscription = new Subscription(
-      index,
-      collection,
-      request.input.body,
-      normalized.id,
-      request.context.connection.id,
-      request.context.user);
-
-    global.kuzzle.emit('core:realtime:user:subscribe:after', subscription);
-
-    return {
-      channel,
-      roomId: normalized.id,
-    };
-  }
-
-  /**
-   * Given an index, returns an array of collections on which some filters are
-   * registered
-   * @param {string} index
-   * @returns {Array.<string>}
-   */
-  listCollections (index) {
-    return getCollections(global.kuzzle.koncorde, index);
-  }
-
-  /**
-   * Joins an existing room.
-   *
-   * @param {Request} request
-   * @returns {Promise.<Object>}
-   */
-  async join (request) {
-    const roomId = request.input.body.roomId;
-
-    if (! this.rooms.has(roomId)) {
-      const normalized = await global.kuzzle.ask(
-        'cluster:realtime:filters:get',
-        roomId);
-
-      if (!normalized) {
-        throw realtimeError.get('room_not_found', roomId);
-      }
-
-      this._createRoom(normalized);
-    }
-
-    const response = await this._subscribeToRoom(roomId, request);
-
-    if (response.cluster && response.subscribed) {
-      global.kuzzle.emit('core:realtime:subscribe:after', roomId);
-    }
-
-    return {
-      channel: response.channel,
-      roomId,
-    };
-  }
-
-  /**
-   * Return the list of index, collection, rooms (+ their number of subscribers)
-   * on all index/collection pairs that the requesting user is allowed to
-   * subscribe
-   *
-   * Returned object looks like this:
-   *   {
-   *     <index>: {
-   *       <collection>: {
-   *         <roomId>: <number of subscribers>
-   *       }
-   *     }
-   *   }
-   *
-   * @param {User} user
-   * @returns {Promise.<Object>} resolve an object listing all rooms subscribed
-   *                             by the connected user
-   */
-  async list (user) {
-    // We need the room list from the cluster's full state, NOT the one stored
-    // in Koncorde: the latter also contains subscriptions created by the
-    // framework (or by plugins), and we don't want those to appear in the API
-    const list = await global.kuzzle.ask('cluster:realtime:room:list');
-
-    const isAllowedRequest = new Request({
-      action: 'subscribe',
-      controller: 'realtime',
-    });
-
-    for (const index of Object.keys(list)) {
-      isAllowedRequest.input.resource.index = index;
-
-      const toRemove = await Bluebird.filter(
-        Object.keys(list[index]),
-        collection => {
-          isAllowedRequest.input.resource.collection = collection;
-
-          return !user.isActionAllowed(isAllowedRequest);
+    async unsubscribe(connectionId, roomId, notify = true) {
+        const connectionRooms = this.subscriptions.get(connectionId);
+        const requestContext = new request_1.RequestContext({
+            connection: { id: connectionId }
+        });
+        if (!connectionRooms) {
+            throw realtimeError.get('not_subscribed', connectionId, roomId);
+        }
+        const volatile = connectionRooms.getVolatile(roomId);
+        if (volatile === undefined) {
+            throw realtimeError.get('not_subscribed', connectionId, roomId);
+        }
+        if (connectionRooms.count > 1) {
+            connectionRooms.removeRoom(roomId);
+        }
+        else {
+            this.subscriptions.delete(connectionId);
+        }
+        const room = this.rooms.get(roomId);
+        if (!room) {
+            global.kuzzle.log.error(`Cannot remove room "${roomId}": room not found`);
+            throw realtimeError.get('room_not_found', roomId);
+        }
+        for (const channel of Object.keys(room.channels)) {
+            global.kuzzle.entryPoint.leaveChannel(channel, connectionId);
+        }
+        room.removeConnection(connectionId);
+        if (room.size === 0) {
+            await this.removeRoom(roomId);
+        }
+        // even if the room is deleted for this node, another one may need the
+        // notification
+        const request = new request_1.Request({
+            action: 'unsubscribe',
+            collection: room.collection,
+            controller: 'realtime',
+            index: room.index,
+            volatile,
+        }, requestContext);
+        await this.module.notifier.notifyUser(roomId, request, 'out', { count: room.size });
+        // Do not send an unsubscription notification if the room has been destroyed
+        // @aschen Why ?
+        if (notify
+            && this.rooms.has(roomId)
+            && room.channels.size > 0) {
+            await global.kuzzle.pipe('core:realtime:unsubscribe:after', roomId);
+            // @deprecated -- to be removed in next major version
+            await global.kuzzle.pipe('core:hotelClerk:removeRoomForCustomer', {
+                requestContext,
+                room: {
+                    collection: room.collection,
+                    id: roomId,
+                    index: room.index,
+                },
+            });
+        }
+        const kuid = global.kuzzle.tokenManager.getKuidFromConnection(connectionId);
+        const subscription = new subscription_1.Subscription(room.index, room.collection, undefined, roomId, connectionId, { _id: kuid });
+        global.kuzzle.emit('core:realtime:user:unsubscribe:after', {
+            /* @deprecated */
+            requestContext,
+            /* @deprecated */
+            room: {
+                collection: room.collection,
+                id: roomId,
+                index: room.index,
+            },
+            subscription,
         });
-
-      for (const collection of toRemove) {
-        delete list[index][collection];
-      }
-    }
-
-    return list;
-  }
-
-  /**
-   * This function will delete a user from this.customers, and
-   * decrement the subscribers count in all rooms where he has subscribed to
-   * Usually called on a user disconnection event
-   *
-   * @param {string} connectionId
-   */
-  async removeUser (connectionId) {
-    const customer = this.customers.get(connectionId);
-
-    if (!customer) {
-      // No need to raise an error if the connection has already been cleaned up
-      return;
-    }
-
-    await Bluebird.map(customer.keys(), roomId => {
-      return this.unsubscribe(connectionId, roomId)
-        .catch(err => global.kuzzle.log.error(err));
-    });
-  }
-
-  /**
-   * Associate the room to the connection id in this.clients
-   * Allow to manage later disconnection and delete socket/rooms/...
-   *
-   * @param {string} connectionId
-   * @param {string} roomId
-   * @param {object} volatile
-   */
-  _addRoomForCustomer (connectionId, roomId, volatile) {
-    debug('Add room %s for customer %s', roomId, connectionId);
-
-    let customer = this.customers.get(connectionId);
-
-    if (! customer) {
-      customer = new Map();
-      this.customers.set(connectionId, customer);
-    }
-
-    this.rooms.get(roomId).customers.add(connectionId);
-    customer.set(roomId, volatile);
-  }
-
-  /**
-   * Create new room if needed
-   *
-   * @this HotelClerk
-   *
-   * @param {NormalizedFilter} normalized - Obtained with Koncorde.normalize
-   * @param {Object} [options]
-   *
-   * @returns {void}
-   */
-  _createRoom (normalized) {
-    const { index: koncordeIndex, id: roomId } = normalized;
-    const [index, collection] = koncordeIndex.split('/');
-
-    if (this.rooms.has(normalized.id)) {
-      return;
-    }
-
-    const roomsLimit = global.kuzzle.config.limits.subscriptionRooms;
-
-    if ( roomsLimit > 0 && this.roomsCount >= roomsLimit ) {
-      throw realtimeError.get('too_many_rooms');
-    }
-
-    global.kuzzle.koncorde.store(normalized);
-
-    global.kuzzle.emit('core:realtime:room:create:after', normalized);
-
-    // @deprecated -- to be removed in the next major version of kuzzle
-    global.kuzzle.emit('room:new', { collection, index, roomId });
-
-    /*
-      In some very rare cases, the room may have been created between
-      the beginning of the function executed at the end of normalize,
-      and this one
-
-      Before incrementing the rooms count, we have to make sure this
-      is not the case to ensure our counter is right
-      */
-    if (this.newRoom(index, collection, roomId)) {
-      this.roomsCount++;
-    }
-  }
-
-  /**
-   * Remove the room from subscribed room from the user
-   * Return the roomId in user mapping
-   *
-   * @this HotelClerk
-   * @param {string} connectionId
-   * @param {string} roomId
-   * @param {Boolean} [notify]
-   * @returns {Promise}
-   */
-  async unsubscribe (connectionId, roomId, notify = true) {
-    const customer = this.customers.get(connectionId);
-    const requestContext = new RequestContext({
-      connection: { id: connectionId }
-    });
-
-    if (! customer) {
-      throw realtimeError.get('not_subscribed', connectionId, roomId);
-    }
-
-    const volatile = customer.get(roomId);
-
-    if (volatile === undefined) {
-      throw realtimeError.get('not_subscribed', connectionId, roomId);
-    }
-
-    if (customer.size > 1) {
-      customer.delete(roomId);
-    }
-    else {
-      this.customers.delete(connectionId);
-    }
-
-    const room = this.rooms.get(roomId);
-
-    if (! room) {
-      global.kuzzle.log.error(`[hotelClerk] Cannot remove room "${roomId}": room not found`);
-      throw realtimeError.get('room_not_found', roomId);
-    }
-
-    for (const channel of Object.keys(room.channels)) {
-      global.kuzzle.entryPoint.leaveChannel(channel, connectionId);
-    }
-
-    if (room.customers.size === 1) {
-      this.roomsCount--;
-      this.rooms.delete(roomId);
-
-      await this._removeRoomFromRealtimeEngine(roomId);
-
-      room.customers = new Set();
-    }
-    else {
-      room.customers.delete(connectionId);
-    }
-
-    // even if the room is deleted for this node, another one may need the
-    // notification
-    const request = new Request(
-      {
-        action: 'unsubscribe',
-        collection: room.collection,
-        controller: 'realtime',
-        index: room.index,
-        volatile,
-      },
-      requestContext);
-
-    await this.module.notifier.notifyUser(roomId, request, 'out', {
-      count: room.customers.size
-    });
-
-    // Do not send an unsubscription notification if the room has been destroyed
-    if ( notify
-      && this.rooms.has(roomId)
-      && Object.keys(room.channels).length > 0
-    ) {
-      await global.kuzzle.pipe('core:realtime:unsubscribe:after', roomId);
-
-      // @deprecated -- to be removed in next major version
-      await global.kuzzle.pipe('core:hotelClerk:removeRoomForCustomer', {
-        requestContext,
-        room: {
-          collection: room.collection,
-          id: roomId,
-          index: room.index,
-        },
-      });
-    }
-
-    const kuid = global.kuzzle.tokenManager.getKuidFromConnection(connectionId);
-
-    const subscription = new Subscription(
-      room.index,
-      room.collection,
-      undefined,
-      roomId,
-      connectionId,
-      { _id: kuid });
-
-    global.kuzzle.emit('core:realtime:user:unsubscribe:after', {
-      /* @deprecated */
-      requestContext,
-      /* @deprecated */
-      room: {
-        collection: room.collection,
-        id: roomId,
-        index: room.index,
-      },
-      subscription,
-    });
-  }
-
-  /**
-   * Deletes a room if no user has subscribed to it, and removes it also from the
-   * real-time engine
-   *
-   * @param {string} roomId
-   */
-  async _removeRoomFromRealtimeEngine (roomId) {
-    // @deprecated -- to be removed in the next major version
-    try {
-      await global.kuzzle.pipe('room:remove', roomId);
-    }
-    catch (e) {
-      return;
-    }
-
-    // We have to ask the cluster to dispatch the room removal event.
-    // The cluster will also remove the room from Koncorde if no other node
-    // uses it.
-    // (this node may have no subscribers on it, but other nodes might)
-    await global.kuzzle.ask('cluster:realtime:room:remove', roomId);
-  }
-
-  /**
-   * Subscribes a user to an existing room.
-   *
-   * @param {string} roomId
-   * @param {Request} request
-   * @returns {Promise.<Object>}
-   */
-  async _subscribeToRoom (roomId, request) {
-    let subscribed = false;
-    let notifyPromise;
-    const channel = new Channel(roomId, request.input.args);
-    const connectionId = request.context.connection.id;
-    const customer = this.customers.get(connectionId);
-    const room = this.rooms.get(roomId);
-
-    if ( !customer || !customer.has(roomId)) {
-      subscribed = true;
-      this._addRoomForCustomer(connectionId, roomId, request.input.volatile);
-
-      notifyPromise = this.module.notifier.notifyUser(
-        roomId,
-        request,
-        'in',
-        { count: room.customers.size });
-    }
-    else {
-      notifyPromise = Bluebird.resolve();
     }
-
-    global.kuzzle.entryPoint.joinChannel(channel.name, connectionId);
-
-    if (! room.channels[channel.name]) {
-      room.channels[channel.name] = channel;
+    /**
+     * Deletes a room if no user has subscribed to it, and removes it also from the
+     * real-time engine
+     */
+    async removeRoom(roomId) {
+        this.roomsCount--;
+        this.rooms.delete(roomId);
+        // @deprecated -- to be removed in the next major version
+        try {
+            await global.kuzzle.pipe('room:remove', roomId);
+        }
+        catch (e) {
+            return;
+        }
+        // We have to ask the cluster to dispatch the room removal event.
+        // The cluster will also remove the room from Koncorde if no other node
+        // uses it.
+        // (this node may have no subscribers on it, but other nodes might)
+        await global.kuzzle.ask('cluster:realtime:room:remove', roomId);
     }
-
-    await notifyPromise;
-
-    return {
-      channel: channel.name,
-      cluster: channel.cluster,
-      subscribed,
-    };
-  }
-
-  /**
-   * Return the rooms a user has subscribed to.
-   * @param  {connectionId} connectionId
-   * @returns {Array.<string>}
-   */
-  getUserRooms (connectionId) {
-    const rooms = this.customers.get(connectionId);
-
-    if (rooms) {
-      return Array.from(rooms.keys());
+    /**
+     * Subscribes a connection to an existing room.
+     *
+     * The subscription is made on a configuration channel who will be created
+     * on the room if it does not already exists.
+     *
+     */
+    async subscribeToRoom(roomId, request) {
+        let subscribed = false;
+        let notifyPromise;
+        const { scope, users, propagate } = request.input.args;
+        const connectionId = request.context.connection.id;
+        const channel = new channel_1.Channel(roomId, { propagate, scope, users });
+        const connectionRooms = this.subscriptions.get(connectionId);
+        const room = this.rooms.get(roomId);
+        if (!connectionRooms || !connectionRooms.hasRoom(roomId)) {
+            subscribed = true;
+            this.registerSubscription(connectionId, roomId, request.input.volatile);
+            notifyPromise = this.module.notifier.notifyUser(roomId, request, 'in', { count: room.size });
+        }
+        else {
+            notifyPromise = bluebird_1.default.resolve();
+        }
+        global.kuzzle.entryPoint.joinChannel(channel.name, connectionId);
+        room.createChannel(channel);
+        await notifyPromise;
+        return {
+            channel: channel.name,
+            cluster: channel.cluster,
+            subscribed,
+        };
     }
-
-    return [];
-  }
-
-  /**
-   * Create an empty room in the RAM cache
-   * @param  {string} index
-   * @param  {string  } collection
-   * @param  {string} roomId
-   * @returns {boolean}
-   */
-  newRoom (index, collection, roomId) {
-    if (!this.rooms.has(roomId)) {
-      this.rooms.set(roomId, {
-        channels: {},
-        collection,
-        customers: new Set(),
-        id: roomId,
-        index,
-      });
-
-      return true;
+    /**
+     * Create an empty room in the RAM cache if it doesn't exists
+     *
+     * @returns True if a new room has been created
+     */
+    newRoom(index, collection, roomId) {
+        if (!this.rooms.has(roomId)) {
+            this.rooms.set(roomId, new room_1.Room(roomId, index, collection));
+            return true;
+        }
+        return false;
     }
-
-    return false;
-  }
 }
-
-module.exports = HotelClerk;
+exports.HotelClerk = HotelClerk;
+//# sourceMappingURL=hotelClerk.js.map