on-zero 0.4.26 → 0.4.28

package/dist/cjs/httpPull/rebase.test.cjs

@@ -0,0 +1,360 @@
+var import_vitest = require("vitest");
+var import_testHarness = require("./testHarness.cjs");
+let harness;
+(0, import_vitest.afterEach)(async () => {
+  await harness?.close();
+  harness = void 0;
+});
+(0, import_vitest.test)("ack-then-pull keeps optimistic rows visible until the authoritative snapshot lands", async () => {
+  const postPushPull = deferred();
+  const postPushPullStarted = deferred();
+  let shouldHoldPostPushPull = false;
+  harness = await (0, import_testHarness.startZeroHttpHarness)({
+    seed: {
+      user: [{
+        id: "u1",
+        name: "ada"
+      }],
+      project: [{
+        id: "p1",
+        ownerId: "u1",
+        name: "first"
+      }],
+      member: []
+    },
+    interceptFetch: next => async (input, init) => {
+      const path = new URL(String(input)).pathname;
+      if (path === "/push") {
+        const response = await next(input, init);
+        shouldHoldPostPushPull = true;
+        return response;
+      }
+      if (path === "/pull" && shouldHoldPostPushPull) {
+        shouldHoldPostPushPull = false;
+        postPushPullStarted.resolve();
+        await postPushPull.promise;
+      }
+      return next(input, init);
+    }
+  });
+  const zero = harness.createZero("u1");
+  const view = zero.query.project.materialize();
+  await (0, import_testHarness.waitForComplete)(view);
+  const emissions = recordEmissions(view);
+  const mutation = zero.mutate.project.create({
+    id: "p2",
+    ownerId: "u1",
+    name: "second"
+  });
+  await mutation.client;
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data)).toContain("p2"));
+  await mutation.server;
+  await postPushPullStarted.promise;
+  (0, import_vitest.expect)(projectIDs(view.data)).toContain("p2");
+  postPushPull.resolve();
+  await harness.transport.pull();
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data).sort()).toEqual(["p1", "p2"]));
+  expectNeverDisappearsAfterFirstSeen(emissions, "p2");
+  (0, import_vitest.expect)(harness.server.rows("project").sort(byID)).toEqual([{
+    id: "p1",
+    ownerId: "u1",
+    name: "first"
+  }, {
+    id: "p2",
+    ownerId: "u1",
+    name: "second"
+  }]);
+  emissions.cleanup();
+  view.destroy();
+});
+(0, import_vitest.test)("pull-then-ack rebases optimistic rows over a newer snapshot", async () => {
+  const pushGate = deferred();
+  const pushStarted = deferred();
+  harness = await (0, import_testHarness.startZeroHttpHarness)({
+    seed: {
+      user: [{
+        id: "u1",
+        name: "ada"
+      }],
+      project: [{
+        id: "p1",
+        ownerId: "u1",
+        name: "first"
+      }],
+      member: []
+    },
+    interceptFetch: next => async (input, init) => {
+      const path = new URL(String(input)).pathname;
+      if (path === "/push") {
+        const body = JSON.parse(String(init?.body));
+        pushStarted.resolve(body);
+        await pushGate.promise;
+      }
+      return next(input, init);
+    }
+  });
+  const zero = harness.createZero("u1");
+  const view = zero.query.project.materialize();
+  await (0, import_testHarness.waitForComplete)(view);
+  const emissions = recordEmissions(view);
+  const mutation = zero.mutate.project.create({
+    id: "p2",
+    ownerId: "u1",
+    name: "optimistic"
+  });
+  await mutation.client;
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data)).toContain("p2"));
+  const heldPush = await pushStarted.promise;
+  await rawPush(harness, {
+    clientGroupID: heldPush.clientGroupID,
+    clientID: "server-side",
+    id: 1,
+    name: "project|create",
+    args: {
+      id: "p-server",
+      ownerId: "u1",
+      name: "server change"
+    }
+  });
+  await harness.transport.pull();
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data).sort()).toEqual(["p-server", "p1", "p2"]));
+  (0, import_vitest.expect)(harness.server.rows("project").map(row => row.id).sort()).toEqual(["p-server", "p1"]);
+  pushGate.resolve();
+  await mutation.server;
+  await harness.transport.pull();
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data).sort()).toEqual(["p-server", "p1", "p2"]));
+  expectNeverDisappearsAfterFirstSeen(emissions, "p2");
+  (0, import_vitest.expect)(harness.server.rows("project").sort(byID)).toEqual([{
+    id: "p-server",
+    ownerId: "u1",
+    name: "server change"
+  }, {
+    id: "p1",
+    ownerId: "u1",
+    name: "first"
+  }, {
+    id: "p2",
+    ownerId: "u1",
+    name: "optimistic"
+  }]);
+  emissions.cleanup();
+  view.destroy();
+});
+(0, import_vitest.test)("app-error rollback advances LMID and reverts optimistic state after pull", async () => {
+  const pushGate = deferred();
+  const pushStarted = deferred();
+  let clientGroupID = "";
+  harness = await (0, import_testHarness.startZeroHttpHarness)({
+    seed: {
+      user: [{
+        id: "u1",
+        name: "ada"
+      }, {
+        id: "u2",
+        name: "ben"
+      }],
+      project: [{
+        id: "p1",
+        ownerId: "u2",
+        name: "shared"
+      }],
+      member: [{
+        id: "m1",
+        projectId: "p1",
+        userId: "u1"
+      }]
+    },
+    interceptFetch: next => async (input, init) => {
+      if (new URL(String(input)).pathname === "/push") {
+        const body = JSON.parse(String(init?.body));
+        clientGroupID = body.clientGroupID;
+        pushStarted.resolve();
+        await pushGate.promise;
+      }
+      return next(input, init);
+    }
+  });
+  const zero = harness.createZero("u1");
+  const view = zero.query.project.materialize();
+  await (0, import_testHarness.waitForComplete)(view);
+  const emissions = recordEmissions(view);
+  const mutation = zero.mutate.project.rename({
+    id: "p1",
+    name: "stolen"
+  });
+  await mutation.client;
+  await pushStarted.promise;
+  (0, import_vitest.expect)(projectName(view.data, "p1")).toBe("stolen");
+  (0, import_vitest.expect)(harness.server.rows("project")).toEqual([{
+    id: "p1",
+    ownerId: "u2",
+    name: "shared"
+  }]);
+  pushGate.resolve();
+  await (0, import_vitest.expect)(mutation.server).resolves.toMatchObject({
+    type: "error",
+    error: {
+      type: "app",
+      details: "forbidden"
+    }
+  });
+  await harness.transport.pull();
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectName(view.data, "p1")).toBe("shared"));
+  (0, import_vitest.expect)(emissions.values.map(rows => projectName(rows, "p1"))).toContain("stolen");
+  (0, import_vitest.expect)(emissions.values.at(-1)?.[0]).toEqual({
+    id: "p1",
+    ownerId: "u2",
+    name: "shared"
+  });
+  (0, import_vitest.expect)(harness.server.rows("project")).toEqual([{
+    id: "p1",
+    ownerId: "u2",
+    name: "shared"
+  }]);
+  const pull = await rawPull(harness, "u1", {
+    clientGroupID
+  });
+  (0, import_vitest.expect)(Object.values(pull.lastMutationIDChanges)).toContain(1);
+  emissions.cleanup();
+  view.destroy();
+});
+(0, import_vitest.test)("app-error rollback removes phantom optimistic create after pull", async () => {
+  const pushGate = deferred();
+  const pushStarted = deferred();
+  let clientGroupID = "";
+  harness = await (0, import_testHarness.startZeroHttpHarness)({
+    seed: {
+      user: [{
+        id: "u1",
+        name: "ada"
+      }, {
+        id: "u2",
+        name: "ben"
+      }],
+      project: [],
+      member: []
+    },
+    interceptFetch: next => async (input, init) => {
+      if (new URL(String(input)).pathname === "/push") {
+        const body = JSON.parse(String(init?.body));
+        clientGroupID = body.clientGroupID;
+        pushStarted.resolve();
+        await pushGate.promise;
+      }
+      return next(input, init);
+    }
+  });
+  const zero = harness.createZero("u1");
+  const view = zero.query.project.materialize();
+  await (0, import_testHarness.waitForComplete)(view);
+  const emissions = recordEmissions(view);
+  const mutation = zero.mutate.project.create({
+    id: "p-phantom",
+    ownerId: "u2",
+    name: "forbidden"
+  });
+  await mutation.client;
+  await pushStarted.promise;
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data)).toContain("p-phantom"));
+  (0, import_vitest.expect)(harness.server.rows("project")).toEqual([]);
+  pushGate.resolve();
+  await (0, import_vitest.expect)(mutation.server).resolves.toMatchObject({
+    type: "error",
+    error: {
+      type: "app",
+      details: "forbidden"
+    }
+  });
+  await harness.transport.pull();
+  await (0, import_testHarness.eventually)(() => (0, import_vitest.expect)(projectIDs(view.data)).not.toContain("p-phantom"));
+  (0, import_vitest.expect)(emissions.values.some(rows => projectIDs(rows).includes("p-phantom"))).toBe(true);
+  (0, import_vitest.expect)(emissions.values.at(-1)).toEqual([]);
+  (0, import_vitest.expect)(harness.server.rows("project")).toEqual([]);
+  const pull = await rawPull(harness, "u1", {
+    clientGroupID
+  });
+  (0, import_vitest.expect)(Object.values(pull.lastMutationIDChanges)).toContain(1);
+  emissions.cleanup();
+  view.destroy();
+});
+async function rawPush(harness2, mutation) {
+  const response = await fetch(`${harness2.server.url}/push`, {
+    method: "POST",
+    headers: {
+      authorization: "Bearer token-u1",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      timestamp: Date.now(),
+      clientGroupID: mutation.clientGroupID,
+      pushVersion: 1,
+      requestID: `raw-${mutation.clientID}-${mutation.id}`,
+      mutations: [{
+        type: "custom",
+        name: mutation.name,
+        id: mutation.id,
+        clientID: mutation.clientID,
+        args: [mutation.args]
+      }]
+    })
+  });
+  (0, import_vitest.expect)(response.status).toBe(200);
+  return response.json();
+}
+async function rawPull(harness2, userID, body) {
+  const response = await fetch(`${harness2.server.url}/pull`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer token-${userID}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      clientID: "raw-pull",
+      clientGroupID: body.clientGroupID,
+      cookie: null
+    })
+  });
+  (0, import_vitest.expect)(response.status).toBe(200);
+  return response.json();
+}
+function recordEmissions(view) {
+  const values = [];
+  const cleanup = view.addListener(data => values.push(snapshot(data)));
+  return {
+    values,
+    cleanup
+  };
+}
+function snapshot(rows) {
+  return JSON.parse(JSON.stringify(rows));
+}
+function projectIDs(rows) {
+  return rows.map(row => row.id);
+}
+function projectName(rows, id) {
+  return rows.find(row => row.id === id)?.name;
+}
+function expectNeverDisappearsAfterFirstSeen(emissions, id) {
+  let seen = false;
+  for (const rows of emissions.values) {
+    if (projectIDs(rows).includes(id)) seen = true;
+    if (seen) (0, import_vitest.expect)(projectIDs(rows)).toContain(id);
+  }
+  (0, import_vitest.expect)(seen).toBe(true);
+}
+function byID(a, b) {
+  return a.id.localeCompare(b.id);
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}