on-zero 0.4.26 → 0.4.28

package/dist/esm/httpPull/transport.test.native.js

@@ -0,0 +1,675 @@
+import { Zero } from "@rocicorp/zero";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { zeroHttpFixtureMutators, zeroHttpFixtureSchema } from "./fixtureSchema.native.js";
+import { ensureHttpPullTransport, installHttpPullTransport } from "../httpPullTransport.native.js";
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var ORIGIN = "https://zero-http.local";
+var zeros = [];
+var transports = [];
+var storageID = 0;
+afterEach(async function () {
+  var _zeros_pop, _transports_pop;
+  while (zeros.length) await ((_zeros_pop = zeros.pop()) === null || _zeros_pop === void 0 ? void 0 : _zeros_pop.close());
+  while (transports.length) (_transports_pop = transports.pop()) === null || _transports_pop === void 0 ? void 0 : _transports_pop.uninstall();
+  vi.useRealTimers();
+});
+describe("zero-http transport", function () {
+  test("connect + complete hydrates a stock Zero materialized query", async function () {
+    var requests = [];
+    var cookie = 0;
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      requests.push(request);
+      expect(request.path).toBe("/pull");
+      expect(request.headers.authorization).toBe("Bearer token-u1");
+      return jsonResponse({
+        cookie: ++cookie,
+        lastMutationIDChanges: {},
+        rowsPatch: [{
+          op: "clear"
+        }, {
+          op: "put",
+          tableName: "user",
+          value: {
+            id: "u1",
+            name: "ada"
+          }
+        }, {
+          op: "put",
+          tableName: "project",
+          value: {
+            id: "p1",
+            ownerId: "u1",
+            name: "control"
+          }
+        }, {
+          op: "put",
+          tableName: "member",
+          value: {
+            id: "m1",
+            projectId: "p1",
+            userId: "u1"
+          }
+        }]
+      });
+    });
+    var transport = install(fetch);
+    var zero = createZero();
+    var view = zero.query.project.related("members").materialize();
+    var data = await waitForComplete(view);
+    view.destroy();
+    expect(transport.connections).toBe(1);
+    expect(data).toEqual([{
+      id: "p1",
+      ownerId: "u1",
+      name: "control",
+      members: [{
+        id: "m1",
+        projectId: "p1",
+        userId: "u1"
+      }]
+    }]);
+    expect(requests[0].body.cookie).toBeNull();
+    expect(requests[0].body.clientID).toEqual(expect.any(String));
+    expect(requests[0].body.clientGroupID).toEqual(expect.any(String));
+  });
+  test("push frames POST to /push, resolve server promises, and schedule a follow-up pull", async function () {
+    var requests = [];
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      requests.push(request);
+      if (request.path === "/pull") {
+        return jsonResponse({
+          cookie: request.body.cookie,
+          unchanged: true
+        });
+      }
+      expect(request.path).toBe("/push");
+      var mutation2 = request.body.mutations[0];
+      return jsonResponse({
+        pushResponse: {
+          mutations: [{
+            id: {
+              clientID: mutation2.clientID,
+              id: mutation2.id
+            },
+            result: {}
+          }]
+        }
+      });
+    });
+    install(fetch);
+    var zero = createZero();
+    await eventually(function () {
+      return expect(requests.filter(function (request) {
+        return request.path === "/pull";
+      }).length).toBe(1);
+    });
+    var pullsBeforePush = requests.filter(function (request) {
+      return request.path === "/pull";
+    }).length;
+    var mutation = zero.mutate.project.create({
+      id: "p1",
+      ownerId: "u1",
+      name: "created"
+    });
+    await mutation.client;
+    await mutation.server;
+    var push = requests.find(function (request) {
+      return request.path === "/push";
+    });
+    expect(push === null || push === void 0 ? void 0 : push.headers.authorization).toBe("Bearer token-u1");
+    expect(push === null || push === void 0 ? void 0 : push.body).toMatchObject({
+      clientGroupID: expect.any(String),
+      pushVersion: 1,
+      requestID: expect.any(String),
+      mutations: [{
+        type: "custom",
+        name: "project|create",
+        id: 1,
+        clientID: expect.any(String),
+        args: [{
+          id: "p1",
+          ownerId: "u1",
+          name: "created"
+        }]
+      }]
+    });
+    await eventually(function () {
+      return expect(requests.filter(function (request) {
+        return request.path === "/pull";
+      }).length).toBe(pullsBeforePush + 1);
+    });
+  });
+  test("updateAuth frame updates bearer headers for later requests", async function () {
+    var _requests_at;
+    var requests = [];
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      requests.push(request);
+      expect(request.path).toBe("/pull");
+      return jsonResponse({
+        cookie: request.body.cookie,
+        unchanged: true
+      });
+    });
+    var transport = install(fetch);
+    var {
+      socket
+    } = openRawSocketWithMessages({
+      authToken: "token-old"
+    });
+    await eventually(function () {
+      return expect(requests.length).toBe(1);
+    });
+    expect(requests[0].headers.authorization).toBe("Bearer token-old");
+    socket.send(JSON.stringify(["updateAuth", {
+      auth: "token-new"
+    }]));
+    await transport.pull();
+    expect((_requests_at = requests.at(-1)) === null || _requests_at === void 0 ? void 0 : _requests_at.headers.authorization).toBe("Bearer token-new");
+  });
+  test("push frames are serialized per socket", async function () {
+    var firstPushStarted = defer();
+    var releaseFirstPush = defer();
+    var pushIDs = [];
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      if (request.path === "/pull") {
+        return jsonResponse({
+          cookie: request.body.cookie,
+          unchanged: true
+        });
+      }
+      expect(request.path).toBe("/push");
+      var mutationID = request.body.mutations[0].id;
+      pushIDs.push(mutationID);
+      if (mutationID === 1) {
+        firstPushStarted.resolve();
+        await releaseFirstPush.promise;
+      }
+      return jsonResponse({
+        pushResponse: {
+          mutations: request.body.mutations.map(function (mutation) {
+            return {
+              id: {
+                clientID: mutation.clientID,
+                id: mutation.id
+              },
+              result: {}
+            };
+          })
+        }
+      });
+    });
+    install(fetch);
+    var {
+      messages,
+      socket
+    } = openRawSocketWithMessages();
+    await eventually(function () {
+      return expect(messages.some(function (message) {
+        return message[0] === "connected";
+      })).toBe(true);
+    });
+    socket.send(JSON.stringify(["push", pushBody(1)]));
+    await firstPushStarted.promise;
+    socket.send(JSON.stringify(["push", pushBody(2)]));
+    await sleep(25);
+    expect(pushIDs).toEqual([1]);
+    releaseFirstPush.resolve();
+    await eventually(function () {
+      return expect(pushIDs).toEqual([1, 2]);
+    });
+    await eventually(function () {
+      return expect(messages.filter(function (message) {
+        return message[0] === "pushResponse";
+      })).toHaveLength(2);
+    });
+    expect(messages.filter(function (message) {
+      return message[0] === "pushResponse";
+    }).map(function (message) {
+      return message[1].mutations[0].id.id;
+    })).toEqual([1, 2]);
+  });
+  test("cookie discipline skips unchanged pokes, chains changed pokes, and coalesces concurrent pulls", async function () {
+    var requests = [];
+    var responses = [{
+      cookie: 1,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }]
+    }, {
+      cookie: 1,
+      unchanged: true
+    }, {
+      cookie: 2,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }, {
+        op: "put",
+        tableName: "project",
+        value: {
+          id: "p2",
+          ownerId: "u1",
+          name: "second"
+        }
+      }]
+    }, {
+      cookie: 3,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }, {
+        op: "put",
+        tableName: "project",
+        value: {
+          id: "p3",
+          ownerId: "u1",
+          name: "third"
+        }
+      }]
+    }];
+    var deferred = defer();
+    responses.push(deferred.promise);
+    var inFlight = 0;
+    var maxInFlight = 0;
+    var fetch = vi.fn(async function (input, init) {
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      try {
+        var request = recordRequest(input, init);
+        requests.push(request);
+        var response = responses.shift();
+        if (!response) throw new Error("missing canned response");
+        return jsonResponse(await response);
+      } finally {
+        inFlight--;
+      }
+    });
+    var transport = install(fetch);
+    var messages = openRawSocket();
+    await eventually(function () {
+      return expect(messages.some(function (message) {
+        return message[0] === "pokeEnd";
+      })).toBe(true);
+    });
+    expect(requests[0].body.cookie).toBeNull();
+    expect(findMessage(messages, "pokeStart")[1].baseCookie).toBeNull();
+    expect(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000001");
+    messages.length = 0;
+    await transport.pull();
+    expect(messages.filter(function (message) {
+      return message[0].startsWith("poke");
+    })).toEqual([]);
+    expect(requests[1].body.cookie).toBe(1);
+    await transport.pull();
+    expect(findMessage(messages, "pokeStart")[1].baseCookie).toBe("00000000000000000001");
+    expect(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000002");
+    expect(requests[2].body.cookie).toBe(1);
+    messages.length = 0;
+    await transport.pull();
+    expect(findMessage(messages, "pokeStart")[1].baseCookie).toBe("00000000000000000002");
+    expect(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000003");
+    expect(requests[3].body.cookie).toBe(2);
+    messages.length = 0;
+    var concurrentA = transport.pull();
+    var concurrentB = transport.pull();
+    await eventually(function () {
+      return expect(requests.length).toBe(5);
+    });
+    deferred.resolve({
+      cookie: 4,
+      lastMutationIDChanges: {},
+      rowsPatch: [{
+        op: "clear"
+      }]
+    });
+    await Promise.all([concurrentA, concurrentB]);
+    expect(requests.length).toBe(5);
+    expect(maxInFlight).toBe(1);
+    expect(findMessage(messages, "pokeStart")[1].baseCookie).toBe("00000000000000000003");
+    expect(findMessage(messages, "pokeEnd")[1].cookie).toBe("00000000000000000004");
+  });
+  test("unchanged pull flushes late query registration to complete", async function () {
+    var _requests_at;
+    var requests = [];
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      requests.push(request);
+      expect(request.path).toBe("/pull");
+      if (request.body.cookie === null) {
+        return jsonResponse({
+          cookie: 1,
+          lastMutationIDChanges: {},
+          rowsPatch: [{
+            op: "clear"
+          }, {
+            op: "put",
+            tableName: "user",
+            value: {
+              id: "u1",
+              name: "ada"
+            }
+          }, {
+            op: "put",
+            tableName: "project",
+            value: {
+              id: "p1",
+              ownerId: "u1",
+              name: "first"
+            }
+          }]
+        });
+      }
+      return jsonResponse({
+        cookie: request.body.cookie,
+        unchanged: true
+      });
+    });
+    install(fetch);
+    var zero = createZero();
+    var projectView = zero.query.project.materialize();
+    await waitForComplete(projectView);
+    var userView = zero.query.user.materialize();
+    var users = await waitForComplete(userView);
+    expect(users).toEqual([{
+      id: "u1",
+      name: "ada"
+    }]);
+    expect((_requests_at = requests.at(-1)) === null || _requests_at === void 0 ? void 0 : _requests_at.body.cookie).toBe(1);
+    projectView.destroy();
+    userView.destroy();
+  });
+  test("ping is answered locally and the stock Zero connection survives idle ping", async function () {
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      expect(request.path).toBe("/pull");
+      return jsonResponse({
+        cookie: request.body.cookie,
+        unchanged: true
+      });
+    });
+    var transport = install(fetch);
+    var zero = createZero({
+      pingTimeoutMs: 10
+    });
+    await eventually(function () {
+      return expect(zero.connection.state.current.name).toBe("connected");
+    });
+    await sleep(40);
+    expect(zero.connection.state.current.name).toBe("connected");
+    expect(transport.connections).toBe(1);
+  });
+  test("401 pull failure closes the fake socket without materializing data", async function () {
+    var requests = [];
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      requests.push(request);
+      expect(request.path).toBe("/pull");
+      return jsonResponse({
+        error: "unauthorized"
+      }, {
+        status: 401
+      });
+    });
+    var transport = install(fetch);
+    var zero = createZero();
+    var view = zero.query.project.materialize();
+    var emissions = [];
+    var cleanup = view.addListener(function (data, resultType) {
+      emissions.push({
+        data: JSON.parse(JSON.stringify(data)),
+        resultType
+      });
+    });
+    await eventually(function () {
+      return expect(requests.length).toBeGreaterThan(0);
+    });
+    await eventually(function () {
+      return expect(zero.connection.state.current.name).toBe("needs-auth");
+    });
+    await sleep(25);
+    expect(transport.connections).toBe(0);
+    expect(emissions.flatMap(function (emission) {
+      return emission.data;
+    })).toEqual([]);
+    expect(view.data).toEqual([]);
+    cleanup();
+    view.destroy();
+  });
+  test("non-origin WebSockets pass through to the native implementation", function () {
+    var previous = globalThis.WebSocket;
+    var NativeWebSocket = function NativeWebSocket2(url, protocols) {
+      "use strict";
+
+      _class_call_check(this, NativeWebSocket2);
+      _define_property(this, "url", void 0);
+      _define_property(this, "protocols", void 0);
+      this.url = url;
+      this.protocols = protocols;
+    };
+    _define_property(NativeWebSocket, "CONNECTING", 0);
+    _define_property(NativeWebSocket, "OPEN", 1);
+    _define_property(NativeWebSocket, "CLOSING", 2);
+    _define_property(NativeWebSocket, "CLOSED", 3);
+    globalThis.WebSocket = NativeWebSocket;
+    var transport = installHttpPullTransport({
+      origin: ORIGIN,
+      fetch: vi.fn()
+    });
+    var socket = new WebSocket("wss://elsewhere.local/socket", "native");
+    expect(socket).toBeInstanceOf(NativeWebSocket);
+    expect(socket.url).toBe("wss://elsewhere.local/socket");
+    transport.uninstall();
+    expect(globalThis.WebSocket).toBe(NativeWebSocket);
+    globalThis.WebSocket = previous;
+  });
+  test("ensureHttpPullTransport installs once per origin", function () {
+    var origin = "http://127.0.0.1:65501";
+    var first = ensureHttpPullTransport({
+      origin,
+      fetch: vi.fn()
+    });
+    var second = ensureHttpPullTransport({
+      origin,
+      fetch: vi.fn()
+    });
+    expect(second).toBe(first);
+    first.uninstall();
+  });
+  test("pull 409 (client cookie ahead of server) resets client state instead of reconnect-looping", async function () {
+    var fetch = vi.fn(async function (input, init) {
+      var request = recordRequest(input, init);
+      expect(request.path).toBe("/pull");
+      return jsonResponse({
+        error: "future cookie 299 is ahead of server cookie 66"
+      }, {
+        status: 409
+      });
+    });
+    install(fetch);
+    var onClientStateNotFound = vi.fn();
+    createZero({
+      onClientStateNotFound
+    });
+    await vi.waitFor(function () {
+      return expect(onClientStateNotFound).toHaveBeenCalled();
+    }, {
+      timeout: 5e3
+    });
+  });
+});
+function install(fetch) {
+  var transport = installHttpPullTransport({
+    origin: ORIGIN,
+    fetch
+  });
+  transports.push(transport);
+  return transport;
+}
+function createZero() {
+  var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var zero = new Zero({
+    server: ORIGIN,
+    userID: "u1",
+    auth: "token-u1",
+    schema: zeroHttpFixtureSchema,
+    kvStore: "mem",
+    storageKey: `zero-http-test-${++storageID}`,
+    mutators: zeroHttpFixtureMutators,
+    pingTimeoutMs: options.pingTimeoutMs,
+    onClientStateNotFound: options.onClientStateNotFound
+  });
+  zeros.push(zero);
+  return zero;
+}
+function recordRequest(input, init) {
+  var url = new URL(String(input));
+  var _init_headers;
+  var headers = Object.fromEntries(Object.entries((_init_headers = init === null || init === void 0 ? void 0 : init.headers) !== null && _init_headers !== void 0 ? _init_headers : {}).map(function (param) {
+    var [key, value] = param;
+    return [key.toLowerCase(), value];
+  }));
+  return {
+    url: url.toString(),
+    path: url.pathname,
+    headers,
+    body: (init === null || init === void 0 ? void 0 : init.body) ? JSON.parse(String(init.body)) : void 0
+  };
+}
+function jsonResponse(body, init) {
+  var _init_status;
+  return new Response(JSON.stringify(body), {
+    status: (_init_status = init === null || init === void 0 ? void 0 : init.status) !== null && _init_status !== void 0 ? _init_status : 200,
+    statusText: init === null || init === void 0 ? void 0 : init.statusText,
+    headers: {
+      "content-type": "application/json",
+      ...(init === null || init === void 0 ? void 0 : init.headers)
+    }
+  });
+}
+async function waitForComplete(view) {
+  return new Promise(function (resolve, reject) {
+    var timeout = setTimeout(function () {
+      return reject(new Error("timed out waiting for complete query"));
+    }, 5e3);
+    var cleanup = function () {};
+    cleanup = view.addListener(function (data, resultType) {
+      if (resultType !== "complete") return;
+      clearTimeout(timeout);
+      cleanup();
+      resolve(JSON.parse(JSON.stringify(data)));
+    });
+  });
+}
+async function eventually(assertion) {
+  var timeout = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1e3;
+  var started = Date.now();
+  var lastError;
+  while (Date.now() - started < timeout) {
+    try {
+      await assertion();
+      return;
+    } catch (error) {
+      lastError = error;
+      await sleep(10);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+}
+function openRawSocket() {
+  return openRawSocketWithMessages().messages;
+}
+function openRawSocketWithMessages(opts) {
+  var url = new URL(`${ORIGIN}/sync/v51/connect`);
+  url.protocol = "wss:";
+  url.searchParams.set("clientID", "c1");
+  url.searchParams.set("clientGroupID", "cg1");
+  url.searchParams.set("userID", "u1");
+  url.searchParams.set("baseCookie", "");
+  url.searchParams.set("lmid", "0");
+  url.searchParams.set("wsid", "ws-test");
+  var messages = [];
+  var _opts_desiredQueriesPatch, _opts_authToken;
+  var socket = new WebSocket(url, encodeSecProtocol(["initConnection", {
+    desiredQueriesPatch: (_opts_desiredQueriesPatch = opts === null || opts === void 0 ? void 0 : opts.desiredQueriesPatch) !== null && _opts_desiredQueriesPatch !== void 0 ? _opts_desiredQueriesPatch : []
+  }], (_opts_authToken = opts === null || opts === void 0 ? void 0 : opts.authToken) !== null && _opts_authToken !== void 0 ? _opts_authToken : "token-u1"));
+  socket.addEventListener("message", function (event) {
+    messages.push(JSON.parse(String(event.data)));
+  });
+  return {
+    messages,
+    socket
+  };
+}
+function pushBody(id) {
+  return {
+    clientGroupID: "cg1",
+    pushVersion: 1,
+    requestID: `push-${id}`,
+    timestamp: Date.now(),
+    mutations: [{
+      type: "custom",
+      name: "project|create",
+      id,
+      clientID: "c1",
+      args: [{
+        id: `p${id}`,
+        ownerId: "u1",
+        name: `project ${id}`
+      }]
+    }]
+  };
+}
+function findMessage(messages, type) {
+  var message = messages.find(function (item) {
+    return item[0] === type;
+  });
+  expect(message).toBeDefined();
+  return message;
+}
+function encodeSecProtocol(initConnectionMessage, authToken) {
+  return encodeURIComponent(Buffer.from(JSON.stringify({
+    initConnectionMessage,
+    authToken
+  })).toString("base64"));
+}
+function defer() {
+  var resolve;
+  var reject;
+  var promise = new Promise(function (res, rej) {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+//# sourceMappingURL=transport.test.native.js.map