@automerge/automerge-repo 2.0.0-alpha.6 → 2.0.0-beta.1

package/test/StorageSubsystem.test.ts

@@ -4,13 +4,15 @@ import assert from "assert"
 import fs from "fs"
 import os from "os"
 import path from "path"
-import { describe, it } from "vitest"
+import { describe, it, expect } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { PeerId, cbor } from "../src/index.js"
 import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
 import { StorageId } from "../src/storage/types.js"
 import { DummyStorageAdapter } from "../src/helpers/DummyStorageAdapter.js"
 import * as Uuid from "uuid"
+import { chunkTypeFromKey } from "../src/storage/chunkTypeFromKey.js"
+import { DocumentId } from "../src/types.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 
@@ -243,6 +245,83 @@ describe("StorageSubsystem", () => {
           assert.strictEqual(id1, id2)
         })
       })
+
+      describe("loadDoc", () => {
+        it("maintains correct document state when loading chunks in order", async () => {
+          const storageAdapter = new DummyStorageAdapter()
+          const storage = new StorageSubsystem(storageAdapter)
+
+          // Create a document with multiple changes
+          const doc = A.init<{ foo: string }>()
+          const doc1 = A.change(doc, d => {
+            d.foo = "first"
+          })
+          const doc2 = A.change(doc1, d => {
+            d.foo = "second"
+          })
+          const doc3 = A.change(doc2, d => {
+            d.foo = "third"
+          })
+
+          // Save the document with multiple changes
+          const documentId = "test-doc" as DocumentId
+          await storage.saveDoc(documentId, doc3)
+
+          // Load the document
+          const loadedDoc = await storage.loadDoc<{ foo: string }>(documentId)
+
+          // Verify the document state is correct
+          expect(loadedDoc?.foo).toBe("third")
+        })
+
+        it("combines chunks with snapshot first", async () => {
+          const storageAdapter = new DummyStorageAdapter()
+          const storage = new StorageSubsystem(storageAdapter)
+
+          // Create a document with multiple changes
+          const doc = A.init<{ foo: string }>()
+          const doc1 = A.change(doc, d => {
+            d.foo = "first"
+          })
+          const doc2 = A.change(doc1, d => {
+            d.foo = Array(10000)
+              .fill(0)
+              .map(() =>
+                String.fromCharCode(Math.floor(Math.random() * 26) + 97)
+              )
+              .join("")
+          })
+
+          // Save the document with multiple changes
+          const documentId = "test-doc" as DocumentId
+          await storage.saveDoc(documentId, doc2)
+
+          const doc3 = A.change(doc2, d => {
+            d.foo = "third"
+          })
+          await storage.saveDoc(documentId, doc3)
+
+          // Load the document
+          const loadedDoc = await storage.loadDoc<{ foo: string }>(documentId)
+
+          // Verify the document state is correct
+          expect(loadedDoc?.foo).toBe(doc3.foo)
+
+          // Get the raw binary data from storage
+          const binary = await storage.loadDocData(documentId)
+          expect(binary).not.toBeNull()
+          if (!binary) return
+
+          // Verify the binary starts with the Automerge magic value
+          expect(binary[0]).toBe(0x85)
+          expect(binary[1]).toBe(0x6f)
+          expect(binary[2]).toBe(0x4a)
+          expect(binary[3]).toBe(0x83)
+
+          // Verify the chunk type is CHUNK_TYPE_DOCUMENT (0x00)
+          expect(binary[8]).toBe(0x00)
+        })
+      })
     })
   }
 })

package/test/remoteHeads.test.ts

@@ -13,6 +13,7 @@ import {
 import { DummyStorageAdapter } from "../src/helpers/DummyStorageAdapter.js"
 import { collectMessages } from "./helpers/collectMessages.js"
 import { TestDoc } from "./types.js"
+import { pause } from "../src/helpers/pause.js"
 
 describe("DocHandle.remoteHeads", () => {
   const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
@@ -128,13 +129,15 @@ describe("DocHandle.remoteHeads", () => {
       const aliceDoc = alice.create<TestDoc>()
       aliceDoc.change(d => (d.foo = "bar"))
 
+      await pause(50)
+
       // bob waits for the document to arrive
-      const bobDoc = bob.find<TestDoc>(aliceDoc.url)
-      await bobDoc.whenReady()
+      const bobDoc = await bob.find<TestDoc>(aliceDoc.url)
 
       // alice's service worker waits for the document to arrive
-      const aliceServiceWorkerDoc = aliceServiceWorker.find(aliceDoc.documentId)
-      await aliceServiceWorkerDoc.whenReady()
+      const aliceServiceWorkerDoc = await aliceServiceWorker.find(
+        aliceDoc.documentId
+      )
 
       let aliceSeenByBobPromise = new Promise<DocHandleRemoteHeadsPayload>(
         resolve => {
@@ -168,17 +171,21 @@ describe("DocHandle.remoteHeads", () => {
       const bobDocB = bob.create<TestDoc>()
       bobDocB.change(d => (d.foo = "B"))
 
+      await pause(50)
+
       // alice opens doc A
-      const aliceDocA = alice.find<TestDoc>(bobDocA.url)
+      const aliceDocAPromise = alice.find<TestDoc>(bobDocA.url)
 
       const remoteHeadsChangedMessages = (
         await collectMessages({
           emitter: alice.networkSubsystem,
           event: "message",
-          until: aliceDocA.whenReady(),
+          until: aliceDocAPromise,
         })
       ).filter(({ type }) => type === "remote-heads-changed")
 
+      const aliceDocA = await aliceDocAPromise
+
       // we should only be notified of the head changes of doc A
       assert(
         remoteHeadsChangedMessages.every(
@@ -197,6 +204,8 @@ describe("DocHandle.remoteHeads", () => {
       const bobDocB = bob.create<TestDoc>()
       bobDocB.change(d => (d.foo = "B"))
 
+      await pause(50)
+
       // alice opens the docs
       const _aliceDocA = alice.find<TestDoc>(bobDocA.url)
       const _aliceDocB = alice.find<TestDoc>(bobDocB.url)
@@ -209,19 +218,21 @@ describe("DocHandle.remoteHeads", () => {
       // stored remote heads immediately.
 
       // open doc and subscribe alice's second tab to bob's service worker
-      const alice2DocA = alice2.find<TestDoc>(bobDocA.url)
+      const alice2DocAPromise = alice2.find<TestDoc>(bobDocA.url)
       alice2.subscribeToRemotes([bobServiceWorkerStorageId])
 
       const remoteHeadsChangedMessages = (
         await collectMessages({
           emitter: alice2.networkSubsystem,
           event: "message",
-          until: alice2DocA.whenReady(),
+          until: alice2DocAPromise,
         })
       ).filter(({ type }) => type === "remote-heads-changed")
 
+      const alice2DocA = await alice2DocAPromise
+
       // we should only be notified of the head changes of doc A
-      assert.strictEqual(remoteHeadsChangedMessages.length, 2)
+      assert.strictEqual(remoteHeadsChangedMessages.length, 1)
       assert(
         remoteHeadsChangedMessages.every(
           d => d.documentId === alice2DocA.documentId
@@ -242,18 +253,22 @@ describe("DocHandle.remoteHeads", () => {
       // alice subscribes to bob's service worker
       alice.subscribeToRemotes([bobServiceWorkerStorageId])
 
+      await pause(50)
+
       // alice opens doc A
-      const alice1DocA = alice.find<TestDoc>(bobDocA.url)
+      const alice1DocAPromise = alice.find<TestDoc>(bobDocA.url)
 
       const remoteHeadsChangedMessages = (
         await collectMessages({
           emitter: alice.networkSubsystem,
           event: "message",
-          until: alice1DocA.whenReady(),
+          until: alice1DocAPromise,
         })
       ).filter(({ type }) => type === "remote-heads-changed")
 
-      assert.strictEqual(remoteHeadsChangedMessages.length, 2)
+      const alice1DocA = await alice1DocAPromise
+
+      assert.strictEqual(remoteHeadsChangedMessages.length, 1)
       assert(
         remoteHeadsChangedMessages.every(
           d => d.documentId === alice1DocA.documentId