@evolu/common 8.12.0 → 8.14.0

package/src/local-first/Evolu.test.ts

@@ -61,6 +61,7 @@ import {
   type SharedWorkerInput,
   type SharedWorkerOutput,
   type SyncState,
+  syncStateToOwnerSyncStatus,
 } from "./Shared.ts";
 import {
   acquireLeaderLock,
@@ -72,6 +73,7 @@ import { err, ok } from "../Result.ts";
 import { SqliteBoolean } from "../Sqlite.ts";
 import { explicitAbortReason, testCreateDeps, testCreateRun } from "../Task.ts";
 import { testCreateId } from "../Test.ts";
+import { Millis } from "../Time.ts";
 import {
   assertType,
   createIdFromString,
@@ -370,16 +372,6 @@ describe("Evolu", () => {
       assertSame(setup.deps.evoluError.get(), null);
     });
 
-    it("says nothing to a worker that reports it keeps databases in memory", async () => {
-      using setup = await setupCreateEvoluDeps();
-
-      setup.sharedWorkerPort.postMessage({ type: "StorageUnavailable" });
-      await testWaitForWorkerMessage();
-
-      assertEqual(setup.messages, []);
-      assertSame(setup.deps.evoluError.get(), null);
-    });
-
     it("announces itself as tab leader with its console level once its worker connects", async () => {
       const testConsole = testCreateConsole();
       using setup = await setupCreateEvoluDeps(testConsole);
@@ -428,6 +420,7 @@ describe("Evolu", () => {
         tables: { todo: new Set(["title"]) },
         indexes: [],
       };
+      const sharedWorkerId = testCreateId()<"SharedWorker">();
       const sharedWorkerPort: {
         value: MessagePort<SharedWorkerOutput, SharedWorkerInput> | null;
       } = { value: null };
@@ -468,6 +461,7 @@ describe("Evolu", () => {
           sqliteSchema,
           encryptionKey: testAppOwner.encryptionKey,
           memoryOnly: true,
+          sharedWorkerId,
           port: dbWorkerChannel.port1.native,
         },
         [dbWorkerChannel.port1.native],
@@ -483,6 +477,7 @@ describe("Evolu", () => {
         sqliteSchema,
         encryptionKey: testAppOwner.encryptionKey,
         memoryOnly: true,
+        sharedWorkerId,
         port: dbWorkerChannel.port1.native,
       });
 
@@ -592,7 +587,7 @@ describe("Evolu", () => {
       );
       const createState = (label: string): SyncState => ({
         transports: [],
-        tenants: [{ name: Name.orThrow(label), refused: false, owners: [] }],
+        tenants: [{ type: "Active", name: Name.orThrow(label), owners: [] }],
       });
 
       // Nothing reaches the tab before its worker names the channel.
@@ -616,6 +611,214 @@ describe("Evolu", () => {
       assertEqual(deps.syncState.get(), createState("changed"));
     });
 
+    it("keeps the unchanged parts of each sync state snapshot", async () => {
+      using setup = await setupCreateEvoluDeps();
+      const { deps, connect } = setup;
+      const workerId = testCreateId()<"SharedWorker">();
+      using channel = testCreateBroadcastChannel<SyncState>(
+        `evolu:sync-state:${workerId}`,
+      );
+      await connect(workerId);
+      let notificationCount = 0;
+      deps.syncState.subscribe(() => {
+        notificationCount++;
+      });
+      const transportId = testCreateId()<"SyncTransport">();
+      // Every snapshot is a new structured clone. The worker wraps a caught
+      // Error inside an error in an UnknownError, whose cause can hold the
+      // bytes of a received change.
+      const createState = (
+        lastSentAt: number,
+        message = "wrong key",
+      ): SyncState => ({
+        transports: [
+          {
+            type: "WebSocket",
+            id: transportId,
+            label: "wss://relay.example",
+            connection: {
+              type: "Open",
+              openedAt: Millis.orThrow(1000),
+              error: null,
+            },
+          },
+        ],
+        tenants: [
+          {
+            type: "Active",
+            name: testName,
+            owners: [
+              {
+                type: "Writable",
+                ownerId: testAppOwner.id,
+                routes: [
+                  {
+                    type: "Settled",
+                    transportId,
+                    skippedError: {
+                      type: "DecryptWithXChaCha20Poly1305Error",
+                      error: {
+                        type: "UnknownError",
+                        error: {
+                          message,
+                          cause: { values: { photo: Uint8Array.of(1, 2, 3) } },
+                        },
+                      },
+                      at: Millis.orThrow(1500),
+                    },
+                    completeAt: null,
+                    lastSentAt: Millis.orThrow(lastSentAt),
+                    lastReceivedAt: Millis.orThrow(1500),
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+      const routeOf = (state: SyncState | null) => {
+        const tenant = state?.tenants[0];
+        assert(tenant?.type === "Active", "The tenant should be active.");
+        const owner = tenant.owners[0];
+        assert(owner?.type === "Writable", "The owner should be writable.");
+        const route = owner.routes[0];
+        assert(route?.type === "Settled", "The route should be settled.");
+        return route;
+      };
+      const statusOf = (state: SyncState | null) =>
+        syncStateToOwnerSyncStatus(state, testName, testAppOwner.id);
+
+      channel.postMessage(createState(1000));
+      await testWaitForWorkerMessage();
+      const first = deps.syncState.get();
+      assertNotNull(first);
+      assertSame(notificationCount, 1);
+
+      // An equal snapshot leaves the store unchanged.
+      channel.postMessage(createState(1000));
+      await testWaitForWorkerMessage();
+      assertSame(deps.syncState.get(), first);
+      assertSame(notificationCount, 1);
+
+      // A changed route gets a new object, and every unchanged part keeps the
+      // previous one, so the owner's status is the same object.
+      channel.postMessage(createState(2000));
+      await testWaitForWorkerMessage();
+      const second = deps.syncState.get();
+      assertNotNull(second);
+      assertNotSame(second, first);
+      assertSame(notificationCount, 2);
+      assertSame(second.transports, first.transports);
+      assertNotSame(routeOf(second), routeOf(first));
+      assertSame(routeOf(second).skippedError, routeOf(first).skippedError);
+      assertSame(statusOf(second), statusOf(first));
+
+      // An error with another message is a new error and a new status.
+      channel.postMessage(createState(2000, "tampered"));
+      await testWaitForWorkerMessage();
+      const third = deps.syncState.get();
+      assertNotSame(routeOf(third).skippedError, routeOf(second).skippedError);
+      assertNotSame(statusOf(third), statusOf(second));
+    });
+
+    it("keeps each part of a sync state snapshot when one before it goes away", async () => {
+      using setup = await setupCreateEvoluDeps();
+      const { deps, connect } = setup;
+      const createId = testCreateId();
+      const workerId = createId<"SharedWorker">();
+      using channel = testCreateBroadcastChannel<SyncState>(
+        `evolu:sync-state:${workerId}`,
+      );
+      await connect(workerId);
+      const removedTransportId = createId<"SyncTransport">();
+      const transportId = createId<"SyncTransport">();
+      const at = Millis.orThrow(1000);
+      // The full snapshot lists a transport, tenant, owner, and route before
+      // each part the other snapshot keeps. Only the kept route has an error.
+      const createState = (isFull: boolean): SyncState => ({
+        transports: [removedTransportId, transportId]
+          .slice(isFull ? 0 : 1)
+          .map((id) => ({
+            type: "WebSocket",
+            id,
+            label: `wss://${id}.example`,
+            connection: { type: "Open", openedAt: at, error: null },
+          })),
+        tenants: [
+          ...(isFull
+            ? [
+                {
+                  type: "Active" as const,
+                  name: Name.orThrow("removed"),
+                  owners: [],
+                },
+              ]
+            : []),
+          {
+            type: "Active",
+            name: testName,
+            owners: [
+              ...(isFull
+                ? [
+                    {
+                      type: "Writable" as const,
+                      ownerId: createId<"OwnerId">(),
+                      routes: [],
+                    },
+                  ]
+                : []),
+              {
+                type: "Writable",
+                ownerId: testAppOwner.id,
+                routes: [
+                  ...(isFull
+                    ? [
+                        {
+                          type: "Complete" as const,
+                          transportId: removedTransportId,
+                          completeAt: at,
+                          lastSentAt: at,
+                          lastReceivedAt: at,
+                        },
+                      ]
+                    : []),
+                  {
+                    type: "Pending",
+                    transportId,
+                    failure: {
+                      type: "ProtocolQuotaError",
+                      ownerId: testAppOwner.id,
+                      at,
+                    },
+                    skippedError: null,
+                    completeAt: null,
+                    lastSentAt: at,
+                    lastReceivedAt: at,
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+      const statusOf = (state: SyncState | null) =>
+        syncStateToOwnerSyncStatus(state, testName, testAppOwner.id);
+
+      channel.postMessage(createState(true));
+      await testWaitForWorkerMessage();
+      const full = deps.syncState.get();
+      assertNotNull(full);
+      assertSame(statusOf(full).type, "Error");
+
+      channel.postMessage(createState(false));
+      await testWaitForWorkerMessage();
+      const kept = deps.syncState.get();
+      assertNotNull(kept);
+      assertEqual(kept, createState(false));
+      assertSame(kept.transports[0], full.transports[1]);
+      assertSame(statusOf(kept), statusOf(full));
+    });
+
     it("listens on its worker's channel before asking for a snapshot", async () => {
       const name = "evolu:sync-state:worker";
       using worker = testCreateSharedWorker<
@@ -727,6 +930,29 @@ describe("Evolu", () => {
       assertEqual(deps.evoluError.get(), error);
     });
 
+    it("only logs a sync error that an older build broadcasts", async () => {
+      const testConsole = testCreateConsole();
+      using setup = await setupCreateEvoluDeps(testConsole);
+      const { deps, consoleEntryOrErrorBroadcastChannel } = setup;
+      const error = {
+        type: "ProtocolQuotaError",
+        ownerId: testAppOwner.id,
+      } as const;
+
+      consoleEntryOrErrorBroadcastChannel.postMessage({
+        type: "Error",
+        // @ts-expect-error A ConsoleEntryOrError Error carries only an UnknownError, but a still-running worker of an older build posts a ProtocolQuotaError.
+        error,
+      });
+
+      await testWaitForWorkerMessage();
+
+      assertSame(deps.evoluError.get(), null);
+      assertEqual(testConsole.getEntriesSnapshot(), [
+        { method: "error", path: [], args: [error] },
+      ]);
+    });
+
     for (const source of ["SharedWorker", "Error", "ConsoleEntry"] as const) {
       it(`preserves the first startup refusal while logging a later ${source} message`, async () => {
         const testConsole = testCreateConsole();
@@ -1266,6 +1492,106 @@ describe("Evolu", () => {
     });
   });
 
+  describe("device persistence", () => {
+    const setupPersistenceRequests = async () => {
+      let requestCount = 0;
+      const setup = await setupRunWithEvoluDeps({
+        requestPersistentStorage: () => {
+          requestCount += 1;
+        },
+      });
+      return Object.assign(setup, { getRequestCount: () => requestCount });
+    };
+
+    it("resolves devicePersistence to what its tenant sends", async () => {
+      await using setup = await setupRunWithEvoluDeps();
+      const evolu = await setup.run.ok(testCreateEvolu);
+
+      setup.postEvoluOutput({
+        type: "OnDevicePersistence",
+        devicePersistence: "NotPersisted",
+      });
+
+      assertSame(await evolu.devicePersistence, "NotPersisted");
+    });
+
+    it("resolves devicePersistence to Unknown when disposed before its tenant sends it", async () => {
+      await using setup = await setupRunWithEvoluDeps();
+      const evolu = await setup.run.ok(testCreateEvolu);
+
+      await evolu[Symbol.asyncDispose]();
+
+      assertSame(await evolu.devicePersistence, "Unknown");
+    });
+
+    it("requests persistent storage once, after the first mutation, when devicePersistence is Unknown", async () => {
+      await using setup = await setupPersistenceRequests();
+      const evolu = await setup.run.ok(testCreateEvolu);
+      setup.postEvoluOutput({
+        type: "OnDevicePersistence",
+        devicePersistence: "Unknown",
+      });
+      await evolu.devicePersistence;
+      await testWaitForWorkerMessage();
+      assertSame(setup.getRequestCount(), 0);
+
+      evolu.insert("todo", { title: NonEmptyTrimmedString100.orThrow("A") });
+      evolu.insert("todo", { title: NonEmptyTrimmedString100.orThrow("B") });
+      await testWaitForWorkerMessage();
+      evolu.insert("todo", { title: NonEmptyTrimmedString100.orThrow("C") });
+      await testWaitForWorkerMessage();
+
+      assertSame(setup.getRequestCount(), 1);
+    });
+
+    it("requests persistent storage once devicePersistence resolves after the first mutation", async () => {
+      await using setup = await setupPersistenceRequests();
+      const evolu = await setup.run.ok(testCreateEvolu);
+
+      evolu.insert("todo", { title: NonEmptyTrimmedString100.orThrow("A") });
+      await testWaitForWorkerMessage();
+      assertSame(setup.getRequestCount(), 0);
+
+      setup.postEvoluOutput({
+        type: "OnDevicePersistence",
+        devicePersistence: "Unknown",
+      });
+      await evolu.devicePersistence;
+      await testWaitForWorkerMessage();
+
+      assertSame(setup.getRequestCount(), 1);
+    });
+
+    for (const devicePersistence of ["Persisted", "NotPersisted"] as const) {
+      it(`does not request persistent storage when devicePersistence is ${devicePersistence}`, async () => {
+        await using setup = await setupPersistenceRequests();
+        const evolu = await setup.run.ok(testCreateEvolu);
+        setup.postEvoluOutput({
+          type: "OnDevicePersistence",
+          devicePersistence,
+        });
+
+        evolu.insert("todo", { title: NonEmptyTrimmedString100.orThrow("A") });
+        await evolu.devicePersistence;
+        await testWaitForWorkerMessage();
+
+        assertSame(setup.getRequestCount(), 0);
+      });
+    }
+
+    it("does not request persistent storage after disposal", async () => {
+      await using setup = await setupPersistenceRequests();
+      const evolu = await setup.run.ok(testCreateEvolu);
+
+      evolu.insert("todo", { title: NonEmptyTrimmedString100.orThrow("A") });
+      await evolu[Symbol.asyncDispose]();
+      await evolu.devicePersistence;
+      await testWaitForWorkerMessage();
+
+      assertSame(setup.getRequestCount(), 0);
+    });
+  });
+
   describe("dispose evolu", () => {
     it("logs disposeEvolu once", async () => {
       const testConsole = testCreateConsole();
@@ -1634,6 +1960,50 @@ describe("Evolu", () => {
       assertEqual(called, 0);
     });
 
+    it("releases the onComplete callbacks of a failed mutation without running them", async () => {
+      await using setup = await setupRunWithEvoluDeps();
+      const { run, evoluInputs, postEvoluOutput } = setup;
+      const evolu = await run.ok(testCreateEvolu);
+
+      let called = 0;
+      evolu.insert(
+        "todo",
+        { title: NonEmptyTrimmedString100.orThrow("First failed") },
+        {
+          onComplete: () => {
+            called += 1;
+          },
+        },
+      );
+      evolu.insert(
+        "todo",
+        { title: NonEmptyTrimmedString100.orThrow("Second failed") },
+        {
+          onComplete: () => {
+            called += 10;
+          },
+        },
+      );
+
+      await testWaitForWorkerMessage();
+
+      const mutate = evoluInputs[0] as ExtractTyped<EvoluInput, "Mutate">;
+      const { onCompleteIds } = mutate;
+      assertLength(onCompleteIds, 2);
+
+      postEvoluOutput({ type: "OnMutateFailed", onCompleteIds });
+      // Patches naming released callbacks find nothing to run.
+      postEvoluOutput({
+        type: "OnPatchesByQuery",
+        patchesByQuery: new Map(),
+        onCompleteIds,
+      });
+
+      await testWaitForWorkerMessage();
+
+      assertEqual(called, 0);
+    });
+
     it("executes mutate onComplete callback when query patches are received", async () => {
       await using setup = await setupRunWithEvoluDeps();
       const { run, evoluInputs, postEvoluOutput } = setup;