@evolu/common 8.15.1 → 8.17.0

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

@@ -50,6 +50,7 @@ import {
 } from "./Schema.ts";
 import {
   consoleEntryOrErrorBroadcastChannelName,
+  postConsoleEntry,
   relaySyncStateToStatus,
   syncStateToOwnerSyncStatus,
   syncStateToRelaySyncStates,
@@ -78,7 +79,7 @@ import {
   type SyncTenantOwner,
   type SyncTransport,
 } from "./Shared.ts";
-import type { NativeMessagePort } from "../Worker.ts";
+import type { BroadcastChannel, NativeMessagePort } from "../Worker.ts";
 import {
   DbChange,
   testCreateCrdtMessage,
@@ -241,8 +242,10 @@ const setupSharedWorker = async ({
     autoDispose = true,
     initialClock = createTimestamp(),
     memoryOnly = false,
+    consoleLevel = "debug",
   }: {
     tenantName?: Name;
+    consoleLevel?: ConsoleLevel;
     memoryOnly?: boolean;
     evoluChannel?: TestMessageChannel<EvoluOutput, EvoluInput>;
     releaseDbWorkerLeaderOnDispose?: boolean;
@@ -270,7 +273,6 @@ const setupSharedWorker = async ({
       dbWorkerPort.postMessage({
         clock: initialClock,
         type: "LeaderAcquired",
-        name: tenantName,
       });
       await testWaitForWorkerMessage();
     };
@@ -289,7 +291,7 @@ const setupSharedWorker = async ({
       type: "CreateEvolu",
       name: tenantName,
       id,
-      consoleLevel: "debug",
+      consoleLevel,
       sqliteSchema: testSqliteSchema,
       encryptionKey: testAppOwner.encryptionKey,
       memoryOnly,
@@ -588,6 +590,27 @@ describe("AnnounceTabLeader", () => {
       assertEqual(outputs, [{ type: "ConsoleEntry", entry }]);
     });
 
+    it("delivers a console entry argument that cannot be cloned as a string", async () => {
+      await using setup = await setupSharedWorker();
+      const { consoleStoreOutputEntry, announceTabLeader } = setup;
+      const { outputs } = await announceTabLeader();
+
+      consoleStoreOutputEntry.set({
+        method: "info",
+        path: ["test"],
+        args: [{ attempt: 2, retry: () => undefined }],
+      });
+
+      await testWaitForWorkerMessage();
+
+      assertEqual(outputs, [
+        {
+          type: "ConsoleEntry",
+          entry: { method: "info", path: ["test"], args: ['{"attempt":2}'] },
+        },
+      ]);
+    });
+
     it("ignores null console store updates", async () => {
       await using setup = await setupSharedWorker();
       const { consoleStoreOutputEntry, announceTabLeader } = setup;
@@ -622,6 +645,79 @@ describe("AnnounceTabLeader", () => {
       args: ["Unknown shared worker input", { type: "UnknownInput" }],
     });
   });
+
+  it("applies the tab leader's console level to the worker's console", async () => {
+    await using setup = await setupSharedWorker();
+    const { run, worker } = setup;
+
+    worker.port.postMessage({
+      type: "AnnounceTabLeader",
+      consoleLevel: "warn",
+    });
+    await testWaitForWorkerMessage();
+
+    assertEqual(run.deps.console.getLevel(), "warn");
+  });
+
+  it("logs each tenant at the console level of the Evolu that created it", async () => {
+    await using setup = await setupSharedWorker();
+    const { console } = setup.run.deps;
+    const quietName = Name.orThrow("quiet");
+
+    await setup.createEvolu({ consoleLevel: "info" });
+    await setup.createEvolu({ tenantName: quietName, consoleLevel: "warn" });
+
+    const infoTenantNames = new Set(
+      console
+        .getEntriesSnapshot()
+        .filter(({ method }) => method === "info")
+        .map(({ path }) => path[0]),
+    );
+    assertTrue(infoTenantNames.has(testName));
+    assertFalse(infoTenantNames.has(quietName));
+  });
+
+  it("posts console entry arguments that cannot be cloned as strings", () => {
+    const messages: Array<ConsoleEntryOrError> = [];
+    // Like a native BroadcastChannel, this one clones each message.
+    const channel: BroadcastChannel<ConsoleEntryOrError> = {
+      postMessage: (message) => {
+        messages.push(structuredClone(message));
+      },
+      onMessage: null,
+      [Symbol.dispose]: () => undefined,
+    };
+
+    const error = new Error("boom", {
+      cause: { attempt: 2, retry: () => undefined },
+    });
+
+    postConsoleEntry(channel, {
+      method: "error",
+      path: ["sql"],
+      args: ["failed", { attempt: 2, retry: () => undefined }, error],
+    });
+
+    assertEqual(messages, [
+      {
+        type: "ConsoleEntry",
+        entry: {
+          method: "error",
+          path: ["sql"],
+          args: [
+            "failed",
+            '{"attempt":2}',
+            {
+              name: "Error",
+              message: "boom",
+              stack: error.stack,
+              cause: '{"attempt":2}',
+            },
+          ],
+        },
+      },
+    ]);
+  });
 });
 
 describe("storage", () => {
@@ -666,7 +762,6 @@ describe("storage", () => {
     );
     leaderPort.postMessage({
       type: "LeaderAcquired",
-      name: testName,
       clock: createTimestamp(),
     });
     await testWaitForWorkerMessage();
@@ -787,7 +882,6 @@ describe("builds", () => {
     );
     port.postMessage({
       type: "LeaderAcquired",
-      name: init.name,
       clock: createTimestamp(),
     });
     await testWaitForWorkerMessage();
@@ -1847,6 +1941,32 @@ describe("sync state", () => {
       assertSame(route.skippedError, null);
     });
 
+    it("broadcasts nothing when a publication runs after the worker is disposed", async (t) => {
+      const createWebSocket = testCreateWebSocket();
+      await using setup = await setupSharedWorker({ createWebSocket });
+      using disposer = new DisposableStack();
+      const { states } = setupSyncStates(setup, disposer);
+      const instance = await setup.createEvolu();
+      const transport = await setupAppOwnerTransport(
+        instance,
+        "wss://disposed-worker.example",
+      );
+
+      const publish = setupDeferredSyncStatePublication(
+        t,
+        createWebSocket,
+        transport.url,
+      );
+      await setup[Symbol.asyncDispose]();
+      await testWaitForWorkerMessage();
+      const publishedCount = states.length;
+
+      // The publication was scheduled before disposal and runs after it.
+      publish();
+      await testWaitForWorkerMessage();
+      assertLength(states, publishedCount);
+    });
+
     for (const removed of [
       "writable registration",
       "source transport",
@@ -2231,6 +2351,120 @@ describe("sync state", () => {
       assertSame(routeOf(latest(), testName, 1).type, "Complete");
     });
 
+    it("reports SyncFailed only for failed owners that still have a route", async () => {
+      const createWebSocket = testCreateWebSocket({ isOpen: false });
+      await using setup = await setupSharedWorker({ createWebSocket });
+      using disposer = new DisposableStack();
+      const { latest } = setupSyncStates(setup, disposer);
+      const instance = await setup.createEvolu();
+      // Both owners share one socket.
+      const transport = {
+        type: "WebSocket",
+        url: "wss://downgraded-owner.example",
+      } as const;
+      instance.evoluChannel.port2.postMessage({
+        type: "UseOwner",
+        actions: [testAppOwner, testAppOwner2].map((owner) => ({
+          owner: { owner, transports: [transport] },
+          action: "add",
+        })),
+      });
+      await testWaitForWorkerMessage();
+      createWebSocket.open(transport.url);
+      await testWaitForWorkerMessage();
+      const round = instance.dbInputs.at(-1);
+      assertNotUndefined(round);
+      assertEqual(round.request, {
+        type: "ForSharedWorker",
+        message: {
+          type: "CreateSyncMessages",
+          owners: [testAppOwner, testAppOwner2],
+        },
+      });
+
+      // While the round is dispatched, the other owner becomes readonly. It
+      // keeps its claim on the transport but no longer has a route.
+      instance.evoluChannel.port2.postMessage({
+        type: "UseOwner",
+        actions: [
+          {
+            owner: {
+              owner: {
+                id: testAppOwner2.id,
+                encryptionKey: testAppOwner2.encryptionKey,
+              },
+              transports: [transport],
+            },
+            action: "add",
+          },
+          {
+            owner: { owner: testAppOwner2, transports: [transport] },
+            action: "remove",
+          },
+        ],
+      });
+      await testWaitForWorkerMessage();
+      const transportId = latest().transports[0]?.id;
+      assertNotUndefined(transportId);
+      assertEqual(
+        ownersOf(latest()).find(({ ownerId }) => ownerId === testAppOwner2.id),
+        {
+          type: "Readonly",
+          ownerId: testAppOwner2.id,
+          transportIds: [transportId],
+        },
+      );
+
+      instance.dbWorkerPort.postMessage({
+        type: "OnQueuedResponse",
+        attemptId: round.attemptId,
+        response: {
+          type: "ForSharedWorker",
+          message: {
+            type: "CreateSyncMessages",
+            protocolMessagesByOwnerId: new Map(),
+            failedOwnerIds: new Set([testAppOwner2.id, testAppOwner.id]),
+          },
+        },
+      });
+      await testWaitForWorkerMessage();
+
+      // The writable owner's route fails, and the readonly owner gets no
+      // route.
+      assertEqual(ownersOf(latest()), [
+        {
+          type: "Writable",
+          ownerId: testAppOwner.id,
+          routes: [
+            {
+              type: "Pending",
+              transportId,
+              failure: { type: "SyncFailed", at: setup.run.deps.time.now() },
+              skippedError: null,
+              completeAt: null,
+              lastSentAt: null,
+              lastReceivedAt: null,
+            },
+          ],
+        },
+        {
+          type: "Readonly",
+          ownerId: testAppOwner2.id,
+          transportIds: [transportId],
+        },
+      ]);
+
+      // The response was handled, so the queue dispatches the next round.
+      instance.evoluChannel.port2.postMessage({
+        type: "UseOwner",
+        actions: [{ ownerId: testAppOwner.id, action: "sync" }],
+      });
+      await testWaitForWorkerMessage();
+      assertEqual(await respondToSyncRound(instance, createWebSocket), [
+        transport.url,
+      ]);
+    });
+
     it("keeps SyncFailed when a round fails after an earlier round was sent", async () => {
       const createWebSocket = testCreateWebSocket();
       await using setup = await setupSharedWorker({ createWebSocket });
@@ -3042,7 +3276,6 @@ describe("sync state", () => {
       };
       dbWorkerPort.postMessage({
         type: "LeaderAcquired",
-        name: testName,
         clock: createTimestamp(),
       });
       await testWaitForWorkerMessage();
@@ -3690,6 +3923,78 @@ describe("sync state", () => {
       assertSame(latest().transports[0].connection.type, "Disconnected");
     });
 
+    it("reconnects a shared socket when the owner silent longest reaches the timeout", async () => {
+      const createWebSocket = testCreateWebSocket({ isOpen: false });
+      await using setup = await setupSharedWorker({ createWebSocket });
+      const instance = await setup.createEvolu();
+      const { time } = setup.run.deps;
+      // Both owners share one socket.
+      const transport = {
+        type: "WebSocket",
+        url: "wss://shared-silent.example",
+      } as const;
+
+      instance.evoluChannel.port2.postMessage({
+        type: "UseOwner",
+        actions: [
+          {
+            owner: { owner: testAppOwner, transports: [transport] },
+            action: "add",
+          },
+        ],
+      });
+      await testWaitForWorkerMessage();
+      createWebSocket.open(transport.url);
+      await testWaitForWorkerMessage();
+      assertEqual(await respondToSyncRound(instance, createWebSocket), [
+        transport.url,
+      ]);
+      await postMutation(instance, setup.run);
+      assertEqual(
+        createWebSocket.sentMessages.splice(0).map(({ url }) => url),
+        [transport.url],
+      );
+
+      // One of the app owner's two requests is answered five seconds in, so
+      // its silence restarts there.
+      time.advance("5s");
+      createWebSocket.message(transport.url, relayResponse());
+      await testWaitForWorkerMessage();
+      await respondToApplySync(instance, false, {
+        ok: true,
+        value: { type: "Converged" },
+      });
+
+      // The second owner's request follows five seconds later.
+      time.advance("5s");
+      instance.evoluChannel.port2.postMessage({
+        type: "UseOwner",
+        actions: [
+          {
+            owner: { owner: testAppOwner2, transports: [transport] },
+            action: "add",
+          },
+        ],
+      });
+      await testWaitForWorkerMessage();
+      assertEqual(
+        await respondToSyncRound(instance, createWebSocket, testAppOwner2),
+        [transport.url],
+      );
+
+      // When the first timer fires, neither owner has been silent for the
+      // whole timeout, so it waits for the app owner, silent the longest.
+      time.advance(Millis.orThrow(80_000));
+      await testWaitForWorkerMessage();
+      assertEqual(createWebSocket.reconnectedUrls, []);
+      time.advance(Millis.orThrow(4_999));
+      await testWaitForWorkerMessage();
+      assertEqual(createWebSocket.reconnectedUrls, []);
+      time.advance("1ms");
+      await testWaitForWorkerMessage();
+      assertEqual(createWebSocket.reconnectedUrls, [transport.url]);
+    });
+
     it("stops timing a request when its socket closes", async () => {
       const createWebSocket = testCreateWebSocket({ isOpen: false });
       await using setup = await setupSharedWorker({ createWebSocket });
@@ -4456,7 +4761,6 @@ describe("sync state", () => {
       };
       leaderPort.postMessage({
         type: "LeaderRefused",
-        name: refusedName,
         error,
       });
       await testWaitForWorkerMessage();
@@ -6263,7 +6567,7 @@ describe("sync state", () => {
         storedVersion: PositiveInt.orThrow(2),
         supportedVersion: PositiveInt.orThrow(1),
       };
-      leaderPort.postMessage({ type: "LeaderRefused", name: testName, error });
+      leaderPort.postMessage({ type: "LeaderRefused", error });
       await testWaitForWorkerMessage();
 
       // Nothing the refused database holds syncs, so it publishes its error
@@ -6364,7 +6668,7 @@ const quotaFailure = (at: number): SyncRouteError => ({
 
 const skippedChange = (at: number): SyncRouteError => ({
   type: "DecryptWithXChaCha20Poly1305Error",
-  error: "wrong encryption key",
+  error: createUnknownError("wrong encryption key"),
   at: Millis.orThrow(at),
 });
 
@@ -6449,7 +6753,7 @@ describe("SyncState", () => {
         skippedError: skippedChange(1000),
         completeAt: null,
         lastSentAt: Millis.orThrow(900),
-        lastReceivedAt: null,
+        lastReceivedAt: Millis.orThrow(1000),
       },
       // @ts-expect-error A settled route has sent a round, so it has when it last sent.
       {
@@ -6458,6 +6762,15 @@ describe("SyncState", () => {
         skippedError: skippedChange(1000),
         completeAt: null,
         lastSentAt: null,
+        lastReceivedAt: Millis.orThrow(1000),
+      },
+      // @ts-expect-error A settled route has received the reply that skipped its change, so it has when it last received.
+      {
+        type: "Settled",
+        transportId,
+        skippedError: skippedChange(1000),
+        completeAt: null,
+        lastSentAt: Millis.orThrow(900),
         lastReceivedAt: null,
       },
       {
@@ -6467,7 +6780,7 @@ describe("SyncState", () => {
         skippedError: null,
         completeAt: null,
         lastSentAt: Millis.orThrow(900),
-        lastReceivedAt: null,
+        lastReceivedAt: Millis.orThrow(1000),
       },
     ];
 
@@ -6493,8 +6806,25 @@ describe("SyncState", () => {
       },
     ];
 
+    const errors: ReadonlyArray<SyncRouteError> = [
+      skippedChange(1000),
+      {
+        type: "DecryptWithXChaCha20Poly1305Error",
+        // @ts-expect-error A caught value in a route error is an UnknownError.
+        error: "wrong encryption key",
+        at: Millis.orThrow(1000),
+      },
+      {
+        type: "ProtocolInvalidDataError",
+        // @ts-expect-error A caught value in a route error is an UnknownError.
+        error: "invalid frame",
+        at: Millis.orThrow(1000),
+      },
+    ];
+
     assertLength(connections, 4);
-    assertLength(routes, 7);
+    assertLength(routes, 8);
+    assertLength(errors, 3);
     assertLength(owners, 2);
     assertLength(tenants, 2);
 
@@ -6911,6 +7241,70 @@ describe("with one evolu instance", () => {
       });
     });
 
+    it("coalesces sync rounds requested before a tab leader starts the DbWorker", async () => {
+      const createWebSocket = testCreateWebSocket();
+      await using setup = await setupSharedWorker({ createWebSocket });
+      using disposer = new DisposableStack();
+      const id = testCreateId()<"EvoluInstance">();
+      await using _instanceLock = await setup.run.ok(acquireLeaderLock(id));
+      using evoluChannel = testCreateMessageChannel<EvoluOutput, EvoluInput>();
+      const transport = createOwnerWebSocketTransport({
+        url: "wss://before-leader.example",
+        ownerId: testAppOwner.id,
+      });
+
+      // Without a tab leader, the tenant starts without a DbWorker.
+      setup.worker.port.postMessage({
+        type: "CreateEvolu",
+        name: testName,
+        id,
+        consoleLevel: "debug",
+        sqliteSchema: testSqliteSchema,
+        encryptionKey: testAppOwner.encryptionKey,
+        memoryOnly: false,
+        evoluPort: evoluChannel.port1.native,
+      });
+      await testWaitForWorkerMessage();
+      assertEqual(setup.sharedWorkerOutputs, []);
+
+      // The first claim through an open transport queues a round, and the
+      // transport reopening requests the same round again. Nothing is
+      // dispatched before a leader, so the queued round absorbs it.
+      evoluChannel.port2.postMessage({
+        type: "UseOwner",
+        actions: [
+          {
+            action: "add",
+            owner: { owner: testAppOwner, transports: [transport] },
+          },
+        ],
+      });
+      await testWaitForWorkerMessage();
+      createWebSocket.close(transport.url);
+      createWebSocket.open(transport.url);
+      await testWaitForWorkerMessage();
+
+      const init = await setupTabLeader(setup, disposer);
+      const dbWorkerPort = disposer.use(
+        testCreateMessagePort<DbWorkerOutput, DbWorkerInput>(init.port),
+      );
+      const dbInputs: Array<ExtractTyped<DbWorkerInput, "Request">> = [];
+      dbWorkerPort.onMessage = (input) => {
+        if (input.type === "Request") dbInputs.push(input);
+      };
+      dbWorkerPort.postMessage({
+        type: "LeaderAcquired",
+        clock: createTimestamp(),
+      });
+      await testWaitForWorkerMessage();
+
+      assertEqual(
+        await respondToSyncRound({ dbInputs, dbWorkerPort }, createWebSocket),
+        [transport.url],
+      );
+      assertLength(dbInputs, 1);
+    });
+
     it("starts the next queued request after the first response arrives", async () => {
       await using setup = await setupSharedWorker();
       const { createEvolu, run } = setup;
@@ -7234,7 +7628,6 @@ describe("with one evolu instance", () => {
       dbWorkerPort.postMessage({
         clock: createTimestamp(),
         type: "LeaderAcquired",
-        name: testName,
       });
       await disposePromise;
       await testWaitForWorkerMessage();
@@ -8235,7 +8628,7 @@ describe("with one evolu instance", () => {
       ]);
     });
 
-    it("reconciles a tenant's later writes when it first uses an already claimed transport", async () => {
+    it("uploads an unregistered sibling's write through every claimed transport, so later registrations start no round", async () => {
       const createWebSocket = testCreateWebSocket();
       await using setup = await setupSharedWorker({ createWebSocket });
       const first = await setup.createEvolu();
@@ -8359,23 +8752,15 @@ describe("with one evolu instance", () => {
       second.dbInputs.length = 0;
 
       // The tenant already has a writable registration through A, and B's
-      // global claim remains active. Its first local use of B needs a new round.
+      // global claim remains active. The sibling's registrations of B start no
+      // round, because its write already went through B, and construct no
+      // socket.
       siblingChannel.port2.postMessage({
         type: "UseOwner",
-        actions: [{ action: "add", owner: syncOwnerB }],
-      });
-      await testWaitForWorkerMessage();
-      assertSame(first.dbInputs.length, 1);
-      assertEqual(await respondToSyncRound(first, createWebSocket), [
-        transportB.url,
-      ]);
-      assertEqual(second.dbInputs, []);
-      first.dbInputs.length = 0;
-
-      // Repeated use does not start another round or construct another socket.
-      siblingChannel.port2.postMessage({
-        type: "UseOwner",
-        actions: [{ action: "add", owner: syncOwnerB }],
+        actions: [
+          { action: "add", owner: syncOwnerB },
+          { action: "add", owner: syncOwnerB },
+        ],
       });
       await testWaitForWorkerMessage();
       assertEqual(first.dbInputs, []);
@@ -9764,7 +10149,6 @@ describe("with one evolu instance", () => {
         };
         port.postMessage({
           type: "LeaderAcquired",
-          name: testName,
           clock: committedClock,
         });
         await testWaitForWorkerMessage();
@@ -9915,7 +10299,6 @@ describe("with one evolu instance", () => {
       };
       dbWorkerPort.postMessage({
         type: "LeaderAcquired",
-        name: testName,
         clock: createTimestamp(),
       });
       await testWaitForWorkerMessage();
@@ -9983,7 +10366,6 @@ describe("with one evolu instance", () => {
       dbWorkerPort.postMessage({
         clock: createTimestamp({ nodeId: maxNodeId }),
         type: "LeaderAcquired",
-        name: testName,
       });
       await testWaitForWorkerMessage();
       // A replacement leader refreshes every instance's subscribed queries.
@@ -10116,7 +10498,6 @@ describe("with one evolu instance", () => {
       const startupClock = createTimestamp({ millis: Millis.orThrow(1000) });
       port.postMessage({
         type: "LeaderAcquired",
-        name: testName,
         clock: startupClock,
       });
       await testWaitForWorkerMessage();
@@ -10257,7 +10638,6 @@ describe("with one evolu instance", () => {
       replacement.use(await replacementLock);
       replacementPort.postMessage({
         type: "LeaderAcquired",
-        name: testName,
         clock: createTimestamp(),
       });
       await testWaitForWorkerMessage();
@@ -10846,7 +11226,6 @@ describe("startup refusal", () => {
     const instance = await setup.createEvoluBeforeDbWorkerLeader();
     instance.dbWorkerPort.postMessage({
       type: "LeaderRefused",
-      name: testName,
       error: refusal,
     });
     await testWaitForWorkerMessage();
@@ -10884,7 +11263,6 @@ describe("startup refusal", () => {
 
     instance.dbWorkerPort.postMessage({
       type: "LeaderRefused",
-      name: testName,
       error: refusal,
     });
     await testWaitForWorkerMessage();
@@ -11008,7 +11386,6 @@ describe("startup refusal", () => {
     };
     leaderPort.postMessage({
       type: "LeaderRefused",
-      name: testName,
       error: refusal,
     });
     await testWaitForWorkerMessage();
@@ -11055,13 +11432,11 @@ describe("startup refusal", () => {
 
     instance.dbWorkerPort.postMessage({
       type: "LeaderRefused",
-      name: testName,
       error: refusal,
     });
     await testWaitForWorkerMessage();
     leaderPort.postMessage({
       type: "LeaderAcquired",
-      name: testName,
       clock: createTimestamp(),
     });
     await testWaitForWorkerMessage();