@dxos/client-services 0.1.56-main.d9d1c3e → 0.1.56-main.da2eab1

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

@@ -13,9 +13,11 @@ import { writeMessages } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
+import { SpaceSnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
 import { Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { StorageType } from '@dxos/random-access-storage';
 import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { Timeframe } from '@dxos/timeframe';
 import { range } from '@dxos/util';
 
 import { TestBuilder, syncItemsLocal } from '../testing';
@@ -156,33 +158,34 @@ describe('DataSpaceManager', () => {
   });
 
   describe('Epochs', () => {
-    test('Epoch truncates feeds', async () => {
-      const builder = new TestBuilder();
-      afterTest(async () => builder.destroy());
+    test
+      .skip('Epoch truncates feeds', async () => {
+        const builder = new TestBuilder();
+        afterTest(async () => builder.destroy());
 
-      const peer = builder.createPeer({
-        storageType: typeof window === 'undefined' ? StorageType.NODE : StorageType.WEBFS,
-      });
-      await peer.createIdentity();
-      await openAndClose(peer.dataSpaceManager);
-      const space = await peer.dataSpaceManager.createSpace();
-      await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+        const peer = builder.createPeer({
+          storageType: typeof window === 'undefined' ? StorageType.NODE : StorageType.WEBFS,
+        });
+        await peer.createIdentity();
+        await openAndClose(peer.dataSpaceManager);
+        const space = await peer.dataSpaceManager.createSpace();
+        await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
 
-      const feedDataPath = path.join(space.inner.dataPipeline.pipelineState!.feeds[0].key.toHex(), 'data');
-      const directory = peer.storage.createDirectory('feeds');
-      const file = directory.getOrCreateFile(feedDataPath);
-      afterTest(() => file.close());
+        const feedDataPath = path.join(space.inner.dataPipeline.pipelineState!.feeds[0].key.toHex(), 'data');
+        const directory = peer.storage.createDirectory('feeds');
+        const file = directory.getOrCreateFile(feedDataPath);
+        afterTest(() => file.close());
 
-      expect((await file.stat()).size === 0).to.be.true;
+        expect((await file.stat()).size === 0).to.be.true;
 
-      for (const _ in range(10)) {
-        await testLocalDatabase(space.dataPipeline);
-      }
+        for (const _ in range(10)) {
+          await testLocalDatabase(space.dataPipeline);
+        }
 
-      expect((await file.stat()).size !== 0).to.be.true;
-      await space.createEpoch();
-      expect((await file.stat()).size === 0).to.be.true;
-    })
+        expect((await file.stat()).size !== 0).to.be.true;
+        await space.createEpoch();
+        expect((await file.stat()).size === 0).to.be.true;
+      })
       .onlyEnvironments('nodejs', 'chromium', 'firefox')
       .tag('flaky');
 
@@ -228,6 +231,61 @@ describe('DataSpaceManager', () => {
         expect(epochs).to.deep.equal([epochsNumber]);
       }
     });
+
+    test('Items are cleared before epoch applied', async () => {
+      const builder = new TestBuilder();
+      afterTest(async () => builder.destroy());
+      const peer = builder.createPeer();
+      await peer.createIdentity();
+      await openAndClose(peer.dataSpaceManager);
+
+      // Create space and fill it with Items.
+      const space = await peer.dataSpaceManager.createSpace();
+      await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+      const itemsNumber = 2;
+      for (const _ of range(itemsNumber)) {
+        await testLocalDatabase(space.dataPipeline);
+      }
+
+      // Create empty Epoch and check if it clears items.
+      {
+        const processedFirstEpoch = space.dataPipeline.onNewEpoch.waitFor(
+          (epoch) => epoch.subject.assertion.number === 1,
+        );
+
+        // Empty snapshot.
+        const snapshot: SpaceSnapshot = {
+          spaceKey: space.key.asUint8Array(),
+          timeframe: space.inner.dataPipeline.pipelineState!.timeframe,
+          database: {},
+        };
+
+        const snapshotCid = await peer.snapshotStore.saveSnapshot(snapshot);
+
+        const epoch: Epoch = {
+          previousId: space.dataPipeline.currentEpoch?.id,
+          timeframe: space.inner.dataPipeline.pipelineState!.timeframe,
+          number: (space.dataPipeline.currentEpoch?.subject.assertion as Epoch).number + 1,
+          snapshotCid,
+        };
+
+        const receipt = await space.inner.controlPipeline.writer.write({
+          credential: {
+            credential: await peer.props.signingContext!.credentialSigner.createCredential({
+              subject: space.key,
+              assertion: {
+                '@type': 'dxos.halo.credentials.Epoch',
+                ...epoch,
+              },
+            }),
+          },
+        });
+        await space.inner.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
+        await processedFirstEpoch;
+      }
+
+      expect(Array.from(space.dataPipeline.itemManager.entities.keys()).length).to.equal(0);
+    });
   });
 
   describe('activation', () => {

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

@@ -193,7 +193,11 @@ export class DataSpaceManager {
     const controlFeed =
       metadata.controlFeedKey && (await this._feedStore.openFeed(metadata.controlFeedKey, { writable: true }));
     const dataFeed =
-      metadata.dataFeedKey && (await this._feedStore.openFeed(metadata.dataFeedKey, { writable: true, sparse: true }));
+      metadata.dataFeedKey &&
+      (await this._feedStore.openFeed(metadata.dataFeedKey, {
+        writable: true,
+        sparse: true,
+      }));
 
     const space: Space = await this._spaceManager.constructSpace({
       metadata,

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

@@ -55,6 +55,12 @@ export type DataSpaceParams = {
   cache?: SpaceCache;
 };
 
+/**
+ * Delete feed blocks after an epoch is created.
+ */
+// TODO(dmaretskyi): Disabled till better times https://github.com/dxos/dxos/issues/3949.
+const ENABLE_FEED_PURGE = false;
+
 @trackLeaks('open', 'close')
 export class DataSpace {
   private _ctx = new Context();
@@ -323,10 +329,16 @@ export class DataSpace {
     });
 
     await this.inner.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
-    for (const feed of this.inner.dataPipeline.pipelineState?.feeds ?? []) {
-      const indexBeforeEpoch = epoch.timeframe.get(feed.key);
-      if (indexBeforeEpoch) {
-        await feed.clear(0, indexBeforeEpoch + 1);
+
+    // Clear feed blocks before epoch.
+    if (ENABLE_FEED_PURGE) {
+      for (const feed of this.inner.dataPipeline.pipelineState?.feeds ?? []) {
+        const indexBeforeEpoch = epoch.timeframe.get(feed.key);
+        if (indexBeforeEpoch === undefined) {
+          continue;
+        }
+
+        await feed.safeClear(0, indexBeforeEpoch + 1);
       }
     }
   }

package/src/packlets/vault/worker-runtime.ts

@@ -63,7 +63,7 @@ export class WorkerRuntime {
       log('started');
     } catch (err: any) {
       this._ready.wake(err);
-      log.catch(err);
+      log.catch('starting', err);
     }
   }
 

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.1.56-main.d9d1c3e";
+export const DXOS_VERSION = "0.1.56-main.da2eab1";