@dxos/client-services 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/src/packlets/locks/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './resource-lock';
-export * from './node';
+export type * from './resource-lock';
+export * from '#locks-platform';

package/src/packlets/logging/logging-service.ts

@@ -13,12 +13,12 @@ import {
   log,
 } from '@dxos/log';
 import {
+  type ControlMetricsRequest,
+  type ControlMetricsResponse,
   type LogEntry,
   type LoggingService,
   type Metrics,
   QueryLogsRequest,
-  type ControlMetricsRequest,
-  type ControlMetricsResponse,
   type QueryMetricsRequest,
   type QueryMetricsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
@@ -26,6 +26,10 @@ import { getDebugName, jsonify, numericalValues, tracer } from '@dxos/util';
 
 /**
  * Logging service used to spy on logs of the host.
+ *
+ * @deprecated This was created so that logs from the shared worker (WorkerClientServices) could be
+ * seen in the main window console without opening the shared worker DevTools. Shared worker client
+ * services is deprecated; dedicated worker logs already show in the main window console.
  */
 export class LoggingServiceImpl implements LoggingService {
   private readonly _logs = new Event<NaturalLogEntry>();
@@ -37,7 +41,7 @@ export class LoggingServiceImpl implements LoggingService {
   }
 
   async close(): Promise<void> {
-    const index = log.runtimeConfig.processors.findIndex((processor) => processor === this._logProcessor);
+    const index = log.runtimeConfig.processors.findIndex((processor: LogProcessor) => processor === this._logProcessor);
     log.runtimeConfig.processors.splice(index, 1);
   }
 
@@ -112,6 +116,7 @@ export class LoggingServiceImpl implements LoggingService {
 
         const record: LogEntry = {
           ...entry,
+          message: entry.message ?? (entry.error ? (entry.error.message ?? String(entry.error)) : ''),
           context: jsonify(getContextFromEntry(entry)),
           timestamp: new Date(),
           meta: {

package/src/packlets/logging/logging.test.ts

@@ -5,7 +5,7 @@
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
-import { log, LogLevel } from '@dxos/log';
+import { LogLevel, log } from '@dxos/log';
 import { type LogEntry } from '@dxos/protocols/proto/dxos/client/services';
 
 import { LoggingServiceImpl } from './logging-service';

package/src/packlets/network/network-service.test.ts

@@ -2,15 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { type NetworkService, ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
+import { ConnectionState, type NetworkService } from '@dxos/protocols/proto/dxos/client/services';
 
-import { NetworkServiceImpl } from './network-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
+import { NetworkServiceImpl } from './network-service';
 
 describe('NetworkService', () => {
   let serviceContext: ServiceContext;

package/src/packlets/network/network-service.ts

@@ -2,20 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
+import { type RequestOptions } from '@dxos/codec-protobuf';
 import { Stream } from '@dxos/codec-protobuf/stream';
+import { Context } from '@dxos/context';
 import { type EdgeConnection } from '@dxos/edge-client';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import {
-  type SubscribeSwarmStateRequest,
   type NetworkService,
   type NetworkStatus,
+  type SubscribeSwarmStateRequest,
   type UpdateConfigRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Peer, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import {
-  type LeaveRequest,
   type JoinRequest,
+  type LeaveRequest,
   type Message,
   type QueryRequest,
 } from '@dxos/protocols/proto/dxos/edge/signal';
@@ -47,16 +49,16 @@ export class NetworkServiceImpl implements NetworkService {
     await this.networkManager.setConnectionState(request.swarm);
   }
 
-  async joinSwarm(request: JoinRequest): Promise<void> {
-    return this.signalManager.join(request);
+  async joinSwarm(request: JoinRequest, options?: RequestOptions): Promise<void> {
+    return this.signalManager.join(options?.ctx ?? Context.default(), request);
   }
 
-  async leaveSwarm(request: LeaveRequest): Promise<void> {
-    return this.signalManager.leave(request);
+  async leaveSwarm(request: LeaveRequest, options?: RequestOptions): Promise<void> {
+    return this.signalManager.leave(options?.ctx ?? Context.default(), request);
   }
 
-  async querySwarm(request: QueryRequest): Promise<SwarmResponse> {
-    return this.signalManager.query(request);
+  async querySwarm(request: QueryRequest, options?: RequestOptions): Promise<SwarmResponse> {
+    return this.signalManager.query(options?.ctx ?? Context.default(), request);
   }
 
   subscribeSwarmState(request: SubscribeSwarmStateRequest): Stream<SwarmResponse> {
@@ -69,8 +71,8 @@ export class NetworkServiceImpl implements NetworkService {
     });
   }
 
-  async sendMessage(message: Message): Promise<void> {
-    return this.signalManager.sendMessage(message);
+  async sendMessage(message: Message, options?: RequestOptions): Promise<void> {
+    return this.signalManager.sendMessage(options?.ctx ?? Context.default(), message);
   }
 
   subscribeMessages(peer: Peer): Stream<Message> {

package/src/packlets/services/client-rpc-server.ts

@@ -3,25 +3,27 @@
 //
 
 import { type ClientServices } from '@dxos/client-protocol';
-import { type Any, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
+import { type Any, type RequestOptions, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
 import { raise } from '@dxos/debug';
-import { parseMethodName, RpcPeer, type RpcPeerOptions, type ServiceBundle } from '@dxos/rpc';
+import { RpcPeer, type RpcPeerOptions, type ServiceBundle, parseMethodName } from '@dxos/rpc';
 import { MapCounter, trace } from '@dxos/tracing';
 import { type MaybePromise } from '@dxos/util';
 
 import { type ServiceRegistry } from './service-registry';
 
-export type ClientRpcServerParams = {
+export type ClientRpcServerProps = {
   serviceRegistry: ServiceRegistry<ClientServices>;
   handleCall?: (
     method: string,
     params: Any,
-    handler: (method: string, params: Any) => MaybePromise<Any>,
+    handler: (method: string, params: Any, options?: RequestOptions) => MaybePromise<Any>,
+    options?: RequestOptions,
   ) => Promise<Any>;
   handleStream?: (
     method: string,
     params: Any,
-    handler: (method: string, params: Any) => Stream<Any>,
+    handler: (method: string, params: Any, options?: RequestOptions) => Stream<Any>,
+    options?: RequestOptions,
   ) => MaybePromise<Stream<Any>>;
 } & Omit<RpcPeerOptions, 'callHandler' | 'streamHandler'>;
 
@@ -30,8 +32,8 @@ export class ClientRpcServer {
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _rpcPeer: RpcPeer;
   private readonly _handlerCache = new Map<string, ServiceHandler<any>>();
-  private readonly _handleCall: ClientRpcServerParams['handleCall'];
-  private readonly _handleStream: ClientRpcServerParams['handleStream'];
+  private readonly _handleCall: ClientRpcServerProps['handleCall'];
+  private readonly _handleStream: ClientRpcServerProps['handleStream'];
 
   @trace.metricsCounter()
   private readonly _callMetrics = new MapCounter();
@@ -41,7 +43,7 @@ export class ClientRpcServer {
     return Object.keys(this._serviceRegistry.services);
   }
 
-  constructor(params: ClientRpcServerParams) {
+  constructor(params: ClientRpcServerProps) {
     const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
     this._handleCall = handleCall;
     this._handleStream = handleStream;
@@ -49,32 +51,33 @@ export class ClientRpcServer {
     this._serviceRegistry = serviceRegistry;
     this._rpcPeer = new RpcPeer({
       ...rpcOptions,
-      callHandler: (method, params) => {
+      callHandler: (method, params, options) => {
         const [serviceName, methodName] = parseMethodName(method);
-        const handler = (method: string, params: Any) => this._getServiceHandler(serviceName).call(method, params);
+        const handler = (method: string, params: Any, handlerOptions?: RequestOptions) =>
+          this._getServiceHandler(serviceName).call(method, params, handlerOptions);
 
         this._callMetrics.inc(`${serviceName}.${methodName} request`);
 
         if (this._handleCall) {
-          return this._handleCall(methodName, params, handler);
+          return this._handleCall(methodName, params, handler, options);
         } else {
-          return handler(methodName, params);
+          return handler(methodName, params, options);
         }
       },
-      streamHandler: (method, params) => {
+      streamHandler: (method, params, options) => {
         const [serviceName, methodName] = parseMethodName(method);
-        const handler = (method: string, params: Any) =>
-          this._getServiceHandler(serviceName).callStream(method, params);
+        const handler = (method: string, params: Any, handlerOptions?: RequestOptions) =>
+          this._getServiceHandler(serviceName).callStream(method, params, handlerOptions);
 
         this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
 
         if (this._handleStream) {
-          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params, handler)), (data) => {
+          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params, handler, options)), (data) => {
             this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
             return data;
           });
         } else {
-          return handler(methodName, params);
+          return handler(methodName, params, options);
         }
       },
     });

package/src/packlets/services/feed-syncer.test.ts

@@ -0,0 +1,340 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Encoder, decode as cborDecode } from 'cbor-x';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { describe, expect, onTestFinished, test, vi } from 'vitest';
+
+import { Event } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { type EdgeConnection, MessageSchema } from '@dxos/edge-client';
+import { RuntimeProvider } from '@dxos/effect';
+import { FeedStore, SyncServer } from '@dxos/feed';
+import { ObjectId, SpaceId } from '@dxos/keys';
+import { FeedProtocol } from '@dxos/protocols';
+import { EdgeService } from '@dxos/protocols';
+import { createBuf } from '@dxos/protocols/buf';
+import { type Message as RouterMessage } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
+import { SqlTransaction } from '@dxos/sql-sqlite';
+import { layerMemory } from '@dxos/sql-sqlite/platform';
+import { bufferToArray } from '@dxos/util';
+
+import { FeedSyncer } from './feed-syncer';
+
+type ProtocolMessage = FeedProtocol.ProtocolMessage;
+
+const encoder = new Encoder({ tagUint8Array: false, useRecords: false });
+const syncNamespace = FeedProtocol.WellKnownNamespaces.data;
+const syncNamespaces = [FeedProtocol.WellKnownNamespaces.data, FeedProtocol.WellKnownNamespaces.trace];
+
+const createRuntime = () => {
+  const baseLayer = layerMemory;
+  const transactionLayer = SqlTransaction.layer.pipe(Layer.provide(baseLayer));
+  return ManagedRuntime.make(Layer.merge(baseLayer, transactionLayer).pipe(Layer.orDie));
+};
+
+const createFeedStore = (localActorId: string, assignPositions: boolean) =>
+  new FeedStore({ localActorId, assignPositions });
+
+const createEdgeConnection = ({
+  syncServer,
+  serverRuntime,
+  messageListeners,
+}: {
+  syncServer: SyncServer;
+  serverRuntime: ReturnType<typeof createRuntime>;
+  messageListeners: Set<(message: RouterMessage) => void>;
+}): EdgeConnection => {
+  const reconnectListeners = new Set<() => void>();
+
+  return {
+    statusChanged: new Event<any>(),
+    info: {},
+    identityKey: 'client-identity',
+    peerKey: 'client-peer',
+    isOpen: true,
+    status: {
+      state: EdgeStatus.ConnectionState.CONNECTED,
+      rtt: 0,
+      uptime: 0,
+      rateBytesUp: 0,
+      rateBytesDown: 0,
+      messagesSent: 0,
+      messagesReceived: 0,
+    },
+    setIdentity: () => {},
+    open: async () => {},
+    close: async () => {},
+    send: async (ctx, routerMessage: RouterMessage) => {
+      const decoded = cborDecode(routerMessage.payload!.value) as ProtocolMessage;
+      await syncServer.handleMessage(ctx, decoded).pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+    },
+    onMessage: (listener: (message: RouterMessage) => void) => {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    onReconnected: (listener: () => void) => {
+      reconnectListeners.add(listener);
+      return () => reconnectListeners.delete(listener);
+    },
+  };
+};
+
+const createFeedSyncHarness = async ({
+  spaceId,
+  pollingInterval,
+  syncNamespaces: namespaces = [syncNamespace],
+}: {
+  spaceId: SpaceId;
+  pollingInterval?: number;
+  syncNamespaces?: string[];
+}) => {
+  const serverRuntime = createRuntime();
+  const clientRuntime = createRuntime();
+  const serverFeedStore = createFeedStore('server', true);
+  const clientFeedStore = createFeedStore('client', false);
+
+  await serverFeedStore.migrate().pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+  await clientFeedStore.migrate().pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+  const messageListeners = new Set<(message: RouterMessage) => void>();
+  const syncServer = new SyncServer({
+    peerId: 'server',
+    feedStore: serverFeedStore,
+    sendMessage: (_ctx, message) =>
+      Effect.promise(async () => {
+        const routerMessage = createBuf(MessageSchema, {
+          source: {
+            identityKey: 'server-identity',
+            peerKey: 'server-peer',
+          },
+          serviceId: `${EdgeService.QUEUE_REPLICATOR}:test`,
+          payload: { value: bufferToArray(encoder.encode(message)) },
+        });
+
+        for (const listener of messageListeners) {
+          listener(routerMessage);
+        }
+      }),
+  });
+
+  const edgeClient = createEdgeConnection({ syncServer, serverRuntime, messageListeners });
+
+  const syncer = new FeedSyncer({
+    runtime: clientRuntime.runtimeEffect,
+    feedStore: clientFeedStore,
+    edgeClient: edgeClient as any,
+    peerId: 'client',
+    getSpaceIds: () => [spaceId],
+    syncNamespaces: namespaces,
+    pollingInterval,
+  });
+
+  const close = async () => {
+    await syncer.close();
+    await clientRuntime.dispose();
+    await serverRuntime.dispose();
+  };
+
+  onTestFinished(close);
+
+  return { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer, close };
+};
+
+describe('FeedSyncer', () => {
+  test('syncs mixed pull and push traffic', async () => {
+    const spaceId = SpaceId.random();
+    const { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer } = await createFeedSyncHarness({
+      spaceId,
+    });
+    const serverFeedId = ObjectId.random();
+    const clientFeedId = ObjectId.random();
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([1, 2, 3]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await syncer.open(new Context());
+
+    await vi.waitFor(async () => {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].data).toEqual(new Uint8Array([1, 2, 3]));
+      expect(blocks[0].position).toBeDefined();
+    });
+
+    await clientFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: clientFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([9, 8, 7]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+    await vi.waitFor(async () => {
+      const { blocks } = await serverFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [clientFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].data).toEqual(new Uint8Array([9, 8, 7]));
+      expect(blocks[0].position).toBeDefined();
+    });
+  });
+
+  test('requestPoll triggers best-effort pull for a space', async () => {
+    const spaceId = SpaceId.random();
+    const { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer } = await createFeedSyncHarness({
+      spaceId,
+      pollingInterval: 60_000,
+    });
+    const serverFeedId = ObjectId.random();
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([1, 2, 3]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await syncer.open(new Context());
+
+    await vi.waitFor(async () => {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].data).toEqual(new Uint8Array([1, 2, 3]));
+    });
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([4, 5, 6]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+      expect(blocks).toHaveLength(1);
+    }
+
+    syncer.schedulePoll();
+
+    await vi.waitFor(async () => {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(2);
+      expect(blocks[1].data).toEqual(new Uint8Array([4, 5, 6]));
+    });
+  });
+
+  test('syncs all configured namespaces', async () => {
+    const spaceId = SpaceId.random();
+    const { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer } = await createFeedSyncHarness({
+      spaceId,
+      syncNamespaces,
+    });
+    const serverDataFeedId = ObjectId.random();
+    const serverTraceFeedId = ObjectId.random();
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverDataFeedId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.data,
+          data: new Uint8Array([1, 2, 3]),
+        },
+        {
+          spaceId,
+          feedId: serverTraceFeedId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.trace,
+          data: new Uint8Array([7, 8, 9]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await syncer.open(new Context());
+
+    await vi.waitFor(async () => {
+      const dataResult = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.data,
+          position: -1,
+          query: { feedIds: [serverDataFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+      const traceResult = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.trace,
+          position: -1,
+          query: { feedIds: [serverTraceFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(dataResult.blocks).toHaveLength(1);
+      expect(traceResult.blocks).toHaveLength(1);
+      expect(dataResult.blocks[0].data).toEqual(new Uint8Array([1, 2, 3]));
+      expect(traceResult.blocks[0].data).toEqual(new Uint8Array([7, 8, 9]));
+    });
+  });
+});