@dxos/echo-db 2.33.5-dev.ea3876ba → 2.33.5-dev.fee8f5fe

package/src/parties/data-party.test.ts

@@ -5,7 +5,7 @@
 import expect from 'expect';
 import { it as test } from 'mocha';
 
-import { createKeyAdmitMessage, createPartyGenesisMessage, defaultSecretProvider, KeyHint, Keyring, KeyType, codec as haloCodec } from '@dxos/credentials';
+import { createKeyAdmitMessage, createPartyGenesisMessage, defaultSecretProvider, Keyring, KeyType, codec as haloCodec } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { codec } from '@dxos/echo-protocol';
 import { FeedStore } from '@dxos/feed-store';
@@ -22,24 +22,29 @@ import { SnapshotStore } from '../snapshots';
 import { DataParty } from './data-party';
 
 describe('DataParty', () => {
-  const createParty = async (identity: IdentityCredentials, partyKey: PublicKey, hints: KeyHint[]) => {
-    const metadataStore = new MetadataStore(createStorage('metadata', StorageType.RAM));
-    const feedStore = new FeedStore(createStorage('feed', StorageType.RAM), { valueEncoding: codec });
-    const snapshotStore = new SnapshotStore(createStorage('snapshots', StorageType.RAM));
+  const createParty = async (identity: IdentityCredentials, partyKey: PublicKey, feedHints: PublicKey[]) => {
+
+    const storage = createStorage('', StorageType.RAM);
+    const snapshotStore = new SnapshotStore(storage.directory('snapshots'));
+    const metadataStore = new MetadataStore(storage.directory('metadata'));
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     const modelFactory = new ModelFactory().registerModel(ObjectModel);
     const networkManager = new NetworkManager();
     const partyFeedProvider = new PartyFeedProvider(metadataStore, identity.keyring, feedStore, partyKey);
+    const writableFeed = await partyFeedProvider.createOrOpenWritableFeed();
 
-    return new DataParty(
+    const party = new DataParty(
       partyKey,
       modelFactory,
       snapshotStore,
       partyFeedProvider,
+      metadataStore,
       identity.createCredentialsSigner(),
       identity.preferences,
-      networkManager,
-      hints
+      networkManager
     );
+    party._setFeedHints([...feedHints, writableFeed.key]);
+    return party;
   };
 
   test('open & close', async () => {
@@ -59,8 +64,8 @@ describe('DataParty', () => {
     const party = await createParty(identity, partyKey.publicKey, []);
     await party.open();
 
-    const feed = await party.feedProvider.createOrOpenWritableFeed();
-    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+    const feed = await party.getWriteFeed();
+    await party.credentialsWriter.write(createPartyGenesisMessage(
       keyring,
       partyKey,
       feed.key,
@@ -72,6 +77,33 @@ describe('DataParty', () => {
     await party.close();
   });
 
+  test('data is immediately available after re-opening', async () => {
+    const keyring = new Keyring();
+    const identity = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+    const party = await createParty(identity, partyKey.publicKey, []);
+    await party.open();
+
+    const feed = await party.getWriteFeed();
+    await party.credentialsWriter.write(createPartyGenesisMessage(
+      keyring,
+      partyKey,
+      feed.key,
+      partyKey
+    ));
+
+    for (let i = 0; i < 10; i++) {
+      await party.database.createItem({ type: 'test:item' });
+    }
+
+    await party.close();
+    await party.open();
+
+    expect(party.database.select({ type: 'test:item' }).exec().entities).toHaveLength(10);
+
+    await party.close();
+  });
+
   test('authenticates its own credentials', async () => {
     const keyring = new Keyring();
     const identity = await createTestIdentityCredentials(keyring);
@@ -79,15 +111,16 @@ describe('DataParty', () => {
 
     const party = await createParty(identity, partyKey.publicKey, []);
     await party.open();
-    const feed = await party.feedProvider.createOrOpenWritableFeed();
-    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+    const feed = await party.getWriteFeed();
+    await party.credentialsWriter.write(createPartyGenesisMessage(
       keyring,
       partyKey,
       feed.key,
       partyKey
     ));
+    await party.processor.feedAdded.waitForCount(1);
 
-    const authenticator = createAuthenticator(party.processor, identity.createCredentialsSigner());
+    const authenticator = createAuthenticator(party.processor, identity.createCredentialsSigner(), party.credentialsWriter);
     const credentialsProvider = createCredentialsProvider(identity.createCredentialsSigner(), party.key, feed.key);
 
     const wrappedCredentials = haloCodec.decode(credentialsProvider.get());
@@ -103,14 +136,16 @@ describe('DataParty', () => {
 
     const party = await createParty(identityA, partyKey.publicKey, []);
     await party.open();
-    const feed = await party.feedProvider.createOrOpenWritableFeed();
-    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+    const feed = await party.getWriteFeed();
+    await party.credentialsWriter.write(createPartyGenesisMessage(
       keyring,
       partyKey,
       feed.key,
       partyKey
     ));
-    const authenticator = createAuthenticator(party.processor, identityA.createCredentialsSigner());
+    await party.processor.feedAdded.waitForCount(1);
+
+    const authenticator = createAuthenticator(party.processor, identityA.createCredentialsSigner(), party.credentialsWriter);
 
     const identityB = await deriveTestDeviceCredentials(identityA);
     const credentialsProvider = createCredentialsProvider(identityB.createCredentialsSigner(), party.key, feed.key);
@@ -128,14 +163,14 @@ describe('DataParty', () => {
 
     const partyA = await createParty(identityA, partyKey.publicKey, []);
     await partyA.open();
-    const feedA = await partyA.feedProvider.createOrOpenWritableFeed();
-    await partyA.processor.writeHaloMessage(createPartyGenesisMessage(
+    const feedA = await partyA.getWriteFeed();
+    await partyA.credentialsWriter.write(createPartyGenesisMessage(
       keyring,
       partyKey,
       feedA.key,
       partyKey
     ));
-    await partyA.processor.writeHaloMessage(createKeyAdmitMessage(
+    await partyA.credentialsWriter.write(createKeyAdmitMessage(
       keyring,
       partyKey.publicKey,
       identityA.identityKey,
@@ -143,9 +178,7 @@ describe('DataParty', () => {
     ));
 
     const identityB = await deriveTestDeviceCredentials(identityA);
-    const partyB = await createParty(identityB, partyKey.publicKey, [
-      { type: KeyType.FEED, publicKey: feedA.key }
-    ]);
+    const partyB = await createParty(identityB, partyKey.publicKey, [feedA.key]);
     await partyB.open();
 
     await partyA.database.createItem({ type: 'test:item-a' });
@@ -164,14 +197,14 @@ describe('DataParty', () => {
 
     const partyA = await createParty(identityA, partyKeyA.publicKey, []);
     await partyA.open();
-    const feedA = await partyA.feedProvider.createOrOpenWritableFeed();
-    await partyA.processor.writeHaloMessage(createPartyGenesisMessage(
+    const feedA = await partyA.getWriteFeed();
+    await partyA.credentialsWriter.write(createPartyGenesisMessage(
       identityA.keyring,
       partyKeyA,
       feedA.key,
       partyKeyA
     ));
-    await partyA.processor.writeHaloMessage(createKeyAdmitMessage(
+    await partyA.credentialsWriter.write(createKeyAdmitMessage(
       identityA.keyring,
       partyKeyA.publicKey,
       identityA.identityKey,

package/src/parties/data-party.ts

@@ -5,20 +5,22 @@
 import assert from 'assert';
 
 import { synchronized, Event } from '@dxos/async';
-import { KeyHint } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { timed } from '@dxos/debug';
 import { PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
+import { FeedDescriptor } from '@dxos/feed-store';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
 
-import { Database, Item, ResultSet } from '../api';
+import { ResultSet } from '../api';
 import { ActivationOptions, PartyPreferences, Preferences } from '../halo';
 import { InvitationFactory } from '../invitations';
-import { PartyFeedProvider, PartyProtocolFactory, PartyCore, PartyOptions } from '../pipeline';
+import { Database, Item } from '../packlets/database';
+import { PartyFeedProvider, PartyProtocolFactory, PartyPipeline, PipelineOptions, MetadataStore } from '../pipeline';
 import { createAuthPlugin, createOfflineInvitationPlugin, createAuthenticator, createCredentialsProvider } from '../protocol';
 import { CredentialsSigner } from '../protocol/credentials-signer';
+import { createReplicatorPlugin } from '../protocol/replicator-plugin';
 import { SnapshotStore } from '../snapshots';
 import { CONTACT_DEBOUNCE_INTERVAL } from './party-manager';
 
@@ -40,31 +42,31 @@ export interface PartyMember {
 export class DataParty {
   public readonly update = new Event<void>();
 
-  private readonly _partyCore: PartyCore;
+  private readonly _partyCore: PartyPipeline;
   private readonly _preferences?: PartyPreferences;
   private _invitationManager?: InvitationFactory;
   private _protocol?: PartyProtocolFactory;
+  private _feedHints: PublicKey[] = []
 
   constructor (
     partyKey: PartyKey,
     modelFactory: ModelFactory,
     snapshotStore: SnapshotStore,
     private readonly _feedProvider: PartyFeedProvider,
+    private readonly _metadataStore: MetadataStore,
     private readonly _credentialsSigner: CredentialsSigner,
     // TODO(dmaretskyi): Pull this out to a higher level. Should preferences be part of client API instead?
     private readonly _profilePreferences: Preferences | undefined,
     private readonly _networkManager: NetworkManager,
-    private readonly _hints: KeyHint[] = [],
-    _initialTimeframe?: Timeframe,
-    _options: PartyOptions = {}
+    private readonly _initialTimeframe?: Timeframe,
+    _options: PipelineOptions = {}
   ) {
-    this._partyCore = new PartyCore(
+    this._partyCore = new PartyPipeline(
       partyKey,
       _feedProvider,
       modelFactory,
       snapshotStore,
       this._credentialsSigner.getIdentityKey().publicKey,
-      _initialTimeframe,
       _options
     );
 
@@ -125,14 +127,8 @@ export class DataParty {
     return this._invitationManager;
   }
 
-  // TODO(burdon): Remove?
-  get feedProvider (): PartyFeedProvider {
-    return this._feedProvider;
-  }
-
-  get preferences (): PartyPreferences {
-    assert(this._preferences, 'Preferences not available.');
-    return this._preferences;
+  get credentialsWriter () {
+    return this._partyCore.credentialsWriter;
   }
 
   get title () {
@@ -145,6 +141,13 @@ export class DataParty {
     await this._preferences?.setLastKnownTitle(title);
   }
 
+  /**
+   * @internal
+   */
+  _setFeedHints (feedHints: PublicKey[]) {
+    this._feedHints = feedHints;
+  }
+
   /**
    * Opens the pipeline and connects the streams.
    */
@@ -155,11 +158,25 @@ export class DataParty {
       return this;
     }
 
-    await this._partyCore.open(this._hints);
+    // TODO(dmaretskyi): May be undefined in some tests.
+    const party = this._metadataStore.getParty(this._partyCore.key);
+
+    await this._partyCore.open({
+      feedHints: this._feedHints,
+      initialTimeframe: this._initialTimeframe,
+      targetTimeframe: party?.latestTimeframe
+    });
+
+    // Keep updating latest reached timeframe in the metadata.
+    // This timeframe will be waited for when opening the party next time.
+    this._partyCore.timeframeUpdate.on(timeframe => {
+      void this._metadataStore.setTimeframe(this._partyCore.key, timeframe);
+    });
 
     this._invitationManager = new InvitationFactory(
       this._partyCore.processor,
       this._credentialsSigner,
+      this._partyCore.credentialsWriter,
       this._networkManager
     );
 
@@ -173,13 +190,13 @@ export class DataParty {
     this._protocol = new PartyProtocolFactory(
       this._partyCore.key,
       this._networkManager,
-      this._feedProvider,
       deviceKey.publicKey,
       createCredentialsProvider(this._credentialsSigner, this._partyCore.key, writeFeed.key)
     );
 
     await this._protocol.start([
-      createAuthPlugin(createAuthenticator(this._partyCore.processor, this._credentialsSigner), deviceKey.publicKey),
+      createReplicatorPlugin(this._feedProvider),
+      createAuthPlugin(createAuthenticator(this._partyCore.processor, this._credentialsSigner, this.credentialsWriter), deviceKey.publicKey),
       createOfflineInvitationPlugin(this._invitationManager, deviceKey.publicKey)
     ]);
 
@@ -199,6 +216,9 @@ export class DataParty {
       return this;
     }
 
+    // Save the latest reached timeframe.
+    await this._metadataStore.setTimeframe(this._partyCore.key, this._partyCore.timeframe);
+
     await this._partyCore.close();
     await this._protocol?.stop();
 
@@ -210,6 +230,14 @@ export class DataParty {
     return this;
   }
 
+  async getWriteFeed (): Promise<FeedDescriptor> {
+    return this._feedProvider.createOrOpenWritableFeed();
+  }
+
+  getFeeds (): FeedDescriptor[] {
+    return this._feedProvider.getFeeds();
+  }
+
   get isActive (): boolean {
     assert(this._preferences, 'PartyActivator required');
     return this._preferences.isActive;

package/src/parties/party-factory.ts

@@ -9,7 +9,6 @@ import {
   createEnvelopeMessage,
   createFeedAdmitMessage,
   createPartyGenesisMessage,
-  KeyHint,
   KeyType,
   SecretProvider,
   wrapMessage
@@ -21,12 +20,12 @@ import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
 
-import { IdentityNotInitializedError } from '../errors';
 import {
   createDataPartyAdmissionMessages,
   GreetingInitiator, InvitationDescriptor, InvitationDescriptorType, OfflineInvitationClaimer
 } from '../invitations';
-import { PartyFeedProvider, PartyOptions } from '../pipeline';
+import { IdentityNotInitializedError } from '../packlets/errors';
+import { MetadataStore, PartyFeedProvider, PipelineOptions } from '../pipeline';
 import { IdentityCredentialsProvider } from '../protocol/identity-credentials';
 import { SnapshotStore } from '../snapshots';
 import { DataParty, PARTY_ITEM_TYPE } from './data-party';
@@ -43,7 +42,8 @@ export class PartyFactory {
     private readonly _modelFactory: ModelFactory,
     private readonly _snapshotStore: SnapshotStore,
     private readonly _feedProviderFactory: (partyKey: PublicKey) => PartyFeedProvider,
-    private readonly _options: PartyOptions = {}
+    private readonly _metadataStore: MetadataStore,
+    private readonly _options: PipelineOptions = {}
   ) {}
 
   /**
@@ -57,13 +57,15 @@ export class PartyFactory {
     const partyKey = await identity.keyring.createKeyRecord({ type: KeyType.PARTY });
     const party = await this.constructParty(partyKey.publicKey);
 
+    const writableFeed = await party.getWriteFeed();
+    // Hint at the newly created writable feed so that we can start replicating from it.
+    party._setFeedHints([writableFeed.key]);
+
     // Connect the pipeline.
     await party.open();
 
-    const writableFeed = await party.feedProvider.createOrOpenWritableFeed();
-
     // PartyGenesis (self-signed by Party).
-    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+    await party.credentialsWriter.write(createPartyGenesisMessage(
       identity.keyring,
       partyKey,
       writableFeed.key,
@@ -71,7 +73,7 @@ export class PartyFactory {
     );
 
     // KeyAdmit (IdentityGenesis in an Envelope signed by Party).
-    await party.processor.writeHaloMessage(createEnvelopeMessage(
+    await party.credentialsWriter.write(createEnvelopeMessage(
       identity.keyring,
       partyKey.publicKey,
       wrapMessage(identity.identityGenesis),
@@ -80,7 +82,7 @@ export class PartyFactory {
 
     // FeedAdmit (signed by the Device KeyChain).
     // TODO(dmaretskyi): Is this really needed since a feed is already admitted by party genesis message.
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await party.credentialsWriter.write(createFeedAdmitMessage(
       identity.keyring,
       partyKey.publicKey,
       writableFeed.key,
@@ -89,7 +91,7 @@ export class PartyFactory {
 
     // IdentityInfo in an Envelope signed by the Device KeyChain.
     if (identity.identityInfo) {
-      await party.processor.writeHaloMessage(createEnvelopeMessage(
+      await party.credentialsWriter.write(createEnvelopeMessage(
         identity.keyring,
         partyKey.publicKey,
         wrapMessage(identity.identityInfo),
@@ -106,61 +108,14 @@ export class PartyFactory {
     return party;
   }
 
-  /**
-   * Constructs a party object and creates a local write feed for it.
-   * @param partyKey
-   * @param hints
-   */
-  async addParty (partyKey: PartyKey, hints: KeyHint[] = []) {
-    const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
-
-    /*
-     * TODO(telackey): We shouldn't have to add our key here, it should be in the hints, but our hint
-     * mechanism is broken by not waiting on the messages to be processed before returning.
-     */
-
-    const feedProvider = this._feedProviderFactory(partyKey);
-    const { feed } = await feedProvider.createOrOpenWritableFeed();
-    const feedKeyPair = identity.keyring.getKey(feed.key);
-    assert(feedKeyPair, 'Keypair for writable feed not found.');
-    const party = new DataParty(
-      partyKey,
-      this._modelFactory,
-      this._snapshotStore,
-      feedProvider,
-      identity.createCredentialsSigner(),
-      identity.preferences,
-      this._networkManager,
-      hints,
-      undefined,
-      this._options
-    );
-
-    await party.open();
-    const isHalo = identity.identityKey.publicKey.equals(partyKey);
-    const signingKey = isHalo ? identity.deviceKey : identity.deviceKeyChain;
-    assert(signingKey, 'No device key or keychain.');
-    // Write the Feed genesis message.
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
-      identity.keyring,
-      partyKey,
-      feedKeyPair.publicKey,
-      [signingKey]
-    ));
-    return party;
-  }
-
   /**
    * Constructs a party object from an existing set of feeds.
    * @param partyKey
    * @param hints
    */
-  async constructParty (partyKey: PartyKey, hints: KeyHint[] = [], initialTimeframe?: Timeframe) {
+  async constructParty (partyKey: PartyKey, initialTimeframe?: Timeframe) {
     const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
 
-    // TODO(marik-d): Support read-only parties if this feed doesn't exist?
-    const feedProvider = this._feedProviderFactory(partyKey);
-
     //
     // Create the party.
     //
@@ -168,11 +123,11 @@ export class PartyFactory {
       partyKey,
       this._modelFactory,
       this._snapshotStore,
-      feedProvider,
+      this._feedProviderFactory(partyKey),
+      this._metadataStore,
       identity.createCredentialsSigner(),
       identity.preferences,
       this._networkManager,
-      hints,
       initialTimeframe,
       this._options
     );
@@ -184,13 +139,12 @@ export class PartyFactory {
     assert(snapshot.partyKey);
     log(`Constructing ${humanize(snapshot.partyKey)} from snapshot at ${JSON.stringify(snapshot.timeframe)}.`);
 
-    const party = await this.constructParty(PublicKey.from(snapshot.partyKey), [], snapshot.timeframe);
+    const party = await this.constructParty(PublicKey.from(snapshot.partyKey), snapshot.timeframe);
     await party.restoreFromSnapshot(snapshot);
     return party;
   }
 
   async joinParty (invitationDescriptor: InvitationDescriptor, secretProvider: SecretProvider): Promise<DataParty> {
-    const haloInvitation = !!invitationDescriptor.identityKey;
     const originalInvitation = invitationDescriptor;
 
     const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
@@ -218,19 +172,19 @@ export class PartyFactory {
 
     await initiator.connect();
     const { partyKey, hints } = await initiator.redeemInvitation(secretProvider);
-    const party = await this.addParty(partyKey, hints);
+    const party = await this.constructParty(partyKey);
+    party._setFeedHints(hints);
+    await party.open();
     await initiator.destroy();
-    if (!haloInvitation) {
-      // Copy our signed IdentityInfo into the new Party.
-      const infoMessage = identity.identityInfo;
-      if (infoMessage) {
-        await party.processor.writeHaloMessage(createEnvelopeMessage(
-          identity.keyring,
-          partyKey,
-          wrapMessage(infoMessage),
-          [identity.deviceKeyChain]
-        ));
-      }
+
+    // Copy our signed IdentityInfo into the new Party.
+    if (identity.identityInfo) {
+      await party.credentialsWriter.write(createEnvelopeMessage(
+        identity.keyring,
+        partyKey,
+        wrapMessage(identity.identityInfo),
+        [identity.deviceKeyChain]
+      ));
     }
 
     return party;
@@ -244,13 +198,15 @@ export class PartyFactory {
     const partyKey = await identity.keyring.createKeyRecord({ type: KeyType.PARTY });
     const party = await this.constructParty(partyKey.publicKey);
 
+    const writableFeed = await party.getWriteFeed();
+    // Hint at the newly created writable feed so that we can start replicating from it.
+    party._setFeedHints([writableFeed.key]);
+
     // Connect the pipeline.
     await party.open();
 
-    const writableFeed = await party.feedProvider.createOrOpenWritableFeed();
-
     // PartyGenesis (self-signed by Party).
-    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+    await party.credentialsWriter.write(createPartyGenesisMessage(
       identity.keyring,
       partyKey,
       writableFeed.key,
@@ -258,7 +214,7 @@ export class PartyFactory {
     );
 
     // KeyAdmit (IdentityGenesis in an Envelope signed by Party).
-    await party.processor.writeHaloMessage(createEnvelopeMessage(
+    await party.credentialsWriter.write(createEnvelopeMessage(
       identity.keyring,
       partyKey.publicKey,
       wrapMessage(identity.identityGenesis),
@@ -266,7 +222,7 @@ export class PartyFactory {
     ));
 
     // FeedAdmit (signed by the Device KeyChain).
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await party.credentialsWriter.write(createFeedAdmitMessage(
       identity.keyring,
       partyKey.publicKey,
       writableFeed.key,
@@ -275,7 +231,7 @@ export class PartyFactory {
 
     // IdentityInfo in an Envelope signed by the Device KeyChain.
     if (identity.identityInfo) {
-      await party.processor.writeHaloMessage(createEnvelopeMessage(
+      await party.credentialsWriter.write(createEnvelopeMessage(
         identity.keyring,
         partyKey.publicKey,
         wrapMessage(identity.identityInfo),
@@ -285,7 +241,7 @@ export class PartyFactory {
 
     // const keyAdmitMessage = snapshot.halo?.messages?.[1];
     // assert(keyAdmitMessage);
-    // await party.processor.writeHaloMessage(createEnvelopeMessage(
+    // await party.writeCredentialsMessage(createEnvelopeMessage(
     //   identity.signer,
     //   partyKey.publicKey,
     //   keyAdmitMessage,
@@ -293,13 +249,14 @@ export class PartyFactory {
     // ));
 
     // for(const message of snapshot.halo?.messages?.slice(2) || []) {
-    //   await party.processor.writeHaloMessage(message);
+    //   await party.writeCredentialsMessage(message);
     // }
 
     // Write messages to create ECHO items.
     const feedWriter = createFeedWriter(writableFeed.feed);
     for (const item of snapshot.database?.items || []) {
       const message: FeedMessage = {
+        timeframe: new Timeframe(),
         echo: {
           itemId: item.itemId ?? failUndefined(),
           genesis: {
@@ -310,8 +267,7 @@ export class PartyFactory {
           itemMutation: {
             parentId: item.parentId
           },
-          snapshot: item.model,
-          timeframe: new Timeframe()
+          snapshot: item.model
         }
       };
       await feedWriter.write(message);