@dxos/echo-db 2.28.6-dev.ca9d0e33 → 2.28.7-dev.1dc18bee

package/src/database/item-demuxer.ts

@@ -7,12 +7,12 @@ import debug from 'debug';
 
 import { Event } from '@dxos/async';
 import { failUndefined } from '@dxos/debug';
-import { DatabaseSnapshot, IEchoStream, ItemID, ItemSnapshot } from '@dxos/echo-protocol';
+import { DatabaseSnapshot, IEchoStream, ItemID, ItemSnapshot, LinkSnapshot } from '@dxos/echo-protocol';
 import { createWritable } from '@dxos/feed-store';
 import { Model, ModelFactory, ModelMessage } from '@dxos/model-factory';
 import { jsonReplacer } from '@dxos/util';
 
-import { Entity, Item } from '../api';
+import { Entity, Item, Link } from '../api';
 import { ItemManager, ModelConstructionOptions } from './item-manager';
 
 const log = debug('dxos:echo-db:item-demuxer');
@@ -43,6 +43,7 @@ export class ItemDemuxer {
       }
     });
 
+    // TODO(burdon): Factor out.
     // TODO(burdon): Should this implement some "back-pressure" (hints) to the PartyProcessor?
     return createWritable<IEchoStream>(async (message: IEchoStream) => {
       log('Reading:', JSON.stringify(message, jsonReplacer));
@@ -116,26 +117,40 @@ export class ItemDemuxer {
   createSnapshot (): DatabaseSnapshot {
     assert(this._options.snapshots, 'Snapshots are disabled');
     return {
-      items: Array.from(this._itemManager.entities.values()).map(entity => this.createEntitySnapshot(entity))
+      items: this._itemManager.items.map(item => this.createItemSnapshot(item)),
+      links: this._itemManager.links.map(link => this.createLinkSnapshot(link))
     };
   }
 
-  createEntitySnapshot (entity: Entity<Model<any>>): ItemSnapshot {
-    const model = entity._stateManager.createSnapshot();
+  createItemSnapshot (item: Item<Model<any>>): ItemSnapshot {
+    const model = item._stateManager.createSnapshot();
 
     return {
-      itemId: entity.id,
-      itemType: entity.type,
-      modelType: entity.modelMeta.type,
-      parentId: (entity instanceof Item) ? entity.parent?.id : undefined,
+      itemId: item.id,
+      itemType: item.type,
+      modelType: item.modelMeta.type,
+      parentId: item.parent?.id,
+      model
+    };
+  }
+
+  createLinkSnapshot (link: Link<Model<any>>): LinkSnapshot {
+    const model = link._stateManager.createSnapshot();
+
+    return {
+      linkId: link.id,
+      linkType: link.type,
+      modelType: link.modelMeta.type,
+      source: link.source.id,
+      target: link.target.id,
       model
     };
   }
 
   async restoreFromSnapshot (snapshot: DatabaseSnapshot) {
-    const items = snapshot.items ?? [];
-    log(`Restoring ${items.length} items from snapshot.`);
+    const { items = [], links = [] } = snapshot;
 
+    log(`Restoring ${items.length} items from snapshot.`);
     for (const item of sortItemsTopologically(items)) {
       assert(item.itemId);
       assert(item.modelType);
@@ -149,9 +164,29 @@ export class ItemDemuxer {
         snapshot: item.model
       });
     }
+
+    log(`Restoring ${links.length} links from snapshot.`);
+    for (const link of links) {
+      assert(link.linkId);
+      assert(link.modelType);
+      assert(link.model);
+
+      await this._itemManager.constructLink({
+        itemId: link.linkId,
+        itemType: link.linkType,
+        modelType: link.modelType,
+        source: link.source,
+        target: link.target,
+        snapshot: link.model
+      });
+    }
   }
 }
 
+/**
+ * Sort based on parents.
+ * @param items
+ */
 export function sortItemsTopologically (items: ItemSnapshot[]): ItemSnapshot[] {
   const snapshots: ItemSnapshot[] = [];
   const seenIds = new Set<ItemID>();

package/src/database/item-manager.ts

@@ -98,7 +98,7 @@ export class ItemManager {
     parentId?: ItemID,
     initProps?: any // TODO(burdon): Remove/change to array of mutations.
   ): Promise<Item<Model<unknown>>> {
-    assert(this._writeStream);
+    assert(this._writeStream); // TODO(burdon): Throw ReadOnlyError();
     assert(modelType);
 
     if (!this._modelFactory.hasModel(modelType)) {
@@ -188,7 +188,8 @@ export class ItemManager {
     modelType, itemId, snapshot
   }: ModelConstructionOptions): Promise<StateManager<Model>> {
     // Convert model-specific outbound mutation to outbound envelope message.
-    const outboundTransform = this._writeStream && mapFeedWriter<Uint8Array, EchoEnvelope>(mutation => ({ itemId, mutation }), this._writeStream);
+    const outboundTransform = this._writeStream && mapFeedWriter<Uint8Array, EchoEnvelope>(
+      mutation => ({ itemId, mutation }), this._writeStream);
 
     // Create the model with the outbound stream.
     return this._modelFactory.createModel<Model>(modelType, itemId, snapshot, this._memberKey, outboundTransform);
@@ -197,6 +198,7 @@ export class ItemManager {
   /**
    * Adds new entity to the tracked set. Sets up events and notifies any listeners waiting for this entity to be constructed.
    */
+  // TODO(burdon): Parent not used.
   private _addEntity (entity: Entity<any>, parent?: Item<any> | null) {
     assert(!this._entities.has(entity.id));
     this._entities.set(entity.id, entity);
@@ -217,19 +219,12 @@ export class ItemManager {
 
   /**
    * Constructs an item with the appropriate model.
-   * @param itemId
-   * @param modelType
-   * @param itemType
-   * @param readStream - Inbound mutation stream (from multiplexer).
-   * @param [parentId] - ItemID of the parent of this Item (optional).
-   * @param initialMutations
-   * @param modelSnapshot
    */
   @timed(5_000)
   async constructItem ({
     itemId,
-    modelType,
     itemType,
+    modelType,
     parentId,
     snapshot
   }: ItemConstructionOptions): Promise<Item<any>> {
@@ -259,14 +254,12 @@ export class ItemManager {
 
   /**
    * Constructs an item with the appropriate model.
-   * @param readStream - Inbound mutation stream (from multiplexer).
-   * @param parentId - ItemID of the parent of this Item (optional).
    */
   @timed(5_000)
   async constructLink ({
-    itemId,
-    modelType,
+    itemId, // TODO(burdon): linkId?
     itemType,
+    modelType,
     snapshot,
     source,
     target

package/src/snapshots/snapshot-store.test.ts

@@ -29,7 +29,8 @@ describe('SnapshotStore', () => {
         items: [{
           itemId: createId(),
           itemType: 'example:test'
-        }]
+        }],
+        links: []
       }
     };
 

package/src/snapshots/snapshot.test.ts

@@ -8,7 +8,7 @@ import { it as test } from 'mocha';
 
 import { waitForCondition } from '@dxos/async';
 import { PublicKey } from '@dxos/crypto';
-import { schema, ItemID, PartyKey } from '@dxos/echo-protocol';
+import { schema, ItemID, MockFeedWriter, PartyKey } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { ObjectModel, ValueUtil } from '@dxos/object-model';
 
@@ -16,6 +16,7 @@ import { ItemDemuxer, ItemManager } from '../database';
 import { createTestInstance } from '../testing';
 
 const log = debug('dxos:snapshot:test');
+debug.enable('dxos:echo-db:*');
 
 // TODO(burdon): Remove "foo", etc from tests.
 describe('snapshot', () => {
@@ -59,15 +60,28 @@ describe('snapshot', () => {
   test('produce & serialize a snapshot', async () => {
     const echo = await createTestInstance({ initialize: true });
     const party = await echo.createParty();
-    const item = await party.database.createItem({ model: ObjectModel, props: { foo: 'foo' } });
-    await item.model.setProperty('foo', 'bar');
+    const item1 = await party.database.createItem({ model: ObjectModel, props: { title: 'Item1 - Creation' } });
+    await item1.model.setProperty('title', 'Item1 - Modified');
+    const item2 = await party.database.createItem({ model: ObjectModel, props: { title: 'Item2 - Creation' } });
+    await item2.model.setProperty('title', 'Item2 - Modified');
+
+    const link = await party.database.createLink({ source: item1, target: item2 });
 
     const snapshot = party.createSnapshot();
-    expect(snapshot.database?.items).toHaveLength(2);
-    expect(snapshot.database?.items?.find(i => i.itemId === item.id)?.model?.snapshot).toBeDefined();
+    expect(snapshot.database?.items).toHaveLength(3); // 1 party + 2 items
+    expect(snapshot.database?.links).toHaveLength(1); // 1 link
+    expect(snapshot.database?.items?.find(i => i.itemId === item1.id)?.model?.snapshot).toBeDefined();
+    expect(snapshot.database?.items?.find(i => i.itemId === item2.id)?.model?.snapshot).toBeDefined();
+    expect(snapshot.database?.links?.find(l => l.linkId === link.id)?.linkId).toBeDefined();
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+    const modelSnapshot1 = ObjectModel.meta.snapshotCodec?.decode(snapshot.database?.items?.find(i => i.itemId === item1.id)?.model?.snapshot!);
+    expect(modelSnapshot1).toEqual({ root: ValueUtil.createMessage({ title: 'Item1 - Modified' }) });
+
     // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-    const modelSnapshot = ObjectModel.meta.snapshotCodec?.decode(snapshot.database?.items?.find(i => i.itemId === item.id)?.model?.snapshot!);
-    expect(modelSnapshot).toEqual({ root: ValueUtil.createMessage({ foo: 'bar' }) });
+    const modelSnapshot2 = ObjectModel.meta.snapshotCodec?.decode(snapshot.database?.items?.find(i => i.itemId === item2.id)?.model?.snapshot!);
+    expect(modelSnapshot2).toEqual({ root: ValueUtil.createMessage({ title: 'Item2 - Modified' }) });
+
     expect(snapshot.halo?.messages && snapshot.halo?.messages?.length > 0).toBeTruthy();
     expect(snapshot.timeframe?.size()).toBe(1);
 
@@ -78,12 +92,68 @@ describe('snapshot', () => {
     expect(echo.isOpen).toBe(false);
   });
 
+  test('restore from snapshot', async () => {
+    const modelFactory = new ModelFactory().registerModel(ObjectModel);
+
+    let data;
+    {
+      const itemManager = new ItemManager(modelFactory, PublicKey.random(), new MockFeedWriter());
+      const itemDemuxer = new ItemDemuxer(itemManager, modelFactory, { snapshots: true });
+
+      await itemManager.constructItem({
+        itemId: 'item-1',
+        itemType: 'test-item-type',
+        modelType: ObjectModel.meta.type,
+        snapshot: {}
+      });
+
+      await itemManager.constructItem({
+        itemId: 'item-2',
+        itemType: 'test-item-type',
+        modelType: ObjectModel.meta.type,
+        snapshot: {}
+      });
+
+      await itemManager.constructLink({
+        itemId: 'link-1',
+        itemType: 'test-link-type',
+        modelType: ObjectModel.meta.type,
+        source: 'item-1',
+        target: 'item-2',
+        snapshot: {}
+      });
+
+      // Create snapshot.
+      console.log('encoding...');
+      const snapshot = itemDemuxer.createSnapshot();
+      data = schema.getCodecForType('dxos.echo.snapshot.DatabaseSnapshot').encode(snapshot);
+    }
+
+    {
+      const itemManager = new ItemManager(modelFactory, PublicKey.random());
+      const itemDemuxer = new ItemDemuxer(itemManager, modelFactory, { snapshots: true });
+
+      // Decode snapshot.
+      console.log('decoding...');
+      const snapshot = schema.getCodecForType('dxos.echo.snapshot.DatabaseSnapshot').decode(data);
+      await itemDemuxer.restoreFromSnapshot(snapshot);
+
+      expect(itemManager.items).toHaveLength(2);
+      expect(itemManager.links).toHaveLength(1);
+
+      const [item1, item2] = itemManager.items;
+      const [link] = itemManager.links;
+      expect(link.source.id).toBe(item1.id);
+      expect(link.target.id).toBe(item2.id);
+    }
+  });
+
   test('restore from empty snapshot', async () => {
     const modelFactory = new ModelFactory().registerModel(ObjectModel);
     const itemManager = new ItemManager(modelFactory, PublicKey.random());
     const itemDemuxer = new ItemDemuxer(itemManager, modelFactory);
 
-    // TODO(burdon): Test.
+    // TODO(burdon): Do actual test.
     await itemDemuxer.restoreFromSnapshot({});
     expect(true).toBeTruthy();
   });