@dxos/client-services 0.1.56-main.c19b7cd → 0.1.56-main.c277f68

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/spaces-service.ts

@@ -78,7 +78,7 @@ export class SpacesServiceImpl implements SpacesService {
           log('update', { spaces });
           next({ spaces });
         },
-        { maxFrequency: 2 },
+        { maxFrequency: process.env.NODE_ENV === 'test' ? undefined : 2 },
       );
 
       scheduleTask(ctx, async () => {

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.c19b7cd";
+export const DXOS_VERSION = "0.1.56-main.c277f68";