dignity.js 0.4.0 → 0.5.1

package/src/network/peerjs-network.js

@@ -0,0 +1,234 @@
+const { DEFAULT_CLOUDFLARE_SIGNALING_URLS } = require('../signaling/default-signaling-config');
+const parsePeerJsServerUrl = require('../signaling/parse-peerjs-url');
+
+function resolvePeerImplementation(PeerImpl) {
+  if (PeerImpl) {
+    return PeerImpl;
+  }
+
+  try {
+    const peerjs = require('peerjs');
+    return peerjs.Peer || peerjs;
+  } catch (error) {
+    return null;
+  }
+}
+
+class PeerJSNetworkAdapter {
+  constructor({
+    url,
+    urls,
+    PeerImpl,
+    connectTimeoutMs = 12000
+  } = {}) {
+    this.urls = urls || (url ? [url] : [...DEFAULT_CLOUDFLARE_SIGNALING_URLS]);
+    this.url = this.urls[0];
+    this.PeerImpl = resolvePeerImplementation(PeerImpl);
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.nodeId = null;
+    this.peer = null;
+    this.connections = new Map();
+    this.pendingConnections = new Map();
+    this.messageHandlers = new Set();
+  }
+
+  async start(nodeId) {
+    if (!nodeId) {
+      throw new Error('PeerJSNetworkAdapter requires nodeId on start');
+    }
+
+    if (!this.PeerImpl) {
+      throw new Error('PeerJS implementation is not available');
+    }
+
+    if (this.peer) {
+      await this.stop();
+    }
+
+    let lastError;
+    for (const candidateUrl of this.urls) {
+      try {
+        await this.startWithUrl(nodeId, candidateUrl);
+        this.url = candidateUrl;
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+
+    throw lastError || new Error('Unable to connect PeerJS network adapter');
+  }
+
+  async startWithUrl(nodeId, url) {
+    this.nodeId = nodeId;
+    const server = parsePeerJsServerUrl(url);
+
+    await new Promise((resolve, reject) => {
+      const peer = new this.PeerImpl(nodeId, {
+        host: server.host,
+        port: server.port,
+        path: server.path,
+        secure: server.secure,
+        key: server.key
+      });
+
+      const timeout = setTimeout(() => {
+        peer.destroy?.();
+        reject(new Error(`Unable to connect PeerJS network adapter to ${url}`));
+      }, this.connectTimeoutMs);
+
+      peer.on('open', () => {
+        clearTimeout(timeout);
+        this.peer = peer;
+        resolve();
+      });
+
+      peer.on('connection', (connection) => {
+        this.attachConnectionHandlers(connection);
+      });
+
+      peer.on('error', (error) => {
+        clearTimeout(timeout);
+        peer.destroy?.();
+        reject(error || new Error(`Unable to connect PeerJS network adapter to ${url}`));
+      });
+    });
+  }
+
+  attachConnectionHandlers(connection) {
+    const remoteId = connection.peer;
+    if (!remoteId) {
+      return;
+    }
+
+    this.connections.set(remoteId, connection);
+
+    connection.on('data', (payload) => {
+      const deliveries = [];
+      for (const handler of this.messageHandlers) {
+        deliveries.push(handler(payload));
+      }
+      return Promise.all(deliveries);
+    });
+
+    connection.on('close', () => {
+      this.connections.delete(remoteId);
+    });
+  }
+
+  async connectToPeer(remotePeerId) {
+    if (!remotePeerId || remotePeerId === this.nodeId) {
+      return null;
+    }
+
+    const existing = this.connections.get(remotePeerId);
+    if (existing && existing.open) {
+      return existing;
+    }
+
+    if (this.pendingConnections.has(remotePeerId)) {
+      return this.pendingConnections.get(remotePeerId);
+    }
+
+    if (!this.peer) {
+      throw new Error('PeerJS network adapter has not been started');
+    }
+
+    const pending = new Promise((resolve, reject) => {
+      const connection = this.peer.connect(remotePeerId, {
+        reliable: true,
+        serialization: 'json'
+      });
+
+      const timeout = setTimeout(() => {
+        reject(new Error(`Unable to connect to peer ${remotePeerId}`));
+      }, this.connectTimeoutMs);
+
+      connection.on('open', () => {
+        clearTimeout(timeout);
+        this.attachConnectionHandlers(connection);
+        resolve(connection);
+      });
+
+      connection.on('error', () => {
+        clearTimeout(timeout);
+        reject(new Error(`Unable to connect to peer ${remotePeerId}`));
+      });
+    }).finally(() => {
+      this.pendingConnections.delete(remotePeerId);
+    });
+
+    this.pendingConnections.set(remotePeerId, pending);
+    return pending;
+  }
+
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+  }
+
+  offMessage(handler) {
+    this.messageHandlers.delete(handler);
+  }
+
+  async broadcast(message) {
+    if (!this.peer) {
+      throw new Error('PeerJS network adapter has not been started');
+    }
+
+    const deliveries = [];
+    for (const connection of this.connections.values()) {
+      if (connection.open) {
+        deliveries.push(connection.send(message));
+      }
+    }
+
+    await Promise.all(deliveries);
+  }
+
+  getOpenConnectionCount() {
+    return this.listOpenPeerIds().length;
+  }
+
+  listOpenPeerIds() {
+    const ids = [];
+    for (const [peerId, connection] of this.connections.entries()) {
+      if (connection.open) {
+        ids.push(peerId);
+      }
+    }
+    return ids;
+  }
+
+  isConnectedTo(remotePeerId) {
+    const connection = this.connections.get(remotePeerId);
+    return Boolean(connection && connection.open);
+  }
+
+  async stop() {
+    for (const connection of this.connections.values()) {
+      if (typeof connection.close === 'function') {
+        connection.close();
+      }
+    }
+
+    this.connections.clear();
+    this.pendingConnections.clear();
+
+    if (this.peer && typeof this.peer.destroy === 'function') {
+      this.peer.destroy();
+    }
+
+    this.peer = null;
+    this.nodeId = null;
+  }
+}
+
+function createPeerJSNetworkAdapter(options = {}) {
+  return new PeerJSNetworkAdapter(options);
+}
+
+module.exports = {
+  PeerJSNetworkAdapter,
+  createPeerJSNetworkAdapter,
+  parsePeerJsServerUrl
+};

package/src/persistence/indexeddb-persistence.js

@@ -71,6 +71,7 @@ class IndexedDBPersistence {
       collection,
       id,
       ownerId: record.ownerId,
+      collaboratorIds: Array.isArray(record.collaboratorIds) ? [...record.collaboratorIds] : [],
       data: { ...record.data },
       createdAt: record.createdAt,
       updatedAt: record.updatedAt,
@@ -140,6 +141,7 @@ class IndexedDBPersistence {
       this.node.restoreRecord(stored.collection, {
         id: stored.id,
         ownerId: stored.ownerId,
+        collaboratorIds: stored.collaboratorIds,
         data: stored.data,
         createdAt: stored.createdAt,
         updatedAt: stored.updatedAt,

package/src/react/index.js

@@ -107,8 +107,150 @@ function usePeers(node, scope = 'main', options = {}) {
   return peers;
 }
 
+function useObject(node, collectionName, objectId) {
+  const [record, setRecord] = useState(null);
+
+  const refresh = useCallback(() => {
+    if (!node || !collectionName || !objectId) {
+      setRecord(null);
+      return;
+    }
+
+    setRecord(node.read(collectionName, objectId));
+  }, [node, collectionName, objectId]);
+
+  useEffect(() => {
+    refresh();
+
+    if (!node) {
+      return undefined;
+    }
+
+    const handleChange = (event) => {
+      if (
+        event &&
+        event.collection === collectionName &&
+        event.id === objectId
+      ) {
+        refresh();
+      }
+    };
+
+    node.on('change', handleChange);
+    return () => node.off('change', handleChange);
+  }, [node, collectionName, objectId, refresh]);
+
+  return record;
+}
+
+function useDiscovery(node, scope = 'main', options = null) {
+  const [joined, setJoined] = useState(false);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    if (!node || !scope || !options) {
+      setJoined(false);
+      setError(null);
+      return undefined;
+    }
+
+    let cancelled = false;
+
+    node.joinDiscovery(scope, options)
+      .then(() => {
+        if (!cancelled) {
+          setJoined(true);
+          setError(null);
+        }
+      })
+      .catch((joinError) => {
+        if (!cancelled) {
+          setJoined(false);
+          setError(joinError);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+      node.leaveDiscovery(scope).catch(() => undefined);
+      setJoined(false);
+    };
+  }, [node, scope, options]);
+
+  return { joined, error };
+}
+
+function useConnectionStats(node, pollIntervalMs = 2000) {
+  const [stats, setStats] = useState({ openCount: 0, peerIds: [] });
+
+  const refresh = useCallback(() => {
+    if (!node || typeof node.getConnectionStats !== 'function') {
+      setStats({ openCount: 0, peerIds: [] });
+      return;
+    }
+
+    setStats(node.getConnectionStats());
+  }, [node]);
+
+  useEffect(() => {
+    refresh();
+
+    if (!node || !pollIntervalMs) {
+      return undefined;
+    }
+
+    const timer = setInterval(refresh, pollIntervalMs);
+    return () => clearInterval(timer);
+  }, [node, pollIntervalMs, refresh]);
+
+  return stats;
+}
+
+function useRoom(node, scope = 'main', options = null) {
+  const peersOptions = options && options.peersOptions ? options.peersOptions : {};
+  const { joined, error } = useDiscovery(node, scope, options);
+  const peers = usePeers(node, scope, peersOptions);
+  const connectionStats = useConnectionStats(node, options?.connectionPollMs ?? 2000);
+
+  return {
+    joined,
+    error,
+    peers,
+    connectionStats
+  };
+}
+
+function useMessages(node, filter = null) {
+  const [messages, setMessages] = useState([]);
+
+  useEffect(() => {
+    if (!node) {
+      setMessages([]);
+      return undefined;
+    }
+
+    const handleMessage = (message) => {
+      if (typeof filter === 'function' && !filter(message)) {
+        return;
+      }
+
+      setMessages((current) => [...current, message]);
+    };
+
+    node.on('message', handleMessage);
+    return () => node.off('message', handleMessage);
+  }, [node, filter]);
+
+  return messages;
+}
+
 module.exports = {
   useDignity,
   useCollection,
-  usePeers
+  usePeers,
+  useObject,
+  useDiscovery,
+  useConnectionStats,
+  useRoom,
+  useMessages
 };

package/src/signaling/parse-peerjs-url.js

@@ -0,0 +1,24 @@
+function parsePeerJsServerUrl(url) {
+  const parsed = new URL(url);
+  const secure = parsed.protocol === 'wss:';
+  const host = parsed.hostname;
+  const port = parsed.port ? Number(parsed.port) : secure ? 443 : 80;
+  const key = parsed.searchParams.get('key') || 'peerjs';
+
+  let path = parsed.pathname || '/';
+
+  // dignity.js URLs describe the final PeerJS websocket path (often ending in /peerjs).
+  // The official PeerJS client always appends "peerjs" to `path`, so strip that suffix
+  // to avoid connections like /peerjs/peerjs.
+  if (path.endsWith('/peerjs')) {
+    path = path.slice(0, -'/peerjs'.length) || '/';
+  }
+
+  if (path !== '/' && !path.endsWith('/')) {
+    path += '/';
+  }
+
+  return { secure, host, port, path, key };
+}
+
+module.exports = parsePeerJsServerUrl;

package/src/signaling/peerjs-signaling-provider.js

@@ -1,4 +1,5 @@
 const WebSocketSignalingProvider = require('./websocket-signaling-provider');
+const parsePeerJsServerUrl = require('./parse-peerjs-url');
 
 class PeerJSSignalingProvider {
   constructor({ id, url, PeerImpl, WebSocketImpl, priority = 0, connectTimeoutMs = 10000 }) {
@@ -30,14 +31,7 @@ class PeerJSSignalingProvider {
   }
 
   parsePeerJsServerUrl() {
-    const parsed = new URL(this.url);
-    const secure = parsed.protocol === 'wss:';
-    const host = parsed.hostname;
-    const port = parsed.port ? Number(parsed.port) : secure ? 443 : 80;
-    const path = parsed.pathname || '/';
-    const key = parsed.searchParams.get('key') || 'peerjs';
-
-    return { secure, host, port, path, key };
+    return parsePeerJsServerUrl(this.url);
   }
 
   shouldUseWebSocketFallback() {