@soundworks/core 4.0.0-alpha.4 → 4.0.0-alpha.6

package/src/common/BaseStateManager.js

@@ -1,4 +1,6 @@
+import { isString, isFunction } from '@ircam/sc-utils';
 import SharedState from './BaseSharedState.js';
+import SharedStateCollection from './BaseSharedStateCollection.js';
 import {
   CREATE_REQUEST,
   CREATE_RESPONSE,
@@ -31,7 +33,7 @@ class BaseStateManager {
     this.client = { id, transport };
 
     this._statesById = new Map();
-    this._observeListeners = new Set();
+    this._observeListeners = new Map(); // Map <callback, filterSchemaName>
     this._cachedSchemas = new Map();
     this._observeRequestCallbacks = new Map();
 
@@ -88,28 +90,35 @@ 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 = this._observeRequestCallbacks.get(reqId);
+      const [callback, filterSchemaName] = this._observeRequestCallbacks.get(reqId);
       this._observeRequestCallbacks.delete(reqId);
 
       const promises = list.map(([schemaName, stateId, nodeId]) => {
-        return callback(schemaName, stateId, nodeId);
+        if (filterSchemaName === '*' || filterSchemaName === schemaName) {
+          return callback(schemaName, stateId, nodeId);
+        } else {
+          return Promise.resolve();
+        }
       });
 
       await Promise.all(promises);
 
       const unsubscribe = () => {
         this._observeListeners.delete(callback);
-
+        // no more listeners, we can stop receiving notification from the server
         if (this._observeListeners.size === 0) {
           this.client.transport.emit(UNOBSERVE_NOTIFICATION);
         }
       };
+
       resolveRequest(reqId, unsubscribe);
     });
 
-    this.client.transport.addListener(OBSERVE_NOTIFICATION, (...list) => {
-      list.forEach(([schemaName, stateId, nodeId]) => {
-        this._observeListeners.forEach(callback => callback(schemaName, stateId, nodeId));
+    this.client.transport.addListener(OBSERVE_NOTIFICATION, (schemaName, stateId, nodeId) => {
+      this._observeListeners.forEach((filterSchemaName, callback) => {
+        if (filterSchemaName === '*' || filterSchemaName === schemaName) {
+          callback(schemaName, stateId, nodeId);
+        }
       });
     });
 
@@ -170,12 +179,16 @@ class BaseStateManager {
    * the state of all other clients of the application, to monitor them and/or take
    * control over them from a single point.
    *
-   * @todo Optionnal schema name
+   * Note that the states that are created by the same node are not propagated through
+   * the observe callback.
+   *
+   * @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.
-   * @returns {Promise<Function>} - Return a Promise that resolves when the callback
-   *  as been executed for the first time. The promise value is a function which
-   *  allows to stop observing the network.
+   * @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) => {
    *   if (schemaName === 'something') {
@@ -184,16 +197,57 @@ class BaseStateManager {
    *   }
    * });
    */
-  async observe(callback) {
-    this._observeListeners.add(callback);
-    // store function
+  // note: all filtering is done only on client-side as it is really more simple to
+  // handle this way and the network overhead is very low for observe notifications:
+  // i.e. schemaName, stateId, nodeId
+  async observe(...args) {
+    let filterSchemaName;
+    let callback;
+
+    if (args.length === 1) {
+      filterSchemaName = '*';
+      callback = args[0];
+
+      if (!isFunction(callback)) {
+        throw new Error(`[stateManager] Invalid arguments, valid signatures are "stateManager.observe(callback)" or "stateManager.observe(schemaName, callback)"`);
+      }
+    } else if (args.length === 2) {
+      filterSchemaName = args[0];
+      callback = args[1];
+
+      if (!isString(filterSchemaName) || !isFunction(callback)) {
+        throw new Error(`[stateManager] Invalid arguments, valid signatures are "stateManager.observe(callback)" or "stateManager.observe(schemaName, callback)"`);
+      }
+    } 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);
-      // store the callback to be executed on the response
-      this._observeRequestCallbacks.set(reqId, callback);
+      // 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);
     });
   }
+
+  /**
+   * Returns a collection of all the states created from the schema name. Except
+   * the ones created by the current node.
+   *
+   * @param {string} schemaName - Name of the schema.
+   * @returns {server.SharedStateCollection|client.SharedStateCollection}
+   */
+  async getCollection(schemaName) {
+    const collection = new SharedStateCollection(this, schemaName);
+    await collection._init();
+
+    return collection;
+  }
 }
 
 export default BaseStateManager;

package/src/common/ParameterBag.js

@@ -17,7 +17,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (typeof value !== 'boolean') {
-        throw new TypeError(`[SharedState] Invalid value for boolean param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value "${value}" for boolean parameter "${name}"`);
       }
 
       return value;
@@ -30,7 +30,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (typeof value !== 'string') {
-        throw new TypeError(`[SharedState] Invalid value for string param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value "${value}" for string parameter "${name}"`);
       }
 
       return value;
@@ -63,7 +63,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (!(typeof value === 'number' && Math.floor(value) === value)) {
-        throw new TypeError(`[SharedState] Invalid value for integer param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value "${value}" for integer parameter "${name}"`);
       }
 
       return Math.max(def.min, Math.min(def.max, value));
@@ -96,7 +96,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (typeof value !== 'number' || value !== value) { // reject NaN
-        throw new TypeError(`[SharedState] Invalid value for float param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value "${value}" for float parameter "${name}"`);
       }
 
       return Math.max(def.min, Math.min(def.max, value));
@@ -109,7 +109,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (def.list.indexOf(value) === -1) {
-        throw new TypeError(`[SharedState] Invalid value for enum param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value "${value}" for enum parameter "${name}"`);
       }
 
 
@@ -241,7 +241,8 @@ class ParameterBag {
   }
 
   /**
-   * Return values of all parameters as a flat object.
+   * Return values of all parameters as a flat object. If a parameter is of `any`
+   * type, a deep copy is made.
    *
    * @return {object}
    */
@@ -255,6 +256,25 @@ class ParameterBag {
     return values;
   }
 
+  /**
+   * Return values of all parameters as a flat object. Similar to `getValues` but
+   * returns a reference to the underlying value in case of `any` type. May be
+   * usefull if the underlying value is big (e.g. sensors recordings, etc.) and
+   * deep cloning expensive. Be aware that if changes are made on the returned
+   * object, the state of your application will become inconsistent.
+   *
+   * @return {object}
+   */
+  getValuesUnsafe() {
+    let values = {};
+
+    for (let name in this._values) {
+      values[name] = this.getUnsafe(name);
+    }
+
+    return values;
+  }
+
   /**
    * Return the value of the given parameter. If the parameter is of `any` type,
    * a deep copy is returned.
@@ -277,39 +297,66 @@ class ParameterBag {
   }
 
   /**
-   * Set the value of a parameter. If the value of the parameter is updated
-   * (aka if previous value is different from new value) all registered
-   * callbacks are registered.
+   * Similar to `get` but returns a reference to the underlying value in case of
+   * `any` type. May be usefull if the underlying value is big (e.g. sensors
+   * recordings, etc.) and deep cloning expensive. Be aware that if changes are
+   * made on the returned object, the state of your application will become
+   * inconsistent.
    *
    * @param {string} name - Name of the parameter.
+   * @return {Mixed} - Value of the parameter.
+   */
+  getUnsafe(name) {
+    if (!this.has(name)) {
+      throw new ReferenceError(`[SharedState] Cannot get value of undefined parameter "${name}"`);
+    }
+
+    return this._values[name];
+  }
+
+  /**
+   * Check that the value is valid according to the schema and return it coerced
+   * to the schema definition
+   *
+   * @param {String} name - Name of the parameter.
    * @param {Mixed} value - Value of the parameter.
-   * @param {boolean} [forcePropagation=false] - if true, propagate value even
-   *    if the value has not changed.
-   * @return {Array} - [new value, updated flag].
    */
-  set(name, value) {
+  coerceValue(name, value) {
     if (!this.has(name)) {
       throw new ReferenceError(`[SharedState] Cannot set value of undefined parameter "${name}"`);
     }
 
     const def = this._schema[name];
-    const { coerceFunction } = types[def.type];
 
     if (value === null && def.nullable === false) {
       throw new TypeError(`[SharedState] Invalid value for ${def.type} param "${name}": value is null and param is not nullable`);
     } else if (value === null && def.nullable === true) {
       value = null;
     } else {
+      const { coerceFunction } = types[def.type];
       value = coerceFunction(name, def, value);
     }
 
+    return value;
+  }
+
+  /**
+   * Set the value of a parameter. If the value of the parameter is updated
+   * (aka if previous value is different from new value) all registered
+   * callbacks are registered.
+   *
+   * @param {string} name - Name of the parameter.
+   * @param {Mixed} value - Value of the parameter.
+   * @return {Array} - [new value, updated flag].
+   */
+  set(name, value) {
+    value = this.coerceValue(name, value);
     const currentValue = this._values[name];
     const updated = !equal(currentValue, value);
 
     // we store a deep copy of the object as we don't want the client to be able
-    // to modify our underlying data, which leads unexpected behavior where the
+    // to modify our underlying data, which leads to unexpected behavior where the
     // deep equal check to returns true, and therefore the update is not triggered.
-    //
     // @see tests/common.state-manager.spec.js
     // 'should copy stored value for "any" type to have a predictable behavior'
     if (this._schema[name].type === 'any') {

package/src/common/promise-store.js

@@ -1,4 +1,4 @@
-import { idGenerator } from './utils.js';
+import { idGenerator } from '@ircam/sc-utils';
 
 const generateRequestId = idGenerator();
 const requestPromises = new Map();

package/src/server/Client.js

@@ -1,7 +1,6 @@
+import { idGenerator } from '@ircam/sc-utils';
 import { v4 as uuid } from 'uuid';
 
-import { idGenerator } from '../common/utils.js';
-
 const generateId = idGenerator();
 
 /**
@@ -44,6 +43,12 @@ class Client {
      * @type {server.Socket}
      */
     this.socket = socket;
+
+    /**
+     * Is set in server._onSocketConnection
+     * @private
+     */
+    this.token = null;
   }
 }
 

package/src/server/ContextManager.js

@@ -114,7 +114,7 @@ class ContextManager {
         this._contextStartPromises.set(contextName, startPromise);
         await startPromise;
         context.status = 'started';
-      } catch(err) {
+      } catch (err) {
         context.status = 'errored';
         throw new Error(err);
       }
@@ -144,7 +144,7 @@ class ContextManager {
       let context;
       try {
         context = await this.get(contextName);
-      } catch(err) {
+      } catch (err) {
         client.socket.send(
           CONTEXT_ENTER_ERROR,
           reqId,
@@ -185,7 +185,7 @@ class ContextManager {
         await context.enter(client);
 
         client.socket.send(CONTEXT_ENTER_RESPONSE, reqId, contextName);
-      } catch(err) {
+      } catch (err) {
         client.socket.send(CONTEXT_ENTER_ERROR, reqId, contextName, err.message);
       }
     });
@@ -207,7 +207,7 @@ class ContextManager {
         try {
           await context.exit(client);
           client.socket.send(CONTEXT_EXIT_RESPONSE, reqId, contextName);
-        } catch(err) {
+        } catch (err) {
           client.socket.send(CONTEXT_EXIT_ERROR, reqId, contextName, err.message);
         }
       } else {