@dxos/echo-db 2.33.1-dev.3a7c6ac9 → 2.33.1-dev.83d113fe

package/src/echo.test.ts

@@ -7,7 +7,7 @@ import debug from 'debug';
 import expect from 'expect';
 import { it as test } from 'mocha';
 
-import { latch, waitForCondition } from '@dxos/async';
+import { latch, promiseTimeout, waitForCondition } from '@dxos/async';
 import { defaultSecretProvider, defaultSecretValidator } from '@dxos/credentials';
 import { generateSeedPhrase, keyPairFromSeedPhrase, createKeyPair } from '@dxos/crypto';
 import { ObjectModel } from '@dxos/object-model';
@@ -329,6 +329,105 @@ describe('ECHO', () => {
     expect(a.queryParties().value[1].key).toEqual(b.queryParties().value[1].key);
   }).timeout(10_000);
 
+  test('Mutations from another device', async () => {
+    const a = await setup({ createProfile: true });
+    const b = await setup();
+
+    await a.createParty();
+
+    const invitation = await a.halo.createInvitation(defaultInvitationAuthenticator);
+    await b.halo.join(invitation, defaultSecretProvider);
+
+    // Check the initial party is opened.
+    await waitForCondition(() => b.queryParties().value.length === 1, 1000);
+
+    const partyA = a.queryParties().value[0];
+    await partyA.open();
+    const partyB = b.queryParties().value[0];
+    await partyB.open();
+
+    {
+      // Subscribe to Item updates on B.
+      const selection = partyA.database.select({ type: 'example:item/test' }).exec();
+      const updated = selection.update.waitFor(result => result.entities.length > 0);
+
+      // Create a new Item on A.
+      const itemB = await partyB.database
+        .createItem({ model: ObjectModel, type: 'example:item/test' }) as Item<any>;
+      log(`A created ${itemB.id}`);
+
+      // Now wait to see it on B.
+      await updated;
+      log(`B has ${itemB.id}`);
+
+      expect(selection.entities[0].id).toEqual(itemB.id);
+    }
+
+    await a.close();
+    await b.close();
+
+    await a.open();
+
+    {
+      const partyA = a.queryParties().first;
+
+      expect(partyA.database.select({ type: 'example:item/test' }).exec().entities.length > 0).toEqual(true);
+    }
+
+  }).timeout(10_000);
+
+  test.skip('3 devices', async () => {
+    const a = await setup({ createProfile: true });
+    const b = await setup();
+
+    await a.createParty();
+
+    await b.halo.join(await a.halo.createInvitation(defaultInvitationAuthenticator), defaultSecretProvider);
+
+    // Check the initial party is opened.
+    await waitForCondition(() => b.queryParties().value.length === 1, 1000);
+
+    const partyA = a.queryParties().value[0];
+    await partyA.open();
+    const partyB = b.queryParties().value[0];
+    await partyB.open();
+
+    {
+      // Subscribe to Item updates on B.
+      const selection = partyA.database.select({ type: 'example:item/test' }).exec();
+      const updated = selection.update.waitFor(result => result.entities.length > 0);
+
+      // Create a new Item on A.
+      const itemB = await partyB.database
+        .createItem({ model: ObjectModel, type: 'example:item/test' }) as Item<any>;
+      log(`A created ${itemB.id}`);
+
+      // Now wait to see it on B.
+      await updated;
+      log(`B has ${itemB.id}`);
+
+      expect(selection.entities[0].id).toEqual(itemB.id);
+    }
+
+    await a.close();
+    await b.close();
+
+    await a.open();
+
+    {
+      const partyA = a.queryParties().first;
+
+      expect(partyA.database.select({ type: 'example:item/test' }).exec().entities.length > 0).toEqual(true);
+    }
+
+    const c = await setup();
+    await c.halo.join(await a.halo.createInvitation(defaultInvitationAuthenticator), defaultSecretProvider);
+    await waitForCondition(() => c.queryParties().value.length === 1, 1000);
+    const partyC = c.queryParties().first;
+
+    await promiseTimeout(partyC.database.waitForItem({ type: 'example:item/test' }), 1000, new Error('timeout'));
+  }).timeout(10_000);
+
   test('Two users, two devices each', async () => {
     const a1 = await setup({ createProfile: true });
     const a2 = await setup();

package/src/parties/party-core.ts

@@ -122,6 +122,7 @@ export class PartyCore {
     // Pipeline
     //
 
+    await this._feedProvider.openKnownFeeds();
     const iterator = await this._feedProvider.createIterator(
       createMessageSelector(this._partyProcessor, this._timeframeClock),
       this._initialTimeframe

package/src/parties/party-internal.ts

@@ -78,7 +78,7 @@ export class PartyInternal {
       key: this.key.toHex(),
       isOpen: this.isOpen,
       isActive: this.isActive,
-      feedKeys: this._feedProvider.getFeedKeys().length,
+      feedKeys: this._feedProvider.getFeeds().length,
       timeframe: this.isOpen ? this._partyCore.timeframe : undefined,
       properties: this.isOpen ? this.getPropertiesSet().expectOne().model.toObject() : undefined
     };

package/src/pipeline/party-feed-provider.ts

@@ -5,10 +5,12 @@
 import assert from 'assert';
 import debug from 'debug';
 
+import { Event } from '@dxos/async';
 import { Keyring, KeyType } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { FeedStoreIterator, MessageSelector, Timeframe } from '@dxos/echo-protocol';
 import { FeedDescriptor, FeedStore } from '@dxos/feed-store';
+import { ComplexMap } from '@dxos/util';
 
 import { MetadataStore } from '../metadata';
 
@@ -16,6 +18,9 @@ const STALL_TIMEOUT = 1000;
 const warn = debug('dxos:echo-db:party-feed-provider:warn');
 
 export class PartyFeedProvider {
+  private readonly _feeds = new ComplexMap<PublicKey, FeedDescriptor>(x => x.toHex())
+  readonly feedOpened = new Event<FeedDescriptor>();
+
   constructor (
     private readonly _metadataStore: MetadataStore,
     private readonly _keyring: Keyring,
@@ -23,14 +28,13 @@ export class PartyFeedProvider {
     private readonly _partyKey: PublicKey
   ) {}
 
-  // TODO(dmaretskyi): Consider refactoring this to have write feed stored separeately in metadata.
+  getFeeds (): FeedDescriptor[] {
+    return Array.from(this._feeds.values());
+  }
+
   async createOrOpenWritableFeed () {
     const partyMetadata = this._metadataStore.getParty(this._partyKey);
-    if (!partyMetadata) {
-      return this._createReadWriteFeed();
-    }
-
-    if (!partyMetadata.dataFeedKey) {
+    if (!partyMetadata?.dataFeedKey) {
       return this._createReadWriteFeed();
     }
 
@@ -39,22 +43,42 @@ export class PartyFeedProvider {
       return this._createReadWriteFeed();
     }
 
+    if (this._feeds.has(fullKey.publicKey)) {
+      return this._feeds.get(fullKey.publicKey)!;
+    }
+
     const feed = await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey);
-    const feedKey = this._keyring.getKey(feed.key);
-    assert(feedKey, 'Feed key not found');
+    this._feeds.set(fullKey.publicKey, feed);
+    this.feedOpened.emit(feed);
     return feed;
   }
 
-  getFeedKeys () {
-    return this._metadataStore.getParty(this._partyKey)?.feedKeys ?? [];
+  async openKnownFeeds () {
+    for (const feedKey of this._metadataStore.getParty(this._partyKey)?.feedKeys ?? []) {
+      if (!this._feeds.has(feedKey)) {
+        const fullKey = this._keyring.getFullKey(feedKey);
+        const feed = fullKey?.secretKey
+          ? await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey)
+          : await this._feedStore.openReadOnlyFeed(feedKey);
+        this._feeds.set(feedKey, feed);
+        this.feedOpened.emit(feed);
+      }
+    }
   }
 
   async createOrOpenReadOnlyFeed (feedKey: PublicKey): Promise<FeedDescriptor> {
+    if (this._feeds.has(feedKey)) {
+      return this._feeds.get(feedKey)!;
+    }
+
     await this._metadataStore.addPartyFeed(this._partyKey, feedKey);
     if (!this._keyring.hasKey(feedKey)) {
       await this._keyring.addPublicKey({ type: KeyType.FEED, publicKey: feedKey });
     }
-    return this._feedStore.openReadOnlyFeed(feedKey);
+    const feed = await this._feedStore.openReadOnlyFeed(feedKey);
+    this._feeds.set(feedKey, feed);
+    this.feedOpened.emit(feed);
+    return feed;
   }
 
   private async _createReadWriteFeed () {
@@ -63,16 +87,18 @@ export class PartyFeedProvider {
     assert(fullKey && fullKey.secretKey);
     await this._metadataStore.setDataFeed(this._partyKey, fullKey.publicKey);
     const feed = await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey);
+    this._feeds.set(fullKey.publicKey, feed);
+    this.feedOpened.emit(feed);
     return feed;
   }
 
   async createIterator (messageSelector: MessageSelector, initialTimeframe?: Timeframe) {
     const iterator = new FeedStoreIterator(() => true, messageSelector, initialTimeframe ?? new Timeframe());
-    for (const feedKey of this.getFeedKeys()) {
-      iterator.addFeedDescriptor(await this.createOrOpenReadOnlyFeed(feedKey));
+    for (const feed of this._feeds.values()) {
+      iterator.addFeedDescriptor(feed);
     }
 
-    this._feedStore.feedOpenedEvent.on((descriptor) => {
+    this.feedOpened.on((descriptor) => {
       if (this._metadataStore.getParty(this._partyKey)?.feedKeys?.find(feedKey => feedKey.equals(descriptor.key))) {
         iterator.addFeedDescriptor(descriptor);
       }