@soundworks/core 4.0.0-alpha.14 → 4.0.0-alpha.16

package/src/common/BaseStateManager.js

@@ -1,6 +1,7 @@
-import { isString, isFunction } from '@ircam/sc-utils';
+import { isString, isFunction, isPlainObject } from '@ircam/sc-utils';
 import SharedState from './BaseSharedState.js';
 import SharedStateCollection from './BaseSharedStateCollection.js';
+import PromiseStore from './PromiseStore.js';
 import {
   CREATE_REQUEST,
   CREATE_RESPONSE,
@@ -10,15 +11,14 @@ import {
   ATTACH_ERROR,
   OBSERVE_REQUEST,
   OBSERVE_RESPONSE,
+  OBSERVE_ERROR,
   OBSERVE_NOTIFICATION,
   UNOBSERVE_NOTIFICATION,
   DELETE_SCHEMA,
 } from './constants.js';
-import {
-  storeRequestPromise,
-  resolveRequest,
-  rejectRequest,
-} from './promise-store.js';
+
+export const kCreateCollectionController = Symbol('BaseStateManager::createCollectionController');
+export const kAttachInCollection = Symbol('BaseStateManager::attachInCollection');
 
 /**
  * @private
@@ -32,10 +32,13 @@ class BaseStateManager {
   constructor(id, transport) {
     this.client = { id, transport };
 
-    this._statesById = new Map();
-    this._observeListeners = new Map(); // Map <callback, filterSchemaName>
-    this._cachedSchemas = new Map();
-    this._observeRequestCallbacks = new Map();
+    this._statesById = new Map(); // <id, state>
+    this._cachedSchemas = new Map(); // <shemaName, definition>
+
+    this._observeListeners = new Set(); // Set <[observedSchemaName, callback, options]>
+    this._observeRequestCallbacks = new Map(); // Map <reqId, [observedSchemaName, callback, options]>
+
+    this._promiseStore = new PromiseStore();
 
     // ---------------------------------------------
     // CREATE
@@ -53,11 +56,11 @@ class BaseStateManager {
       const state = new SharedState(stateId, remoteId, schemaName, schema, this.client, true, this, initValues);
       this._statesById.set(state.id, state);
 
-      resolveRequest(reqId, state);
+      this._promiseStore.resolve(reqId, state);
     });
 
     this.client.transport.addListener(CREATE_ERROR, (reqId, msg) => {
-      rejectRequest(reqId, msg);
+      this._promiseStore.reject(reqId, msg);
     });
 
     // ---------------------------------------------
@@ -77,11 +80,11 @@ class BaseStateManager {
       const state = new SharedState(stateId, remoteId, schemaName, schema, this.client, false, this, currentValues);
       this._statesById.set(state.id, state);
 
-      resolveRequest(reqId, state);
+      this._promiseStore.resolve(reqId, state);
     });
 
     this.client.transport.addListener(ATTACH_ERROR, (reqId, msg) => {
-      rejectRequest(reqId, msg);
+      this._promiseStore.reject(reqId, msg);
     });
 
     // ---------------------------------------------
@@ -90,11 +93,18 @@ class BaseStateManager {
     this.client.transport.addListener(OBSERVE_RESPONSE, async (reqId, ...list) => {
       // retrieve the callback that have been stored in observe to make sure
       // we don't call another callback that may have been registered earlier.
-      const [callback, filterSchemaName] = this._observeRequestCallbacks.get(reqId);
+      const observeInfos = this._observeRequestCallbacks.get(reqId);
+      const [observedSchemaName, callback, options] = observeInfos;
+
+      // move observeInfos from `_observeRequestCallbacks` to `_observeListeners`
+      // to guarantee order of execution, @see not in `.observe`
       this._observeRequestCallbacks.delete(reqId);
+      this._observeListeners.add(observeInfos);
 
       const promises = list.map(([schemaName, stateId, nodeId]) => {
-        if (filterSchemaName === '*' || filterSchemaName === schemaName) {
+        const filter = this._filterObserve(observedSchemaName, schemaName, nodeId, options);
+
+        if (!filter) {
           return callback(schemaName, stateId, nodeId);
         } else {
           return Promise.resolve();
@@ -104,19 +114,29 @@ class BaseStateManager {
       await Promise.all(promises);
 
       const unsubscribe = () => {
-        this._observeListeners.delete(callback);
-        // no more listeners, we can stop receiving notification from the server
+        this._observeListeners.delete(observeInfos);
+
+        // no more listeners, we can stop receiving notifications from the server
         if (this._observeListeners.size === 0) {
           this.client.transport.emit(UNOBSERVE_NOTIFICATION);
         }
       };
 
-      resolveRequest(reqId, unsubscribe);
+      this._promiseStore.resolve(reqId, unsubscribe);
+    });
+
+    // Observe error can occur if observed schema name does not exists
+    this.client.transport.addListener(OBSERVE_ERROR, (reqId, msg) => {
+      this._observeRequestCallbacks.delete(reqId);
+      this._promiseStore.reject(reqId, msg);
     });
 
     this.client.transport.addListener(OBSERVE_NOTIFICATION, (schemaName, stateId, nodeId) => {
-      this._observeListeners.forEach((filterSchemaName, callback) => {
-        if (filterSchemaName === '*' || filterSchemaName === schemaName) {
+      this._observeListeners.forEach(observeInfos => {
+        const [observedSchemaName, callback, options] = observeInfos;
+        const filter = this._filterObserve(observedSchemaName, schemaName, nodeId, options);
+
+        if (!filter) {
           callback(schemaName, stateId, nodeId);
         }
       });
@@ -130,6 +150,21 @@ class BaseStateManager {
     });
   }
 
+  /** @private */
+  _filterObserve(observedSchemaName, schemaName, creatorId, options) {
+    let filter = true;
+    // schema name filter filer
+    if (observedSchemaName === null || observedSchemaName === schemaName) {
+      filter = false;
+    }
+    // filter state created by client if excludeLocal is true
+    if (options.excludeLocal === true && creatorId === this.client.id) {
+      filter = true;
+    }
+
+    return filter;
+  }
+
   /**
    * Create a `SharedState` instance from a registered schema.
    *
@@ -144,12 +179,24 @@ class BaseStateManager {
    */
   async create(schemaName, initValues = {}) {
     return new Promise((resolve, reject) => {
-      const reqId = storeRequestPromise(resolve, reject);
+      const reqId = this._promiseStore.add(resolve, reject, 'create-request');
       const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
       this.client.transport.emit(CREATE_REQUEST, reqId, schemaName, requireSchema, initValues);
     });
   }
 
+
+  /**
+   * @private
+   */
+  async [kCreateCollectionController](schemaName) {
+    return new Promise((resolve, reject) => {
+      const reqId = this._promiseStore.add(resolve, reject, 'create-collection-controller-request');
+      const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
+      this.client.transport.emit(CREATE_REQUEST, reqId, schemaName, requireSchema, {}, true);
+    });
+  }
+
   /**
    * Attach to an existing `SharedState` instance.
    *
@@ -166,13 +213,20 @@ class BaseStateManager {
    */
   async attach(schemaName, stateId = null) {
     return new Promise((resolve, reject) => {
-      // @todo - add a timeout
-      const reqId = storeRequestPromise(resolve, reject);
+      const reqId = this._promiseStore.add(resolve, reject, 'attach-request');
       const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
       this.client.transport.emit(ATTACH_REQUEST, reqId, schemaName, stateId, requireSchema);
     });
   }
 
+  async [kAttachInCollection](schemaName, stateId) {
+    return new Promise((resolve, reject) => {
+      const reqId = this._promiseStore.add(resolve, reject, 'attach-in-collection-request');
+      const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
+      this.client.transport.emit(ATTACH_REQUEST, reqId, schemaName, stateId, requireSchema, true);
+    });
+  }
+
   /**
    * Observe all the `SharedState` instances that are created on the network.
    * This can be usefull for clients with some controller role that might want to track
@@ -180,20 +234,31 @@ class BaseStateManager {
    * control over them from a single point.
    *
    * Notes:
-   * - The states that are created by the same node are not propagated through
-   * the observe callback.
-   * - The order of execution is not guaranted, i.e. an state attached in the
-   * `observe` callback could be created before the `async create` method resolves.
+   * - The order of execution is not guaranted between nodes, i.e. an state attached
+   * in the `observe` callback could be created before the `async create` method resolves.
+   * - Filtering, i.e. `observedSchemaName` and `options.excludeLocal` are handled
+   * on the node side, the server just notify all state creation activity and
+   * the node executes the given callbacks according to the different filter rules.
+   * Such strategy allows to share the observe notifications between all observers.
+   *
+   * Alternative signatures:
+   * - .observe(callback)
+   * - .observe(schemaName, callback)
+   * - .observe(callback, options)
+   * - .observe(schemaName, callback, options)
    *
-   * @param {String} [schemaName] - optionnal schema name to filter the observed
+   * @param {string} [schemaName] - optionnal schema name to filter the observed
    *  states.
    * @param {server.StateManager~ObserveCallback|client.StateManager~ObserveCallback}
    *  callback - Function to be called when a new state is created on the network.
+   * @param {object} options - Options.
+   * @param {boolean} [options.excludeLocal = false] - If set to true, exclude states
+   *  created locallly, i.e. by the same node, from the collection.
    * @returns {Promise<Function>} - Returns a Promise that resolves when the given
    *  callback as been executed on each existing states. The promise value is a
    *  function which allows to stop observing the states on the network.
    * @example
-   * client.stateManager.observe(async (schemaName, stateId, nodeId) => {
+   * client.stateManager.observe(async (schemaName, stateId) => {
    *   if (schemaName === 'something') {
    *     const state = await this.client.stateManager.attach(schemaName, stateId);
    *     console.log(state.getValues());
@@ -204,50 +269,128 @@ class BaseStateManager {
   // handle this way and the network overhead is very low for observe notifications:
   // i.e. schemaName, stateId, nodeId
   async observe(...args) {
-    let filterSchemaName;
+
+    const defaultOptions = {
+      excludeLocal: false,
+    };
+
+    let observedSchemaName;
     let callback;
+    let options;
 
-    if (args.length === 1) {
-      filterSchemaName = '*';
-      callback = args[0];
+    switch (args.length) {
+      case 1: {
+        // variation: .observe(callback)
+        if (!isFunction(args[0])) {
+          throw new TypeError(`[stateManager] Invalid arguments, argument 1 should be a function"`);
+        }
 
-      if (!isFunction(callback)) {
-        throw new Error(`[stateManager] Invalid arguments, valid signatures are "stateManager.observe(callback)" or "stateManager.observe(schemaName, callback)"`);
+        observedSchemaName = null;
+        callback = args[0];
+        options = defaultOptions;
+        break;
       }
-    } else if (args.length === 2) {
-      filterSchemaName = args[0];
-      callback = args[1];
+      case 2: {
+        // variation: .observe(schemaName, callback)
+        if (isString(args[0])) {
+          if (!isFunction(args[1])) {
+            throw new TypeError(`[stateManager] Invalid arguments, argument 2 should be a function"`);
+          }
+
+          observedSchemaName = args[0];
+          callback = args[1];
+          options = defaultOptions;
+
+        // variation: .observe(callback, options) API
+        } else if (isFunction(args[0])) {
+          if (!isPlainObject(args[1])) {
+            throw new TypeError(`[stateManager] Invalid arguments, argument 2 should be an object"`);
+          }
+
+          observedSchemaName = null;
+          callback = args[0];
+          options = Object.assign(defaultOptions, args[1]);
+
+        } else {
+          throw new Error(`[stateManager] Invalid signature, refer to the StateManager.observe documentation"`);
+        }
 
-      if (!isString(filterSchemaName) || !isFunction(callback)) {
-        throw new Error(`[stateManager] Invalid arguments, valid signatures are "stateManager.observe(callback)" or "stateManager.observe(schemaName, callback)"`);
+        break;
+      }
+      case 3: {
+        // variation: .observe(schemaName, callback, options)
+        if (!isString(args[0])) {
+          throw new TypeError(`[stateManager] Invalid arguments, argument 1 should be a string"`);
+        }
+
+        if (!isFunction(args[1])) {
+          throw new TypeError(`[stateManager] Invalid arguments, argument 2 should be a function"`);
+        }
+
+        if (!isPlainObject(args[2])) {
+          throw new TypeError(`[stateManager] Invalid arguments, argument 2 should be an object"`);
+        }
+
+        observedSchemaName = args[0];
+        callback = args[1];
+        options = Object.assign(defaultOptions, args[2]);
+
+        break;
+      }
+      // throw in all other cases
+      default: {
+        throw new Error(`[stateManager] Invalid signature, refer to the StateManager.observe documentation"`);
       }
-    } else {
-      throw new Error(`[stateManager] Invalid arguments, valid signatures are "stateManager.observe(callback)" or "stateManager.observe(schemaName, callback)"`);
     }
 
     // resend request to get updated list of states
     return new Promise((resolve, reject) => {
-      const reqId = storeRequestPromise(resolve, reject);
+      const reqId = this._promiseStore.add(resolve, reject, 'observe-request');
       // store the callback for execution on the response. the returned Promise
       // is fullfiled once callback has been executed with each existing states
-      this._observeRequestCallbacks.set(reqId, [callback, filterSchemaName]);
-      // store the callback for execution on subsequent notifications
-      this._observeListeners.set(callback, filterSchemaName);
-
-      this.client.transport.emit(OBSERVE_REQUEST, reqId);
+      const observeInfos = [observedSchemaName, callback, options];
+      this._observeRequestCallbacks.set(reqId, observeInfos);
+
+      // NOTE: do not store in `_observeListeners` yet as it can produce race
+      // conditions, e.g.:
+      // ```
+      // await client.stateManager.observe(async (schemaName, stateId, nodeId) => {});
+      // // client now receives OBSERVE_NOTIFICATIONS
+      // await otherClient.stateManager.create('a');
+      // // second observer added in between
+      // client.stateManager.observe(async (schemaName, stateId, nodeId) => {});
+      // ````
+      // OBSERVE_NOTIFICATION is received before the OBSERVE_RESPONSE, then the
+      // second observer is called twice:
+      // - OBSERVE_RESPONSE 1 []
+      // - OBSERVE_NOTIFICATION [ 'a', 1, 0 ]
+      // - OBSERVE_NOTIFICATION [ 'a', 1, 0 ] // this should not happen
+      // - OBSERVE_RESPONSE 1 [ [ 'a', 1, 0 ] ]
+      //
+      // cf. unit test `observe should properly behave in race condition`
+
+      this.client.transport.emit(OBSERVE_REQUEST, reqId, observedSchemaName);
     });
   }
 
   /**
-   * Returns a collection of all the states created from the schema name. Except
-   * the ones created by the current node.
+   * Returns a collection of all the states created from the schema name.
    *
    * @param {string} schemaName - Name of the schema.
+   * @param {object} options - Options.
+   * @param {boolean} [options.excludeLocal = false] - If set to true, exclude states
+   *  created locallly, i.e. by the same node, from the collection.
    * @returns {server.SharedStateCollection|client.SharedStateCollection}
    */
-  async getCollection(schemaName) {
-    const collection = new SharedStateCollection(this, schemaName);
-    await collection._init();
+  async getCollection(schemaName, options) {
+    const collection = new SharedStateCollection(this, schemaName, options);
+
+    try {
+      await collection._init();
+    } catch (err) {
+      console.log(err.message)
+      throw new Error(`Cannot create collection, schema "${schemaName}" does not exists`);
+    }
 
     return collection;
   }

package/src/common/ParameterBag.js

@@ -1,4 +1,4 @@
-import cloneDeep from 'lodash.clonedeep';
+import cloneDeep from 'lodash/cloneDeep.js';
 import equal from 'fast-deep-equal';
 
 export const sharedOptions = {
@@ -394,30 +394,34 @@ class ParameterBag {
   getSchema(name = null) {
     if (name === null) {
       return this._schema;
-    } else {
-      if (!this.has(name)) {
-        throw new ReferenceError(`[SharedState] Cannot get schema description of undefined parameter "${name}"`);
-      }
+    }
 
-      return this._schema[name];
+    if (!this.has(name)) {
+      throw new ReferenceError(`[SharedState] Cannot get schema description of undefined parameter "${name}"`);
     }
+
+    return this._schema[name];
   }
 
   // return the default value, if initValue has been given, return init values
   getInitValues() {
     const initValues = {};
+
     for (let [name, def] of Object.entries(this._schema)) {
       initValues[name] = def.initValue;
     }
+
     return initValues;
   }
 
   // return the default value, if initValue has been given, return init values
   getDefaults() {
     const defaults = {};
+
     for (let [name, def] of Object.entries(this._schema)) {
-      defaults[name] = def.defaults;
+      defaults[name] = def.default;
     }
+
     return defaults;
   }
 }

package/src/common/PromiseStore.js

@@ -0,0 +1,41 @@
+import { idGenerator } from '@ircam/sc-utils';
+
+const generateRequestId = idGenerator();
+
+export default class PromiseStore {
+  constructor(name) {
+    this.name = name;
+    this.store = new Map();
+  }
+
+  add(resolve, reject, type) {
+    const reqId = generateRequestId.next().value;
+    this.store.set(reqId, { resolve, reject, type });
+
+    return reqId;
+  }
+
+  resolve(reqId, data) {
+    const { resolve } = this.store.get(reqId);
+    this.store.delete(reqId);
+
+    resolve(data);
+  }
+
+  reject(reqId, msg) {
+    const { reject } = this.store.get(reqId);
+    this.store.delete(reqId);
+
+    reject(new Error(msg));
+  }
+
+  // reject all pendeing request
+  flush() {
+    for (let [_reqId, entry] of this.store) {
+      const { reject, type } = entry;
+      reject(new Error(`[${this.name}] Discard promise "${type}", cannot resolve`));
+    }
+
+    this.store.clear();
+  }
+}

package/src/common/SharedStatePrivate.js

@@ -13,13 +13,14 @@ import {
 
 /**
  * The "real" state, this instance is kept private by the server.StateManager.
- * It cannot be accessed without a SharedState proxy
+ * It can only be accessed through a SharedState proxy.
  * @private
  */
 class SharedStatePrivate {
   constructor(id, schemaName, schema, manager, initValues = {}) {
     this.id = id;
     this.schemaName = schemaName;
+    this.isCollectionController = false;
 
     this._manager = manager;
     this._parameters = new ParameterBag(schema, initValues);
@@ -29,10 +30,16 @@ class SharedStatePrivate {
     this._creatorId = null;
   }
 
-  _attachClient(remoteId, client, isOwner = false) {
-    this._attachedClients.set(remoteId, client);
+  _attachClient(remoteId, client, isOwner = false, inCollection = false) {
+
+    // isOwner && inCollection  -> collection controller
+    // !isOwner && inCollection -> attached in collection
+
+    const clientInfos = { client, isOwner, inCollection };
+    this._attachedClients.set(remoteId, clientInfos);
 
     if (isOwner) {
+      this.isCollectionController = inCollection;
       this._creatorRemoteId = remoteId;
       this._creatorId = client.id;
     }
@@ -89,48 +96,98 @@ class SharedStatePrivate {
         }
 
         if (hasUpdates) {
-          // send response to requester
-          // client.transport.emit(`${UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates);
-
-          // @note: we propagate server-side last, because as the server transport
-          // is synchronous it can break ordering if a subscription function makes
-          // itself an update in reaction to an update, therefore network messages
-          // order would be broken,
-
-          // we need to handle cases where:
-          // client state (client.id: 2) sends a request
-          // server attached state (client.id: -1) spot a problem and overrides the value
-          // we want the remote client (id: 2) to receive in the right order:
-          // * 1. the value it requested,
-          // * 2. the value overriden by the server-side attached state (id: -1)
-
-          // this problem could be solved properly with a reducer system:
-          // if (dirty) {
-          //   -> call (async) reducer
-          //   -> get values from reducer
-          //.  -> dispatch to everybody
-          // }
-
-          for (let [peerRemoteId, peer] of this._attachedClients.entries()) {
-            // propagate notification to all other attached clients except server
-            if (remoteId !== peerRemoteId && peer.id !== -1) {
-              peer.transport.emit(`${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`, filteredUpdates, context);
+          // Collection Controller logic
+          if (isOwner && inCollection) {
+            // notify the requester back
+            // no need to check for attached clients as it is not observable
+            client.transport.emit(
+              `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
+              reqId, filteredUpdates, context
+            );
+
+            // loop through all private states
+            for (let [stateId, state] of this._manager._sharedStatePrivateById) {
+              // pick all states with same schema name and not this
+              if (state !== this && this.schemaName === state.schemaName) {
+                // notify all attached clients except those who belong to a collection
+                // i.e. !isOwner && inCollection, they will be notified by their own
+                // collection controller
+                for (let [remoteId, clientInfos] of state._attachedClients) {
+                  const { client, isOwner, inCollection } = clientInfos;
+
+                  if (!clientInfos.isOwner && clientInfos.inCollection) {
+                    continue;
+                  } else {
+                    const peer = clientInfos.client;
+
+                    peer.transport.emit(
+                      `${UPDATE_NOTIFICATION}-${state.id}-${remoteId}`,
+                      filteredUpdates, context
+                    );
+                  }
+                }
+              }
             }
-          }
+          } else {
 
-          if (client.id !== -1) {
-            client.transport.emit(`${UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates, context);
-          }
+            // Normal case
+
+            // We need to handle cases where:
+            // - client state (client.id: 2) sends a request
+            // - server attached state (client.id: -1) spot a problem and overrides the value
+            // We want the remote client (id: 2) to receive in the right order:
+            // * 1. the value it requested,
+            // * 2. the value overriden by the server-side attached state (id: -1)
+            //
+            // such problem is now better solved with the the upateHook system, none
+            // nonetheway we don't want to introduce inconsistencies here
+            //
+            // Then we propagate server-side last, because as the server transport
+            // is synchronous it can break ordering if a subscription function makes
+            // itself an update in reaction to an update. Propagating to server last
+            // alllows to maintain network messages order consistent.
+
+            // @note - remoteId correspond to unique remote state id
+
+            // propagate RESPONSE to the client that originates the request if not the server
+            if (client.id !== -1) {
+              client.transport.emit(
+                `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
+                reqId, filteredUpdates, context
+              );
+            }
 
-          for (let [peerRemoteId, peer] of this._attachedClients.entries()) {
-            // propagate notification to server
-            if (remoteId !== peerRemoteId && peer.id === -1) {
-              peer.transport.emit(`${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`, filteredUpdates, context);
+            // propagate NOTIFICATION to all other attached clients except server
+            for (let [peerRemoteId, clientInfos] of this._attachedClients) {
+              const peer = clientInfos.client;
+
+              if (remoteId !== peerRemoteId && peer.id !== -1) {
+                peer.transport.emit(
+                  `${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`,
+                  filteredUpdates, context
+                );
+              }
             }
-          }
 
-          if (client.id === -1) {
-            client.transport.emit(`${UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates, context);
+            // propagate RESPONSE to server if it is the requester
+            if (client.id === -1) {
+              client.transport.emit(
+                `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
+                reqId, filteredUpdates, context
+              );
+            }
+
+            // propagate NOTIFICATION other attached state that belongs to server
+            for (let [peerRemoteId, clientInfos] of this._attachedClients) {
+              const peer = clientInfos.client;
+
+              if (remoteId !== peerRemoteId && peer.id === -1) {
+                peer.transport.emit(
+                  `${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`,
+                  filteredUpdates, context
+                );
+              }
+            }
           }
         } else {
           // propagate back to the requester that the update has been aborted
@@ -152,14 +209,15 @@ class SharedStatePrivate {
     if (isOwner) {
       // delete only if creator
       client.transport.addListener(`${DELETE_REQUEST}-${this.id}-${remoteId}`, (reqId) => {
-        this._manager._serverStatesById.delete(this.id);
+        this._manager._sharedStatePrivateById.delete(this.id);
         // --------------------------------------------------------------------
         // WARNING - MAKE SURE WE DON'T HAVE PROBLEM W/ THAT
         // --------------------------------------------------------------------
         // @todo - propagate server-side last, because if a subscription function sends a
         // message to a client, network messages order are kept coherent
         // this._subscriptions.forEach(func => func(updated));
-        for (let [remoteId, attached] of this._attachedClients.entries()) {
+        for (let [remoteId, clientInfos] of this._attachedClients) {
+          const attached = clientInfos.client;
           this._detachClient(remoteId, attached);
 
           if (remoteId === this._creatorRemoteId) {