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

package/src/common/constants.js

@@ -21,6 +21,7 @@ export const DETACH_ERROR = 's:dt:err';
 
 export const OBSERVE_REQUEST = 's:o:req';
 export const OBSERVE_RESPONSE = 's:o:res';
+export const OBSERVE_ERROR = 's:o:err';
 export const OBSERVE_NOTIFICATION = 's:o:not';
 
 export const UNOBSERVE_NOTIFICATION = 's:uo:not';
@@ -47,5 +48,5 @@ export const CLIENT_HANDSHAKE_RESPONSE = 'cl:h:res';
 export const CLIENT_HANDSHAKE_ERROR = 'cl:h:err';
 
 // audit state schema name
-export const AUDIT_STATE_NAME = 's:c:audit';
+export const AUDIT_STATE_NAME = 'p:s:audit';
 export const PRIVATE_STATES = [AUDIT_STATE_NAME];

package/src/common/sockets-utils.js

@@ -1,8 +1,7 @@
 import 'fast-text-encoding';
-import root from 'window-or-global';
 
-const encoder = new root.TextEncoder('utf-8');
-const decoder = new root.TextDecoder('utf-8');
+const encoder = new TextEncoder('utf-8');
+const decoder = new TextDecoder('utf-8');
 
 const types = [
   'Int8Array',
@@ -57,7 +56,7 @@ export function unpackBinaryMessage(buffer /* arraybuffer */) {
   const channel = decoder.decode(channelBuffer);
   const type = types[typeIndex];
   // slice (copy) the underlying ArrayBuffer to create a clean TypedArray
-  const data = new root[type](buffer.slice(startOffset));
+  const data = new globalThis[type](buffer.slice(startOffset));
 
   return [channel, data];
 }

package/src/server/Server.js

@@ -5,14 +5,13 @@ import path from 'node:path';
 import os from 'node:os';
 import { X509Certificate, createPrivateKey } from 'node:crypto';
 
-import { getTime } from '@ircam/sc-gettime';
-import { isPlainObject, idGenerator } from '@ircam/sc-utils';
+import { isPlainObject, idGenerator, getTime } from '@ircam/sc-utils';
 import chalk from 'chalk';
 import compression from 'compression';
 import express from 'express';
 import Keyv from 'keyv';
 import { KeyvFile } from 'keyv-file';
-import merge from 'lodash.merge';
+import merge from 'lodash/merge.js';
 import pem from 'pem';
 import compile from 'template-literal';
 

package/src/server/SharedStateCollection.js

@@ -15,8 +15,11 @@ import BaseSharedStateCollection from '../common/BaseSharedStateCollection.js';
 
 /**
  * The `SharedStateCollection` interface represent a collection of all states
- * created from a given schema name on the network, at the execption of the ones
- * created by the current node.
+ * created from a given schema name on the network.
+ *
+ * It can optionnaly exclude the states created by the current node.
+ *
+ * See {@link server.StateManager#getCollection} for factory method API
  *
  * ```
  * const collection = await server.stateManager.getCollection('my-schema');

package/src/server/Socket.js

@@ -1,4 +1,4 @@
-import { getTime } from '@ircam/sc-gettime';
+import { getTime } from '@ircam/sc-utils';
 import {
   packBinaryMessage,
   unpackBinaryMessage,

package/src/server/StateManager.js

@@ -1,7 +1,7 @@
 import EventEmitter from 'node:events';
 
 import { idGenerator, isString, isPlainObject } from '@ircam/sc-utils';
-import clonedeep from 'lodash.clonedeep';
+import clonedeep from 'lodash/cloneDeep.js';
 
 import BaseStateManager from '../common/BaseStateManager.js';
 import ParameterBag from '../common/ParameterBag.js';
@@ -17,6 +17,7 @@ import {
   ATTACH_ERROR,
   OBSERVE_REQUEST,
   OBSERVE_RESPONSE,
+  OBSERVE_ERROR,
   OBSERVE_NOTIFICATION,
   UNOBSERVE_NOTIFICATION,
   DELETE_SCHEMA,
@@ -27,6 +28,8 @@ import {
 const generateStateId = idGenerator();
 const generateRemoteId = idGenerator();
 
+const kIsObservableState = Symbol('StateManager::isObservableState');
+
 /**
  * @typedef {object} server.StateManager~schema
  *
@@ -314,7 +317,7 @@ class StateManager extends BaseStateManager {
     super(localClientId, localTransport);
 
     this._clientByNodeId = new Map();
-    this._serverStatesById = new Map();
+    this._sharedStatePrivateById = new Map();
     this._schemas = new Map();
     this._observers = new Set();
     this._hooksBySchemaName = new Map(); // protected
@@ -322,6 +325,12 @@ class StateManager extends BaseStateManager {
     this.addClient(localClientId, localTransport);
   }
 
+  [kIsObservableState](state) {
+    const { schemaName, isCollectionController } = state;
+    // is observable only if not in private state and not a controller state
+    return !PRIVATE_STATES.includes(schemaName) && !isCollectionController;
+  }
+
   /**
    * Add a client to the manager.
    *
@@ -341,105 +350,133 @@ class StateManager extends BaseStateManager {
     // ---------------------------------------------
     // CREATE
     // ---------------------------------------------
-    client.transport.addListener(CREATE_REQUEST, (reqId, schemaName, requireSchema, initValues = {}) => {
-      if (this._schemas.has(schemaName)) {
-        try {
-          const schema = this._schemas.get(schemaName);
-          const stateId = generateStateId.next().value;
-          const remoteId = generateRemoteId.next().value;
-          // id, schemaName, schema, manager, initValues = {}
-          const state = new SharedStatePrivate(stateId, schemaName, schema, this, initValues);
-
-          state._attachClient(remoteId, client, true); // attach client to the state
-          this._serverStatesById.set(stateId, state);
-
-          const currentValues = state._parameters.getValues();
-          const sendedSchema = requireSchema ? schema : null;
-
-          client.transport.emit(CREATE_RESPONSE, reqId, stateId, remoteId, schemaName, sendedSchema, currentValues);
-
-          this._observers.forEach(observer => {
-            if (observer.id !== nodeId) {
-              observer.transport.emit(OBSERVE_NOTIFICATION, schemaName, stateId, nodeId);
+    client.transport.addListener(
+      CREATE_REQUEST,
+      (reqId, schemaName, requireSchema, initValues = {}, inCollection = false) => {
+        if (this._schemas.has(schemaName)) {
+          try {
+            const schema = this._schemas.get(schemaName);
+            const stateId = generateStateId.next().value;
+            const remoteId = generateRemoteId.next().value;
+            const state = new SharedStatePrivate(stateId, schemaName, schema, this, initValues);
+
+             // attach client to the state as owner
+            const isOwner = true;
+            state._attachClient(remoteId, client, isOwner, inCollection);
+
+            this._sharedStatePrivateById.set(stateId, state);
+
+            const currentValues = state._parameters.getValues();
+            const schemaOption = requireSchema ? schema : null;
+
+            client.transport.emit(
+              CREATE_RESPONSE,
+              reqId, stateId, remoteId, schemaName, schemaOption, currentValues
+            );
+
+            const isObservable = this[kIsObservableState](state);
+
+            if (isObservable) {
+              this._observers.forEach(observer => {
+                observer.transport.emit(OBSERVE_NOTIFICATION, schemaName, stateId, nodeId);
+              });
             }
-          });
-        } catch (err) {
-          client.transport.emit(CREATE_ERROR, reqId, err.message);
-          console.error(err.message);
+          } catch (err) {
+            const msg = `Cannot create state "${schemaName}", ${err.message}`;
+            console.error(msg);
+
+            client.transport.emit(CREATE_ERROR, reqId, msg);
+          }
+        } else {
+          const msg = `Cannot create state "${schemaName}", schema does not exists`;
+          console.error(msg);
+
+          client.transport.emit(CREATE_ERROR, reqId, msg);
         }
-      } else {
-        const msg = `Cannot create state "${schemaName}", schema does not exists`;
-        console.error(msg);
-        client.transport.emit(CREATE_ERROR, reqId, msg);
       }
-    });
+    );
 
     // ---------------------------------------------
     // ATTACH (when creator, is attached by default)
     // ---------------------------------------------
-    client.transport.addListener(ATTACH_REQUEST, (reqId, schemaName, stateId = null, requireSchema = true) => {
-      if (this._schemas.has(schemaName)) {
-        let state = null;
-
-        if (stateId !== null && this._serverStatesById.has(stateId)) {
-          state = this._serverStatesById.get(stateId);
-        } else if (stateId === null) {
-          // if no `stateId` given, we try to find the first state with the given
-          // `schemaName` in the list, this allow a client to attach to a global
-          // state created by the server (or some persistant client) without
-          // having to know the `stateId` (e.g. some global state...)
-          for (let existingState of this._serverStatesById.values()) {
-            if (existingState.schemaName === schemaName) {
-              state = existingState;
-              break;
+    client.transport.addListener(
+      ATTACH_REQUEST,
+      (reqId, schemaName, stateId = null, requireSchema = true, inCollection = false) => {
+        if (this._schemas.has(schemaName)) {
+          let state = null;
+
+          if (stateId !== null && this._sharedStatePrivateById.has(stateId)) {
+            state = this._sharedStatePrivateById.get(stateId);
+          } else if (stateId === null) {
+            // if no `stateId` given, we try to find the first state with the given
+            // `schemaName` in the list, this allow a client to attach to a global
+            // state created by the server (or some persistant client) without
+            // having to know the `stateId` (e.g. some global state...)
+            for (let existingState of this._sharedStatePrivateById.values()) {
+              if (existingState.schemaName === schemaName) {
+                state = existingState;
+                break;
+              }
             }
           }
-        }
 
-        if (state !== null) {
-          // @note - we use a unique remote id to allow a client to attach
-          // several times to the same state.
-          // i.e. same state -> several remote attach on the same node
-          const remoteId = generateRemoteId.next().value;
-          const schema = this._schemas.get(schemaName);
-          const currentValues = state._parameters.getValues();
-
-          state._attachClient(remoteId, client, false);
-          // send schema for client-side instanciation
-          const sendedSchema = requireSchema ? schema : null;
-          client.transport.emit(ATTACH_RESPONSE, reqId, state.id, remoteId, schemaName, sendedSchema, currentValues);
+          if (state !== null) {
+            // @note - we use a unique remote id to allow a client to attach
+            // several times to the same state.
+            // i.e. same state -> several remote attach on the same node
+            const remoteId = generateRemoteId.next().value;
+            const isOwner = false;
+            state._attachClient(remoteId, client, isOwner, inCollection);
+
+            const currentValues = state._parameters.getValues();
+            const schema = this._schemas.get(schemaName);
+            const schemaOption = requireSchema ? schema : null;
+
+            client.transport.emit(
+              ATTACH_RESPONSE,
+              reqId, state.id, remoteId, schemaName, schemaOption, currentValues
+            );
+
+          } else {
+            const msg = `Cannot attach, no existing state for schema "${schemaName}" with stateId: "${stateId}"`;
+            console.error(msg);
+
+            client.transport.emit(ATTACH_ERROR, reqId, msg);
+          }
         } else {
-          const msg = `Cannot attach, no existing state for schema "${schemaName}" with stateId: "${stateId}"`;
-          client.transport.emit(ATTACH_ERROR, reqId, msg);
+          const msg = `Cannot attach, schema "${schemaName}" does not exists`;
           console.error(msg);
+
+          client.transport.emit(ATTACH_ERROR, reqId, msg);
         }
-      } else {
-        const msg = `Cannot attach, schema "${schemaName}" does not exists`;
-        client.transport.emit(ATTACH_ERROR, reqId, msg);
-        console.error(msg);
       }
-    });
+    );
 
     // ---------------------------------------------
     // OBSERVE PEERS (be notified when a state is created, lazy)
     // ---------------------------------------------
-    client.transport.addListener(OBSERVE_REQUEST, reqId => {
-      const statesInfos = [];
-
-      this._serverStatesById.forEach(state => {
-        const { schemaName, id, _creatorId } = state;
-        // only track application states
-        // (e.g. do not propagate infos about audit state)
-        if (!PRIVATE_STATES.includes(schemaName) && _creatorId !== client.id) {
-          statesInfos.push([schemaName, id, _creatorId]);
-        }
-      });
+    client.transport.addListener(OBSERVE_REQUEST, (reqId, observedSchemaName) => {
+      if (observedSchemaName === null || this._schemas.has(observedSchemaName)) {
+        const statesInfos = [];
 
-      // add client to observers first because if some (sync) server side
-      // callback throws, the client would never be added to the list
-      this._observers.add(client);
+        this._sharedStatePrivateById.forEach(state => {
+          const isObservable = this[kIsObservableState](state);
 
-      client.transport.emit(OBSERVE_RESPONSE, reqId, ...statesInfos);
+          if (isObservable) {
+            const { schemaName, id, _creatorId } = state;
+            statesInfos.push([schemaName, id, _creatorId]);
+          }
+        });
+
+        // add client to observers first because if some synchronous server side
+        // callback throws, the client would never be added to the list
+        this._observers.add(client);
+
+        client.transport.emit(OBSERVE_RESPONSE, reqId, ...statesInfos);
+      } else {
+        const msg = `Cannot observe, schema "${observedSchemaName}" does not exists`;
+        client.transport.emit(OBSERVE_ERROR, reqId, msg);
+      }
     });
 
     client.transport.addListener(UNOBSERVE_NOTIFICATION, () => {
@@ -458,18 +495,22 @@ class StateManager extends BaseStateManager {
    * @private
    */
   removeClient(nodeId) {
-    for (let [_id, state] of this._serverStatesById.entries()) {
+    for (let [_id, state] of this._sharedStatePrivateById.entries()) {
       let deleteState = false;
 
       // define if the client is the creator of the state, in which case
       // everybody must delete it
-      for (let [remoteId, attachedClient] of state._attachedClients.entries()) {
+      for (let [remoteId, clientInfos] of state._attachedClients) {
+        const attachedClient = clientInfos.client;
+
         if (nodeId === attachedClient.id && remoteId === state._creatorRemoteId) {
           deleteState = true;
         }
       }
 
-      for (let [remoteId, attachedClient] of state._attachedClients.entries()) {
+      for (let [remoteId, clientInfos] of state._attachedClients) {
+        const attachedClient = clientInfos.client;
+
         if (nodeId === attachedClient.id) {
           state._detachClient(remoteId, attachedClient);
         }
@@ -480,7 +521,7 @@ class StateManager extends BaseStateManager {
             attachedClient.transport.emit(`${DELETE_NOTIFICATION}-${state.id}-${remoteId}`);
           }
 
-          this._serverStatesById.delete(state.id);
+          this._sharedStatePrivateById.delete(state.id);
         }
       }
     }
@@ -547,14 +588,15 @@ class StateManager extends BaseStateManager {
    */
   deleteSchema(schemaName) {
     // @note: deleting schema
-    for (let [_id, state] of this._serverStatesById.entries()) {
+    for (let [_id, state] of this._sharedStatePrivateById) {
       if (state.schemaName === schemaName) {
-        for (let [remoteId, attached] of state._attachedClients.entries()) {
+        for (let [remoteId, clientInfos] of state._attachedClients) {
+          const attached = clientInfos.client;
           state._detachClient(remoteId, attached);
           attached.transport.emit(`${DELETE_NOTIFICATION}-${state.id}-${remoteId}`);
         }
 
-        this._serverStatesById.delete(this.id);
+        this._sharedStatePrivateById.delete(state.id);
       }
     }
 

package/src/server/audit-network-latency.worker.js

@@ -1,6 +1,6 @@
 import { parentPort } from 'node:worker_threads';
 
-import { getTime } from '@ircam/sc-gettime';
+import { getTime } from '@ircam/sc-utils';
 
 let stack = [];
 let averageLatencyWindow = 5;

package/src/server/crypto.js

@@ -23,16 +23,15 @@ const encryptionIV = crypto
 
 export function encryptData(obj) {
   const data = JSON.stringify(obj);
-  const cipher = crypto.createCipheriv(encryptionMethod, key, encryptionIV)
-  return Buffer.from(
-    cipher.update(data, 'utf8', 'hex') + cipher.final('hex')
-  ).toString('base64')
+  const cipher = crypto.createCipheriv(encryptionMethod, key, encryptionIV);
+
+  return Buffer.from(cipher.update(data, 'utf8', 'hex') + cipher.final('hex')).toString('base64');
 }
 
 export function decryptData(encryptedData) {
-  const buff = Buffer.from(encryptedData, 'base64')
-  const decipher = crypto.createDecipheriv(encryptionMethod, key, encryptionIV)
+  const buff = Buffer.from(encryptedData, 'base64');
+  const decipher = crypto.createDecipheriv(encryptionMethod, key, encryptionIV);
 
-  const decrypted = `${decipher.update(buff.toString('utf8'), 'hex', 'utf8')}${decipher.final('utf8')}`
+  const decrypted = `${decipher.update(buff.toString('utf8'), 'hex', 'utf8')}${decipher.final('utf8')}`;
   return JSON.parse(decrypted);
 }

package/src/common/promise-store.js

@@ -1,25 +0,0 @@
-import { idGenerator } from '@ircam/sc-utils';
-
-const generateRequestId = idGenerator();
-const requestPromises = new Map();
-
-export function storeRequestPromise(resolve, reject) {
-  const reqId = generateRequestId.next().value;
-  requestPromises.set(reqId, { resolve, reject });
-
-  return reqId;
-}
-
-export function resolveRequest(reqId, data) {
-  const { resolve } = requestPromises.get(reqId);
-  requestPromises.delete(reqId);
-
-  resolve(data);
-}
-
-export function rejectRequest(reqId, data) {
-  const { reject } = requestPromises.get(reqId);
-  requestPromises.delete(reqId);
-
-  reject(data);
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "include": ["src/**/*.js"],
-
-  "compilerOptions": {
-    // Tells TypeScript to read JS files, as
-    // normally they are ignored as source files
-    "allowJs": true,
-    // Generate d.ts files
-    "declaration": true,
-    // This compiler run should
-    // only output d.ts files
-    "emitDeclarationOnly": true,
-    // Types should go into this directory.
-    // Removing this would place the .d.ts files
-    // next to the .js files
-    "outDir": "types",
-    // go to js file when using IDE functions like
-    // "Go to Definition" in VSCode
-    "declarationMap": true
-  }
-}