on-zero 0.16.19 → 0.16.20

package/dist/cjs/createZeroClient.recovery.test.cjs

@@ -6,35 +6,63 @@ var import_createZeroClient = require("./createZeroClient.cjs");
 var import_recoverZeroClient = require("./helpers/recoverZeroClient.cjs");
 var import_jsx_runtime = require("react/jsx-runtime");
 const fakeZero = import_vitest.vi.hoisted(() => {
+  const group = {
+    current: "g1"
+  };
   class FakeZero {
     constructor(options) {
       this.options = options;
       instances.push(this);
+      this.clientGroupID = Promise.resolve(group.current);
+      const listeners = /* @__PURE__ */new Set();
+      this.connection = {
+        state: {
+          current: {
+            name: "closed"
+          },
+          subscribe: listener => {
+            listeners.add(listener);
+            return () => {
+              listeners.delete(listener);
+            };
+          }
+        },
+        connect: import_vitest.vi.fn()
+      };
+      this.__connectionListeners = listeners;
     }
     context = {};
-    connection = {
-      state: {
-        current: {
-          name: "closed"
-        },
-        subscribe: () => () => {}
-      },
-      connect: import_vitest.vi.fn()
-    };
+    connection;
     delete = import_vitest.vi.fn(async () => ({
       errors: []
     }));
     close = import_vitest.vi.fn();
     run = import_vitest.vi.fn(async () => []);
+    mutate = {
+      note: {
+        insert: import_vitest.vi.fn(() => ({
+          client: Promise.resolve({}),
+          server: Promise.resolve({})
+        }))
+      }
+    };
     preload = import_vitest.vi.fn(() => ({
       cleanup: () => {},
       complete: Promise.resolve()
     }));
+    clientGroupID;
   }
   const instances = [];
+  function setConnectionState(instance, name) {
+    instance.connection.state.current.name = name;
+    const listeners = instance.__connectionListeners;
+    for (const listener of [...listeners]) listener();
+  }
   return {
     FakeZero,
-    instances
+    instances,
+    group,
+    setConnectionState
   };
 });
 import_vitest.vi.mock("@rocicorp/zero", async importOriginal => {
@@ -64,6 +92,7 @@ let root;
   window.sessionStorage.clear();
   (0, import_recoverZeroClient.resetRecoveryStateForTests)();
   fakeZero.instances.length = 0;
+  fakeZero.group.current = "g1";
   container = document.createElement("div");
   root = null;
 });
@@ -421,4 +450,316 @@ async function mount() {
   (0, import_vitest.expect)(await isolated.waitForZero()).toBe(connection.zero);
   (0, import_vitest.expect)(first.close).toHaveBeenCalledOnce();
   await connection.close();
+});
+function makeTransitionClient(instanceName) {
+  return (0, import_createZeroClient.createZeroClient)({
+    schema,
+    models: {},
+    groupedQueries: {},
+    instanceName
+  });
+}
+function collectClientEvents(client2) {
+  const events = [];
+  const off = client2.zeroEvents.listen(event => {
+    if (event) events.push(event);
+  });
+  return {
+    events,
+    off
+  };
+}
+async function mountTransitionClient(client2, userID) {
+  const el = document.createElement("div");
+  const mountedRoot = (0, import_client.createRoot)(el);
+  await (0, import_react.act)(async () => {
+    mountedRoot.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(client2.ProvideZero, {
+      cacheURL: "http://127.0.0.1:7777/zero",
+      userID,
+      children: /* @__PURE__ */(0, import_jsx_runtime.jsx)("span", {
+        children: "ok"
+      })
+    }));
+    await Promise.resolve();
+  });
+  return {
+    el,
+    root: mountedRoot,
+    instance: fakeZero.instances.at(-1)
+  };
+}
+async function unmountTransitionClient(mounted) {
+  await (0, import_react.act)(async () => {
+    mounted.root.unmount();
+  });
+}
+function withoutPageReload() {
+  const originalLocation = globalThis.location;
+  Object.defineProperty(globalThis, "location", {
+    configurable: true,
+    value: void 0
+  });
+  return () => {
+    Object.defineProperty(globalThis, "location", {
+      configurable: true,
+      value: originalLocation
+    });
+  };
+}
+(0, import_vitest.test)("two providers ride one group transition and keep querying and mutating", async () => {
+  const restoreLocation = withoutPageReload();
+  const clientA = makeTransitionClient("transition-two-a");
+  const clientB = makeTransitionClient("transition-two-b");
+  const collectedA = collectClientEvents(clientA);
+  const collectedB = collectClientEvents(clientB);
+  const mountedA = await mountTransitionClient(clientA, "transition-user");
+  const mountedB = await mountTransitionClient(clientB, "transition-user");
+  const firstA = mountedA.instance;
+  const firstB = mountedB.instance;
+  const countBefore = fakeZero.instances.length;
+  try {
+    firstA.options.onUpdateNeeded({
+      type: "NewClientGroup"
+    });
+    firstB.options.onUpdateNeeded({
+      type: "NewClientGroup"
+    });
+    await (0, import_react.act)(async () => {
+      await new Promise(resolve => setTimeout(resolve, 0));
+    });
+    (0, import_vitest.expect)(fakeZero.instances).toHaveLength(countBefore + 2);
+    const secondA = fakeZero.instances[countBefore];
+    const secondB = fakeZero.instances[countBefore + 1];
+    (0, import_vitest.expect)(secondA).not.toBe(firstA);
+    (0, import_vitest.expect)(secondB).not.toBe(firstB);
+    (0, import_vitest.expect)(firstA.close).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(firstB.close).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)((0, import_recoverZeroClient.isGroupTransitionOpen)()).toBe(true);
+    await (0, import_react.act)(async () => {
+      fakeZero.setConnectionState(secondA, "connected");
+      fakeZero.setConnectionState(secondB, "connected");
+      await Promise.resolve();
+    });
+    await import_vitest.vi.waitFor(() => (0, import_vitest.expect)((0, import_recoverZeroClient.isGroupTransitionOpen)()).toBe(false));
+    const allEvents = [...collectedA.events, ...collectedB.events];
+    (0, import_vitest.expect)(allEvents.filter(event => event.type === "recovering")).toHaveLength(1);
+    (0, import_vitest.expect)(allEvents.filter(event => event.type === "fatal")).toHaveLength(0);
+    (0, import_vitest.expect)(firstA.delete).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(firstB.delete).not.toHaveBeenCalled();
+    await clientA.zero.run({});
+    await clientB.zero.run({});
+    (0, import_vitest.expect)(secondA.run).toHaveBeenCalled();
+    (0, import_vitest.expect)(secondB.run).toHaveBeenCalled();
+    clientA.zero.mutate.note.insert({
+      id: "a1"
+    });
+    clientB.zero.mutate.note.insert({
+      id: "b1"
+    });
+    (0, import_vitest.expect)(secondA.mutate.note.insert).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(secondB.mutate.note.insert).toHaveBeenCalledTimes(1);
+  } finally {
+    collectedA.off();
+    collectedB.off();
+    await unmountTransitionClient(mountedA);
+    await unmountTransitionClient(mountedB);
+    restoreLocation();
+  }
+});
+(0, import_vitest.test)("a second registry change after recovery remints again without fatal", async () => {
+  const restoreLocation = withoutPageReload();
+  const clientA = makeTransitionClient("transition-second-a");
+  const clientB = makeTransitionClient("transition-second-b");
+  const collectedA = collectClientEvents(clientA);
+  const collectedB = collectClientEvents(clientB);
+  const mountedA = await mountTransitionClient(clientA, "transition-second-user");
+  const mountedB = await mountTransitionClient(clientB, "transition-second-user");
+  try {
+    const fireBoth = instances => {
+      instances[0].options.onUpdateNeeded({
+        type: "NewClientGroup"
+      });
+      instances[1].options.onUpdateNeeded({
+        type: "NewClientGroup"
+      });
+    };
+    const settleRemints = async countBefore2 => {
+      await (0, import_react.act)(async () => {
+        await new Promise(resolve => setTimeout(resolve, 0));
+      });
+      (0, import_vitest.expect)(fakeZero.instances).toHaveLength(countBefore2 + 2);
+      const next = fakeZero.instances.slice(countBefore2);
+      await (0, import_react.act)(async () => {
+        for (const instance of next) fakeZero.setConnectionState(instance, "connected");
+        await Promise.resolve();
+      });
+      await import_vitest.vi.waitFor(() => (0, import_vitest.expect)((0, import_recoverZeroClient.isGroupTransitionOpen)()).toBe(false));
+      return next;
+    };
+    const countBeforeFirst = fakeZero.instances.length;
+    fireBoth(fakeZero.instances.slice(-2));
+    await settleRemints(countBeforeFirst);
+    fakeZero.group.current = "g2";
+    const countBefore = fakeZero.instances.length;
+    fireBoth(fakeZero.instances.slice(-2));
+    const third = await settleRemints(countBefore);
+    const allEvents = [...collectedA.events, ...collectedB.events];
+    (0, import_vitest.expect)(allEvents.filter(event => event.type === "recovering")).toHaveLength(2);
+    (0, import_vitest.expect)(allEvents.filter(event => event.type === "fatal")).toHaveLength(0);
+    await clientA.zero.run({});
+    await clientB.zero.run({});
+    (0, import_vitest.expect)(third[0].run).toHaveBeenCalled();
+    (0, import_vitest.expect)(third[1].run).toHaveBeenCalled();
+  } finally {
+    collectedA.off();
+    collectedB.off();
+    await unmountTransitionClient(mountedA);
+    await unmountTransitionClient(mountedB);
+    restoreLocation();
+  }
+});
+(0, import_vitest.test)("negative control: an incompatible schema emits exactly one terminal error, never a loop", async () => {
+  const restoreLocation = withoutPageReload();
+  const consoleError = import_vitest.vi.spyOn(console, "error").mockImplementation(() => {});
+  const clientA = makeTransitionClient("transition-negative-a");
+  const clientB = makeTransitionClient("transition-negative-b");
+  const collectedA = collectClientEvents(clientA);
+  const collectedB = collectClientEvents(clientB);
+  const mountedA = await mountTransitionClient(clientA, "transition-negative-user");
+  const mountedB = await mountTransitionClient(clientB, "transition-negative-user");
+  const firstA = mountedA.instance;
+  const firstB = mountedB.instance;
+  const countBefore = fakeZero.instances.length;
+  try {
+    firstA.options.onUpdateNeeded({
+      type: "SchemaVersionNotSupported"
+    });
+    firstB.options.onUpdateNeeded({
+      type: "SchemaVersionNotSupported"
+    });
+    await (0, import_react.act)(async () => {
+      await new Promise(resolve => setTimeout(resolve, 0));
+    });
+    (0, import_vitest.expect)(firstA.delete).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(firstB.delete).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(fakeZero.instances).toHaveLength(countBefore + 2);
+    const secondA = fakeZero.instances[countBefore];
+    const secondB = fakeZero.instances[countBefore + 1];
+    (0, import_vitest.expect)((0, import_recoverZeroClient.isGroupTransitionOpen)()).toBe(true);
+    secondA.options.onUpdateNeeded({
+      type: "SchemaVersionNotSupported"
+    });
+    await (0, import_react.act)(async () => {
+      await new Promise(resolve => setTimeout(resolve, 0));
+    });
+    const allEvents = () => [...collectedA.events, ...collectedB.events];
+    (0, import_vitest.expect)(allEvents().filter(event => event.type === "fatal")).toHaveLength(1);
+    const [fatal] = allEvents().filter(event => event.type === "fatal");
+    (0, import_vitest.expect)(fatal).toMatchObject({
+      reasonKey: "SchemaVersionNotSupported",
+      reason: import_vitest.expect.stringContaining("g1")
+    });
+    (0, import_vitest.expect)(consoleError).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(consoleError.mock.calls[0][0]).toContain("g1");
+    secondB.options.onUpdateNeeded({
+      type: "SchemaVersionNotSupported"
+    });
+    secondA.options.onUpdateNeeded({
+      type: "SchemaVersionNotSupported"
+    });
+    await (0, import_react.act)(async () => {
+      await new Promise(resolve => setTimeout(resolve, 0));
+    });
+    (0, import_vitest.expect)(allEvents().filter(event => event.type === "fatal")).toHaveLength(1);
+    (0, import_vitest.expect)(consoleError).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(fakeZero.instances).toHaveLength(countBefore + 2);
+  } finally {
+    collectedA.off();
+    collectedB.off();
+    await unmountTransitionClient(mountedA);
+    await unmountTransitionClient(mountedB);
+    restoreLocation();
+    consoleError.mockRestore();
+  }
+});
+(0, import_vitest.test)("concurrent update signals across providers schedule a single reload", async () => {
+  const reloadPage = import_vitest.vi.fn();
+  const originalLocation = globalThis.location;
+  Object.defineProperty(globalThis, "location", {
+    configurable: true,
+    value: {
+      href: "http://localhost/reload-test",
+      reload: reloadPage
+    }
+  });
+  const scheduleA = import_vitest.vi.fn();
+  const scheduleB = import_vitest.vi.fn();
+  const clientA = makeTransitionClient("transition-reload-a");
+  const clientB = makeTransitionClient("transition-reload-b");
+  const collectedA = collectClientEvents(clientA);
+  const collectedB = collectClientEvents(clientB);
+  const elA = document.createElement("div");
+  const elB = document.createElement("div");
+  const rootA = (0, import_client.createRoot)(elA);
+  const rootB = (0, import_client.createRoot)(elB);
+  try {
+    await (0, import_react.act)(async () => {
+      rootA.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(clientA.ProvideZero, {
+        cacheURL: "http://127.0.0.1:7777/zero",
+        userID: "transition-reload-user",
+        scheduleReload: scheduleA,
+        children: /* @__PURE__ */(0, import_jsx_runtime.jsx)("span", {
+          children: "ok"
+        })
+      }));
+      await Promise.resolve();
+    });
+    await (0, import_react.act)(async () => {
+      rootB.render(/* @__PURE__ */(0, import_jsx_runtime.jsx)(clientB.ProvideZero, {
+        cacheURL: "http://127.0.0.1:7777/zero",
+        userID: "transition-reload-user",
+        scheduleReload: scheduleB,
+        children: /* @__PURE__ */(0, import_jsx_runtime.jsx)("span", {
+          children: "ok"
+        })
+      }));
+      await Promise.resolve();
+    });
+    const firstA = fakeZero.instances.at(-2);
+    const firstB = fakeZero.instances.at(-1);
+    firstA.options.onUpdateNeeded({
+      type: "NewClientGroup"
+    });
+    firstB.options.onUpdateNeeded({
+      type: "NewClientGroup"
+    });
+    await (0, import_react.act)(async () => {
+      await new Promise(resolve => setTimeout(resolve, 0));
+    });
+    (0, import_vitest.expect)(scheduleA.mock.calls.length + scheduleB.mock.calls.length).toBe(1);
+    (0, import_vitest.expect)(reloadPage).not.toHaveBeenCalled();
+    const allEvents = [...collectedA.events, ...collectedB.events];
+    (0, import_vitest.expect)(allEvents.filter(event => event.type === "fatal")).toHaveLength(0);
+    const ctx = (scheduleA.mock.calls[0] ?? scheduleB.mock.calls[0])[0];
+    await (0, import_react.act)(async () => {
+      await ctx.performReload();
+    });
+    (0, import_vitest.expect)(reloadPage).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)((0, import_recoverZeroClient.isGroupTransitionOpen)()).toBe(false);
+    const marker = window.sessionStorage.getItem("on-zero-recover-http://localhost/reload-test-NewClientGroup");
+    (0, import_vitest.expect)(marker).toContain("g1");
+  } finally {
+    collectedA.off();
+    collectedB.off();
+    await (0, import_react.act)(async () => {
+      rootA.unmount();
+    });
+    await (0, import_react.act)(async () => {
+      rootB.unmount();
+    });
+    Object.defineProperty(globalThis, "location", {
+      configurable: true,
+      value: originalLocation
+    });
+  }
 });