Rename inbound sync API

Author: marcus-pousette

examples/playground/src/playground/hooks/usePlaygroundLiveSubscriptions.ts

@@ -7,7 +7,7 @@ import {
   type SetStateAction,
 } from 'react';
 import type { Operation } from '@treecrdt/interface';
-import { createScopeController, type ScopeController, type SyncScope } from '@treecrdt/sync';
+import { createInboundSync, type InboundSync, type SyncScope } from '@treecrdt/sync';
 import type { Filter, SyncMessage, SyncPeer } from '@treecrdt/sync-protocol';
 import type { DuplexTransport } from '@treecrdt/sync-protocol/transport';
 
@@ -34,8 +34,8 @@ export function usePlaygroundLiveSubscriptions(opts: {
   const [liveAllEnabled, setLiveAllEnabled] = useState(false);
   const liveChildrenParentsRef = useRef<Set<string>>(new Set());
   const liveAllEnabledRef = useRef(false);
-  const scopeControllerRef = useRef<ScopeController<Operation> | null>(null);
-  const scopeControllerPeerRef = useRef<SyncPeer<Operation> | null>(null);
+  const inboundSyncRef = useRef<InboundSync<Operation> | null>(null);
+  const inboundSyncPeerRef = useRef<SyncPeer<Operation> | null>(null);
   const liveAllScopeRef = useRef<SyncScope | null>(null);
   const liveChildScopesRef = useRef<Map<string, SyncScope>>(new Map());
   const liveBusyCountRef = useRef(0);
@@ -50,19 +50,19 @@ export function usePlaygroundLiveSubscriptions(opts: {
     setLiveBusy(liveBusyCountRef.current > 0);
   };
 
-  const ensureScopeController = () => {
+  const ensureInboundSync = () => {
     const peer = syncPeerRef.current;
     if (!peer) return null;
-    if (scopeControllerRef.current && scopeControllerPeerRef.current === peer) {
-      return scopeControllerRef.current;
+    if (inboundSyncRef.current && inboundSyncPeerRef.current === peer) {
+      return inboundSyncRef.current;
     }
 
-    scopeControllerRef.current?.close();
+    inboundSyncRef.current?.close();
     liveAllScopeRef.current = null;
     liveChildScopesRef.current.clear();
 
-    const controller = createScopeController<Operation>({
-      peer,
+    const inbound = createInboundSync<Operation>({
+      localPeer: peer,
       subscribeOptions: (peerId) => syncOnceOptionsForPeer(peerId, 1024),
       onWorkStart: beginLiveWork,
       onWorkEnd: endLiveWork,
@@ -71,15 +71,15 @@ export function usePlaygroundLiveSubscriptions(opts: {
         setSyncError(formatSyncError(error));
       },
     });
-    scopeControllerRef.current = controller;
-    scopeControllerPeerRef.current = peer;
-    return controller;
+    inboundSyncRef.current = inbound;
+    inboundSyncPeerRef.current = peer;
+    return inbound;
   };
 
   const ensureLiveAllScope = () => {
-    const controller = ensureScopeController();
-    if (!controller) return;
-    const scope = liveAllScopeRef.current ?? controller.scope({ all: {} });
+    const inbound = ensureInboundSync();
+    if (!inbound) return;
+    const scope = liveAllScopeRef.current ?? inbound.scope({ all: {} });
     liveAllScopeRef.current = scope;
     scope.startLive();
   };
@@ -90,15 +90,15 @@ export function usePlaygroundLiveSubscriptions(opts: {
   };
 
   const ensureLiveChildScope = (parentId: string) => {
-    const controller = ensureScopeController();
-    if (!controller) return;
+    const inbound = ensureInboundSync();
+    if (!inbound) return;
     const existing = liveChildScopesRef.current.get(parentId);
     if (existing) {
       existing.startLive();
       return;
     }
 
-    const scope = controller.scope({ children: { parent: hexToBytes16(parentId) } });
+    const scope = inbound.scope({ children: { parent: hexToBytes16(parentId) } });
     liveChildScopesRef.current.set(parentId, scope);
     scope.startLive();
   };
@@ -115,15 +115,15 @@ export function usePlaygroundLiveSubscriptions(opts: {
     for (const parentId of liveChildrenParentsRef.current) ensureLiveChildScope(parentId);
   };
 
-  const setLivePeer = (peerId: string, conn: PlaygroundSyncConnection) => {
-    const controller = ensureScopeController();
-    if (!controller) return;
-    controller.setPeer(peerId, conn.transport as DuplexTransport<SyncMessage<Operation>>);
+  const addLivePeer = (peerId: string, conn: PlaygroundSyncConnection) => {
+    const inbound = ensureInboundSync();
+    if (!inbound) return;
+    inbound.addPeer(peerId, conn.transport as DuplexTransport<SyncMessage<Operation>>);
     startDesiredScopes();
   };
 
-  const deleteLivePeer = (peerId: string) => {
-    scopeControllerRef.current?.deletePeer(peerId);
+  const removeLivePeer = (peerId: string) => {
+    inboundSyncRef.current?.removePeer(peerId);
   };
 
   const toggleLiveChildren = (parentId: string) => {
@@ -136,9 +136,9 @@ export function usePlaygroundLiveSubscriptions(opts: {
   };
 
   const resetLiveWork = () => {
-    scopeControllerRef.current?.close();
-    scopeControllerRef.current = null;
-    scopeControllerPeerRef.current = null;
+    inboundSyncRef.current?.close();
+    inboundSyncRef.current = null;
+    inboundSyncPeerRef.current = null;
     liveAllScopeRef.current = null;
     liveChildScopesRef.current.clear();
     liveBusyCountRef.current = 0;
@@ -176,8 +176,8 @@ export function usePlaygroundLiveSubscriptions(opts: {
     liveAllEnabledRef,
     beginLiveWork,
     endLiveWork,
-    setLivePeer,
-    deleteLivePeer,
+    addLivePeer,
+    removeLivePeer,
     resetLiveWork,
   };
 }

examples/playground/src/playground/hooks/usePlaygroundSync.ts

@@ -3,10 +3,10 @@ import type { Operation } from '@treecrdt/interface';
 import { bytesToHex } from '@treecrdt/interface/ids';
 import { SyncPeer, deriveOpRefV0, type Filter, type SyncAuth } from '@treecrdt/sync-protocol';
 import {
+  createInboundSync,
   createOutboundSync,
-  createScopeController,
+  type InboundSync,
   type OutboundSync,
-  type ScopeController,
 } from '@treecrdt/sync';
 import { createTreecrdtSyncBackendFromClient } from '@treecrdt/sync-sqlite';
 import type {
@@ -191,8 +191,8 @@ export function usePlaygroundSync(opts: UsePlaygroundSyncOptions): PlaygroundSyn
     liveAllEnabledRef,
     beginLiveWork,
     endLiveWork,
-    setLivePeer,
-    deleteLivePeer,
+    addLivePeer,
+    removeLivePeer,
     resetLiveWork,
   } = usePlaygroundLiveSubscriptions({
     syncPeerRef,
@@ -231,7 +231,7 @@ export function usePlaygroundSync(opts: UsePlaygroundSyncOptions): PlaygroundSyn
     }
     connections.delete(peerId);
     outboundSyncRef.current?.removePeer(peerId);
-    deleteLivePeer(peerId);
+    removeLivePeer(peerId);
 
     if (isRemotePeerId(peerId)) setRemotePeer(null);
     else removeMeshPeer(peerId);
@@ -279,35 +279,35 @@ export function usePlaygroundSync(opts: UsePlaygroundSyncOptions): PlaygroundSyn
 
     setSyncBusy(true);
     setSyncError(null);
-    let manualSyncController: ScopeController<Operation> | null = null;
+    let manualInboundSync: InboundSync<Operation> | null = null;
     try {
       const targets = selectSyncTargetIds(connections).filter((peerId) => connections.has(peerId));
-      manualSyncController = createScopeController<Operation>({
-        peer,
-        selectSyncPeerIds: () => targets,
-        runSync: async ({ peer, peerId, transport, filter }) => {
-          await syncFiltersWithTransport(peer, peerId, transport, [filter], {
+      manualInboundSync = createInboundSync<Operation>({
+        localPeer: peer,
+        selectPeers: () => targets,
+        runSync: async ({ localPeer, peerId, transport, filter }) => {
+          await syncFiltersWithTransport(localPeer, peerId, transport, [filter], {
             multipleTargets: targets.length > 1,
             label,
           });
         },
         onError: ({ peerId, error }) => {
           console.error(`${label} failed for peer`, peerId, error);
-          manualSyncController?.deletePeer(peerId);
+          manualInboundSync?.removePeer(peerId);
           if (isCapabilityRevokedError(error)) return;
           dropPeerConnection(peerId);
         },
       });
       for (const [peerId, conn] of connections) {
-        manualSyncController.setPeer(peerId, conn.transport);
+        manualInboundSync.addPeer(peerId, conn.transport);
       }
-      for (const filter of filters) await manualSyncController.scope(filter).syncOnce();
+      for (const filter of filters) await manualInboundSync.scope(filter).syncOnce();
       await refreshMeta();
     } catch (err) {
       console.error(`${label} failed`, err);
       setSyncError(formatSyncError(err));
     } finally {
-      manualSyncController?.close();
+      manualInboundSync?.close();
       setSyncBusy(false);
     }
   };
@@ -601,7 +601,7 @@ export function usePlaygroundSync(opts: UsePlaygroundSyncOptions): PlaygroundSyn
       }
       const conn = connections.get(peerId);
       if (!conn) return;
-      setLivePeer(peerId, conn);
+      addLivePeer(peerId, conn);
     };
 
     const mesh = channel
@@ -636,7 +636,7 @@ export function usePlaygroundSync(opts: UsePlaygroundSyncOptions): PlaygroundSyn
           onPeerDisconnected: (peerId) => {
             connections.delete(peerId);
             outboundSync.removePeer(peerId);
-            deleteLivePeer(peerId);
+            removeLivePeer(peerId);
             removeMeshPeer(peerId);
           },
           onBroadcastMessage: (data) => {