@dxos/client-services 0.6.11 → 0.6.12-main.5a87ad5

package/src/packlets/invitations/space-invitation-protocol.test.ts

@@ -2,20 +2,21 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
+import { onTestFinished, describe, expect, test } from 'vitest';
 
 import { asyncChain, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest, describe, test } from '@dxos/test';
 
 import { type ServiceContext } from '../services';
 import { createIdentity, createPeers } from '../testing';
 import { acceptInvitation, createInvitation, performInvitation } from '../testing/invitation-utils';
 
 const closeAfterTest = async (peer: ServiceContext) => {
-  afterTest(() => peer.close());
+  onTestFinished(async () => {
+    await peer.close();
+  });
   return peer;
 };
 

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

@@ -2,12 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { expect } from 'chai';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { log, LogLevel } from '@dxos/log';
 import { type LogEntry } from '@dxos/protocols/proto/dxos/client/services';
-import { beforeEach, describe, test } from '@dxos/test';
 
 import { LoggingServiceImpl } from './logging-service';
 

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

@@ -2,12 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { expect } from 'chai';
+import { afterEach, onTestFinished, beforeEach, describe, expect, 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 { afterEach, afterTest, beforeEach, describe, test } from '@dxos/test';
 
 import { NetworkServiceImpl } from './network-service';
 import { type ServiceContext } from '../services';
@@ -41,7 +40,7 @@ describe('NetworkService', () => {
     query.subscribe(({ swarm }) => {
       result.wake(swarm);
     });
-    afterTest(() => query.close());
+    onTestFinished(() => query.close());
     expect(await result.wait()).to.equal(ConnectionState.ONLINE);
 
     result = new Trigger<ConnectionState | undefined>();

package/src/packlets/services/service-context.test.ts

@@ -2,9 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
+import { describe, test } from 'vitest';
+
 import { MemorySignalManagerContext, MemorySignalManager } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { describe, openAndClose, test } from '@dxos/test';
+import { openAndClose } from '@dxos/test-utils';
 
 import { createServiceContext, performInvitation } from '../testing';
 

package/src/packlets/services/service-context.ts

@@ -6,8 +6,14 @@ import { Trigger } from '@dxos/async';
 import { Context, Resource } from '@dxos/context';
 import { getCredentialAssertion, type CredentialProcessor } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { EchoEdgeReplicator, EchoHost } from '@dxos/echo-db';
-import { MeshEchoReplicator, MetadataStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
+import {
+  EchoEdgeReplicator,
+  EchoHost,
+  MeshEchoReplicator,
+  MetadataStore,
+  SpaceManager,
+  valueEncoding,
+} from '@dxos/echo-pipeline';
 import type { EdgeConnection } from '@dxos/edge-client';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
@@ -31,8 +37,8 @@ import { safeInstanceof } from '@dxos/util';
 import {
   IdentityManager,
   type CreateIdentityOptions,
-  type IdentityManagerRuntimeParams,
   type JoinIdentityParams,
+  type IdentityManagerParams,
 } from '../identity';
 import {
   DeviceInvitationProtocol,
@@ -43,7 +49,10 @@ import {
 } from '../invitations';
 import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
-export type ServiceContextRuntimeParams = IdentityManagerRuntimeParams &
+export type ServiceContextRuntimeParams = Pick<
+  IdentityManagerParams,
+  'devicePresenceOfflineTimeout' | 'devicePresenceAnnounceInterval'
+> &
   DataSpaceManagerRuntimeParams & {
     invitationConnectionDefaultParams?: Partial<TeleportParams>;
     disableP2pReplication?: boolean;
@@ -116,13 +125,16 @@ export class ServiceContext extends Resource {
       disableP2pReplication: this._runtimeParams?.disableP2pReplication,
     });
 
-    this.identityManager = new IdentityManager(
-      this.metadataStore,
-      this.keyring,
-      this.feedStore,
-      this.spaceManager,
-      this._runtimeParams as IdentityManagerRuntimeParams,
-      {
+    this.identityManager = new IdentityManager({
+      metadataStore: this.metadataStore,
+      keyring: this.keyring,
+      feedStore: this.feedStore,
+      spaceManager: this.spaceManager,
+      devicePresenceOfflineTimeout: this._runtimeParams?.devicePresenceOfflineTimeout,
+      devicePresenceAnnounceInterval: this._runtimeParams?.devicePresenceAnnounceInterval,
+      edgeConnection: this._edgeConnection,
+      edgeFeatures: this._edgeFeatures,
+      callbacks: {
         onIdentityConstruction: (identity) => {
           if (this._edgeConnection) {
             log.info('Setting identity on edge connection', {
@@ -141,7 +153,7 @@ export class ServiceContext extends Resource {
           }
         },
       },
-    );
+    });
 
     this.echoHost = new EchoHost({ kv: this.level });
 

package/src/packlets/services/service-host.test.ts

@@ -2,9 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
 import { rmSync } from 'node:fs';
+import { afterEach, onTestFinished, describe, expect, test } from 'vitest';
 
 import { asyncTimeout, latch, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
@@ -14,13 +13,10 @@ import { type PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { type Identity } from '@dxos/protocols/proto/dxos/client/services';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { afterTest, describe, test } from '@dxos/test';
 import { isNode } from '@dxos/util';
 
 import { createMockCredential, createServiceHost } from '../testing';
 
-chai.use(chaiAsPromised);
-
 describe('ClientServicesHost', () => {
   const dataRoot = '/tmp/dxos/client-services/service-host/storage';
 
@@ -38,7 +34,7 @@ describe('ClientServicesHost', () => {
   test('queryCredentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    afterTest(() => host.close());
+    onTestFinished(() => host.close());
 
     await host.services.IdentityService!.createIdentity({});
     const { spaceKey } = await host.services.SpacesService!.createSpace();
@@ -49,7 +45,7 @@ describe('ClientServicesHost', () => {
       tick();
       // console.log(credential);
     });
-    afterTest(() => stream.close());
+    onTestFinished(() => stream.close());
 
     await done();
   });
@@ -57,7 +53,7 @@ describe('ClientServicesHost', () => {
   test('write and query credentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    afterTest(() => host.close());
+    onTestFinished(() => host.close());
 
     await host.services.IdentityService!.createIdentity({});
 
@@ -86,7 +82,7 @@ describe('ClientServicesHost', () => {
         queriedCredential.wake(credential);
       }
     });
-    afterTest(() => credentials.close());
+    onTestFinished(() => credentials.close());
 
     await queriedCredential.wait();
   });
@@ -94,7 +90,7 @@ describe('ClientServicesHost', () => {
   test('sign presentation', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    afterTest(() => host.close());
+    onTestFinished(() => host.close());
 
     await host.services.IdentityService!.createIdentity({});
 
@@ -147,9 +143,9 @@ describe('ClientServicesHost', () => {
           trigger.wake(identity.identity);
         }
       });
-      await expect(asyncTimeout(trigger.wait(), 200)).to.be.rejectedWith();
+      await expect(asyncTimeout(trigger.wait(), 200)).rejects.toBeInstanceOf(Error);
       await stream?.close();
       await host.close();
     }
-  }).onlyEnvironments('nodejs', 'chromium', 'firefox');
+  });
 });

package/src/packlets/services/service-host.ts

@@ -15,8 +15,8 @@ import { EdgeSignalManager, WebsocketSignalManager, type SignalManager } from '@
 import {
   SwarmNetworkManager,
   createIceProvider,
-  createSimplePeerTransportFactory,
   type TransportFactory,
+  createRtcTransportFactory,
 } from '@dxos/network-manager';
 import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
@@ -218,7 +218,7 @@ export class ClientServicesHost {
 
     const {
       connectionLog = true,
-      transportFactory = createSimplePeerTransportFactory(
+      transportFactory = createRtcTransportFactory(
         { iceServers: this._config?.get('runtime.services.ice') },
         this._config?.get('runtime.services.iceProviders') &&
           createIceProvider(this._config!.get('runtime.services.iceProviders')!),

package/src/packlets/services/service-registry.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
+import { describe, expect, test } from 'vitest';
 
 import { Event } from '@dxos/async';
 import { type ClientServices } from '@dxos/client-protocol';
@@ -12,7 +12,6 @@ import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols/proto';
 import { type SystemService, SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxos/rpc';
-import { describe, test } from '@dxos/test';
 
 import { ServiceRegistry } from './service-registry';
 import { SystemServiceImpl } from '../system';

package/src/packlets/spaces/data-space-manager.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
+import { describe, expect, test } from 'vitest';
 
 import { asyncTimeout, latch } from '@dxos/async';
 import { createAdmissionCredentials } from '@dxos/credentials';
@@ -10,7 +10,7 @@ import { AuthStatus } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { log } from '@dxos/log';
 import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
-import { describe, openAndClose, test } from '@dxos/test';
+import { openAndClose } from '@dxos/test-utils';
 
 import { TestBuilder, type TestPeer } from '../testing';
 

package/src/packlets/spaces/data-space-manager.ts

@@ -14,8 +14,11 @@ import {
   type DelegateInvitationCredential,
   type MemberInfo,
 } from '@dxos/credentials';
-import { convertLegacyReferences, findInlineObjectOfType, type EchoEdgeReplicator, type EchoHost } from '@dxos/echo-db';
 import {
+  convertLegacyReferences,
+  findInlineObjectOfType,
+  type EchoEdgeReplicator,
+  type EchoHost,
   AuthStatus,
   CredentialServerExtension,
   type MeshEchoReplicator,

package/src/packlets/spaces/data-space.ts

@@ -7,8 +7,13 @@ import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import type { SpecificCredential } from '@dxos/credentials';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import { type EchoHost, type DatabaseRoot } from '@dxos/echo-db';
-import { createMappedFeedWriter, type MetadataStore, type Space } from '@dxos/echo-pipeline';
+import {
+  type EchoHost,
+  type DatabaseRoot,
+  createMappedFeedWriter,
+  type MetadataStore,
+  type Space,
+} from '@dxos/echo-pipeline';
 import { SpaceDocVersion } from '@dxos/echo-protocol';
 import type { EdgeConnection } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -0,0 +1,244 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { decode as decodeCbor, encode as encodeCbor } from 'cbor-x';
+import { getRandomPort } from 'get-port-please';
+import { describe, test, onTestFinished, vi, expect } from 'vitest';
+
+import { Trigger, sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { valueEncoding } from '@dxos/echo-pipeline';
+import { EdgeClient, EdgeIdentityChangedError } from '@dxos/edge-client';
+import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
+import { FeedFactory, FeedStore } from '@dxos/feed-store';
+import { type FeedWrapper } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
+import { PublicKey, SpaceId } from '@dxos/keys';
+import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
+import { createStorage } from '@dxos/random-access-storage';
+import { openAndClose } from '@dxos/test-utils';
+import { Timeframe } from '@dxos/timeframe';
+import { range } from '@dxos/util';
+
+import { EdgeFeedReplicator } from './edge-feed-replicator';
+
+describe('EdgeFeedReplicator', () => {
+  test('requests metadata after connection is open', async () => {
+    const { endpoint, admitConnection, messageSink } = await createEdge();
+    const { messenger, sendSpy } = await createClient(endpoint);
+
+    await attachReplicator(messenger);
+
+    await sleep(50);
+
+    expect(sendSpy).not.toHaveBeenCalled();
+    expect(messageSink.length).toEqual(0);
+
+    admitConnection.wake();
+    await expect.poll(() => sendSpy.mock.calls.length).toEqual(1);
+    expect(messageSink.length).toEqual(1);
+    expect(messageSink[0].type).toEqual('get-metadata');
+  });
+
+  test('sends a block', async () => {
+    const { endpoint, admitConnection, messageSink } = await createEdge();
+    const { messenger } = await createClient(endpoint);
+
+    const { feed } = await attachReplicator(messenger);
+
+    admitConnection.wake();
+    await appendMessage(feed);
+
+    await expect.poll(() => messageSink.length).toEqual(2);
+    expect(messageSink[1].type).toEqual('data');
+  });
+
+  test('re-requests metadata on reconnect', async () => {
+    const { endpoint, admitConnection, messageSink } = await createEdge();
+    const { messenger } = await createClient(endpoint);
+
+    await attachReplicator(messenger);
+
+    admitConnection.wake();
+    await expect.poll(() => messageSink.length).toEqual(1);
+
+    updateIdentity(messenger);
+    await messenger.reconnect.waitForCount(1);
+
+    await expect.poll(() => messageSink.length).toEqual(2);
+    expect(messageSink[1].type).toEqual('get-metadata');
+  });
+
+  test('recovers after query sending failure during identity change', async () => {
+    const { endpoint, admitConnection, messageSink } = await createEdge();
+    const { messenger, sendSpy } = await createClient(endpoint);
+
+    await attachReplicator(messenger);
+
+    sendSpy.mockImplementationOnce(() => {
+      throw new EdgeIdentityChangedError(); // Hard to mock the exact race condition for when this error is thrown
+    });
+    admitConnection.wake();
+
+    await expect.poll(() => sendSpy.mock.calls.length).toEqual(1);
+    expect(messageSink.length).toEqual(0);
+    updateIdentity(messenger);
+
+    await expect.poll(() => messageSink.length).toEqual(1);
+    expect(messageSink[0].type).toEqual('get-metadata');
+  });
+
+  test('recovers after response sending failure during identity change', async () => {
+    const { endpoint, admitConnection, messageSink, sendResponseMessage } = await createEdge();
+    const { messenger, sendSpy } = await createClient(endpoint);
+
+    const { feed } = await attachReplicator(messenger);
+    await appendMessage(feed);
+
+    sendSpy.mockImplementationOnce(async (request: any) => {
+      sendResponseMessage(request, encodeCbor({ type: 'metadata', feedKey: feed.key.toHex(), length: 0 }));
+      return Promise.resolve();
+    });
+    sendSpy.mockImplementationOnce(async () => {
+      throw new EdgeIdentityChangedError();
+    });
+    admitConnection.wake();
+
+    await expect.poll(() => sendSpy.mock.calls.length).toEqual(2);
+    expect(messageSink.length).toEqual(0);
+    updateIdentity(messenger);
+
+    await expect.poll(() => messageSink.length).toEqual(2);
+    expect(messageSink[1].type).toEqual('data');
+  });
+
+  test('propagates errors unrelated to reconnect', async () => {
+    const { endpoint, admitConnection } = await createEdge();
+    const { messenger, sendSpy } = await createClient(endpoint);
+
+    const { replicator } = await attachReplicator(messenger, { skipOpen: true });
+    const raised = new Trigger();
+    await replicator.open(new Context({ onError: () => raised.wake() }));
+    onTestFinished(async () => {
+      await replicator.close();
+    });
+
+    sendSpy.mockImplementationOnce(() => {
+      throw new Error();
+    });
+    admitConnection.wake();
+
+    await raised.wait();
+  });
+
+  test('identity update before connected', async () => {
+    const { endpoint, admitConnection, messageSink } = await createEdge();
+    const { messenger } = await createClient(endpoint);
+
+    await attachReplicator(messenger);
+    updateIdentity(messenger);
+    await sleep(100);
+    admitConnection.wake();
+
+    await expect.poll(() => messageSink.length).toEqual(2);
+    expect(messageSink.map((m) => m.type)).toStrictEqual(range(2, () => 'get-metadata'));
+  });
+
+  test('block appended during reconnect', async () => {
+    const { endpoint, admitConnection, feedLength } = await createEdge();
+    const { messenger } = await createClient(endpoint);
+
+    const { feed } = await attachReplicator(messenger);
+    admitConnection.wake();
+    await sleep(10);
+
+    admitConnection.reset();
+    updateIdentity(messenger);
+    await appendMessage(feed);
+    await sleep(20);
+    admitConnection.wake();
+
+    await expect.poll(() => feedLength()).toEqual(1);
+  });
+
+  test('reconnect during block append', async () => {
+    const { endpoint, admitConnection, feedLength } = await createEdge();
+    const { messenger } = await createClient(endpoint);
+
+    const { feed } = await attachReplicator(messenger);
+    admitConnection.wake();
+    await sleep(10);
+
+    void appendMessage(feed);
+    updateIdentity(messenger);
+
+    await expect.poll(() => feedLength()).toEqual(1);
+  });
+
+  const createEdge = async () => {
+    const port = await getRandomPort('127.0.0.1');
+    let lastBlockIndex = -1;
+    const admitConnection = new Trigger();
+    const { cleanup, endpoint, messageSink, sendResponseMessage } = await createTestEdgeWsServer(port, {
+      admitConnection,
+      payloadDecoder: decodeCbor,
+      messageHandler: async (message: any) => {
+        if (message.type === 'get-metadata') {
+          return encodeCbor({ type: 'metadata', feedKey: message.feedKey, length: lastBlockIndex + 1 });
+        } else {
+          lastBlockIndex = Math.max(lastBlockIndex, message.blocks[message.blocks.length - 1].index);
+        }
+      },
+    });
+    onTestFinished(cleanup);
+
+    return {
+      endpoint,
+      messageSink,
+      admitConnection,
+      sendResponseMessage,
+      feedLength: () => lastBlockIndex + 1,
+    };
+  };
+
+  const createClient = async (endpoint: string) => {
+    const peerKey = PublicKey.random().toHex();
+    const messenger = new EdgeClient(peerKey, peerKey, { socketEndpoint: endpoint });
+    const sendSpy = vi.spyOn(messenger, 'send');
+    await openAndClose(messenger);
+    return { messenger, sendSpy };
+  };
+
+  const attachReplicator = async (messenger: EdgeClient, options?: { skipOpen?: boolean }) => {
+    const spaceId = SpaceId.random();
+    const feed = await createNewFeed();
+    const replicator = new EdgeFeedReplicator({ messenger, spaceId });
+    await replicator.addFeed(feed);
+    if (!options?.skipOpen) {
+      await openAndClose(replicator);
+    }
+    return { feed, replicator };
+  };
+
+  const createNewFeed = async () => {
+    const storage = createStorage();
+    const keyring = new Keyring();
+    const feedStore = new FeedStore<FeedMessage>({
+      factory: new FeedFactory<FeedMessage>({
+        root: storage.createDirectory(),
+        signer: keyring,
+        hypercore: { valueEncoding },
+      }),
+    });
+    onTestFinished(() => feedStore.close());
+    return feedStore.openFeed(await keyring.createKey(), { writable: true });
+  };
+
+  const updateIdentity = (messenger: EdgeClient) => {
+    const identityKey = PublicKey.random().toHex();
+    messenger.setIdentity({ peerKey: messenger.peerKey, identityKey });
+  };
+
+  const appendMessage = (feed: FeedWrapper<FeedMessage>) => feed.append({ timeframe: new Timeframe() });
+});