on-zero 0.7.2-1784530701923 → 0.7.2

package/dist/cjs/httpPull/completeAck.test.native.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var import_vitest = require("vitest");
+var import_testHarness = require("./testHarness.native.js");
+var harness;
+(0, import_vitest.afterEach)(async function () {
+  await (harness === null || harness === void 0 ? void 0 : harness.close());
+  harness = void 0;
+});
+(0, import_vitest.test)("query desired before first connect reaches complete", async function () {
+  harness = await (0, import_testHarness.startZeroHttpHarness)({
+    seed: {
+      user: [{
+        id: "u1",
+        name: "ada"
+      }]
+    }
+  });
+  var zero = harness.createZero("u1");
+  var view = zero.query.user.materialize();
+  var rows = await (0, import_testHarness.waitForComplete)(view);
+  (0, import_vitest.expect)(rows).toEqual([{
+    id: "u1",
+    name: "ada"
+  }]);
+  view.destroy();
+});
+(0, import_vitest.test)("existing + new queries reach complete again after a transport drop", async function () {
+  var failNextPull = false;
+  harness = await (0, import_testHarness.startZeroHttpHarness)({
+    seed: {
+      user: [{
+        id: "u1",
+        name: "ada"
+      }],
+      project: [{
+        id: "p1",
+        ownerId: "u1",
+        name: "first"
+      }]
+    },
+    interceptFetch: function (next) {
+      return function (input, init) {
+        var url = String(input);
+        if (failNextPull && url.endsWith("/pull")) {
+          failNextPull = false;
+          return Promise.reject(new Error("injected transient pull failure"));
+        }
+        return next(input, init);
+      };
+    }
+  });
+  var zero = harness.createZero("u1");
+  var userView = zero.query.user.materialize();
+  await (0, import_testHarness.waitForComplete)(userView);
+  failNextPull = true;
+  await harness.transport.pull().catch(function () {});
+  var mutation = zero.mutate.project.create({
+    id: "p2",
+    ownerId: "u1",
+    name: "second"
+  });
+  await mutation.client;
+  await mutation.server.catch(function () {});
+  var userAgain = zero.query.user.materialize();
+  await (0, import_testHarness.waitForComplete)(userAgain);
+  var projectView = zero.query.project.materialize();
+  var projects = await (0, import_testHarness.waitForComplete)(projectView);
+  (0, import_vitest.expect)(projects.map(function (p) {
+    return p.id;
+  }).sort()).toEqual(["p1", "p2"]);
+  userView.destroy();
+  userAgain.destroy();
+  projectView.destroy();
+});
+//# sourceMappingURL=completeAck.test.native.js.map

package/dist/cjs/httpPull/completeAck.test.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["import_vitest","require","import_testHarness","harness","afterEach","close","test","startZeroHttpHarness","seed","user","id","name","zero","createZero","view","query","materialize","rows","waitForComplete","expect","toEqual","destroy","failNextPull","project","ownerId","interceptFetch","next","input","init","url","String","endsWith"],"sources":["../../../src/httpPull/completeAck.test.ts"],"sourcesContent":[null],"mappings":"AAAA;;AAEA,IAAAA,aAAA,GAAAC,OAKO;AAOP,IAAIC,kBAAA,GAAAD,OAAA;AAAA,IAEJE,OAAA;AACE,IAAAH,aAAe,CAAAI,SAAM;EACrB,OAAAD,OAAU,aAAAA,OAAA,uBAAAA,OAAA,CAAAE,KAAA;EACXF,OAAA;AAAA;AAGC,IAAAH,aAAU,CAAAM,IAAM,uDAAqB;EAAAH,OACnC,GAAQ,MAAM,CAAC,GAAED,kBAAgB,CAAAK,oBAAS;IAC3CC,IAAA;MACDC,IAAM,GAGA;QACAC,EAAA,MAAO;QACbC,IAAA;MACK;IAGP;EACE;EACA,IAAAC,IAAA,GAAUT,OAAA,CAAAU,UAAM;EAAqB,IACnCC,IAAM,GAAAF,IAAA,CAAAG,KAAA,CAAAN,IAAA,CAAAO,WAAA;EAAA,IACJC,IAAA,GAAO,MAAM,IAAAf,kBAAmB,CAAAgB,eAAA,EAAAJ,IAAA;EAAA,IAChCd,aAAY,CAAAmB,MAAI,EAAMF,IAAA,EAAAG,OAAS,EACjC;IACAV,EAAA;IACEC,IAAA,EAAM;EACN,EACE;EACAG,IAAA,CAAAO,OAAA,CAAO;AAA2D;AAEpE,IAAArB,aAAO,CAAKM,IAAA,sEAAW;EAAA,IACzBgB,YAAA;EACFnB,OAAC,aAAAD,kBAAA,CAAAK,oBAAA;IACDC,IAAM;MAENC,IAAM,GACN;QAIAC,EAAA,MAAe;QACTC,IAAA,EAAQ;MAA+B,EAG7C;MACAY,OAAM,GACA;QAA8Bb,EAAA;QAK9Bc,OAAA,MAAY;QAClBb,IAAM;MAGA;IAEN;IAEAc,cAAS,EAAQ,SAAAA,CAAAC,IAAA;MACjB,OAAU,UAAQC,KAAA,EAAAC,IAAA;QAClB,IAAAC,GAAY,GAAAC,MAAQ,CAAAH,KAAA;QACrB,IAAAL,YAAA,IAAAO,GAAA,CAAAE,QAAA","ignoreList":[]}

package/dist/cjs/httpPull/fixtureServer.cjs

@@ -0,0 +1,340 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var fixtureServer_exports = {};
+__export(fixtureServer_exports, {
+  startZeroHttpServer: () => startZeroHttpServer
+});
+module.exports = __toCommonJS(fixtureServer_exports);
+var import_node_http = require("node:http");
+const tableNames = ["user", "project", "member"];
+async function startZeroHttpServer(opts) {
+  const tables = seedTables(opts?.seed);
+  const lmids = /* @__PURE__ */new Map();
+  const mutationResults = /* @__PURE__ */new Map();
+  const clientGroupUsers = /* @__PURE__ */new Map();
+  let cookie = 1;
+  const server = (0, import_node_http.createServer)(async (req, res) => {
+    try {
+      if (req.method !== "POST") {
+        sendJSON(res, 404, {
+          error: "not found"
+        });
+        return;
+      }
+      const path = new URL(req.url || "/", "http://127.0.0.1").pathname;
+      const userID = authenticate(req, tables);
+      if (!userID) {
+        sendJSON(res, 401, {
+          error: "unauthorized"
+        });
+        return;
+      }
+      if (path === "/pull") {
+        const body = await readJSON(req);
+        if (!bindClientGroup(clientGroupUsers, body.clientGroupID, userID)) {
+          sendJSON(res, 403, {
+            error: "client group belongs to a different user"
+          });
+          return;
+        }
+        if (body.cookie === cookie) {
+          sendJSON(res, 200, {
+            cookie,
+            unchanged: true
+          });
+          return;
+        }
+        if (typeof body.cookie === "number" && body.cookie > cookie) {
+          sendJSON(res, 409, {
+            error: `future cookie ${body.cookie} is ahead of server cookie ${cookie}`
+          });
+          return;
+        }
+        sendJSON(res, 200, {
+          cookie,
+          lastMutationIDChanges: lastMutationIDChanges(lmids, body.clientGroupID),
+          rowsPatch: [{
+            op: "clear"
+          }, ...visibleRowsPatch(tables, userID)]
+        });
+        return;
+      }
+      if (path === "/push") {
+        const body = await readJSON(req);
+        if (!bindClientGroup(clientGroupUsers, body.clientGroupID, userID)) {
+          sendJSON(res, 403, {
+            error: "client group belongs to a different user"
+          });
+          return;
+        }
+        const mutations = Array.isArray(body.mutations) ? body.mutations : [];
+        const gap = findMutationGap(lmids, body.clientGroupID, mutations);
+        if (gap) {
+          sendJSON(res, 500, {
+            error: gap
+          });
+          return;
+        }
+        const pushResults = [];
+        let processedNewMutation = false;
+        for (const mutation of mutations) {
+          const current = lmidFor(lmids, body.clientGroupID, mutation.clientID);
+          if (mutation.id <= current) {
+            pushResults.push({
+              id: {
+                clientID: mutation.clientID,
+                id: mutation.id
+              },
+              result: resultForMutation(mutationResults, body.clientGroupID, mutation.clientID, mutation.id) || {}
+            });
+            continue;
+          }
+          const result = applyMutation(tables, userID, mutation);
+          setLMID(lmids, body.clientGroupID, mutation.clientID, mutation.id);
+          setMutationResult(mutationResults, body.clientGroupID, mutation.clientID, mutation.id, result);
+          processedNewMutation = true;
+          pushResults.push({
+            id: {
+              clientID: mutation.clientID,
+              id: mutation.id
+            },
+            result
+          });
+        }
+        if (processedNewMutation) cookie += 1;
+        sendJSON(res, 200, {
+          pushResponse: {
+            mutations: pushResults
+          }
+        });
+        return;
+      }
+      sendJSON(res, 404, {
+        error: "not found"
+      });
+    } catch (err) {
+      sendJSON(res, 500, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  return {
+    url: `http://127.0.0.1:${address.port}`,
+    version: () => cookie,
+    rows: table => rowsForTable(tables, table),
+    close: () => new Promise((resolve, reject) => {
+      server.close(err => err ? reject(err) : resolve());
+    })
+  };
+}
+function seedTables(seed) {
+  const tables = {
+    user: /* @__PURE__ */new Map(),
+    project: /* @__PURE__ */new Map(),
+    member: /* @__PURE__ */new Map()
+  };
+  for (const table of tableNames) {
+    for (const row of seed?.[table] || []) {
+      if (typeof row.id === "string") tables[table].set(row.id, cloneRow(row));
+    }
+  }
+  return tables;
+}
+function authenticate(req, tables) {
+  const header = req.headers.authorization;
+  if (!header?.startsWith("Bearer token-")) return null;
+  const userID = header.slice("Bearer token-".length);
+  return tables.user.has(userID) ? userID : null;
+}
+function bindClientGroup(clientGroupUsers, clientGroupID, userID) {
+  const owner = clientGroupUsers.get(clientGroupID);
+  if (owner) return owner === userID;
+  clientGroupUsers.set(clientGroupID, userID);
+  return true;
+}
+function visibleRowsPatch(tables, userID) {
+  const visibleProjectIDs = visibleProjectIDSet(tables, userID);
+  const rows = [];
+  const user = tables.user.get(userID);
+  if (user) rows.push({
+    op: "put",
+    tableName: "user",
+    value: cloneRow(user)
+  });
+  for (const project of tables.project.values()) {
+    if (visibleProjectIDs.has(project.id)) {
+      rows.push({
+        op: "put",
+        tableName: "project",
+        value: cloneRow(project)
+      });
+    }
+  }
+  for (const member of tables.member.values()) {
+    if (visibleProjectIDs.has(member.projectId)) {
+      rows.push({
+        op: "put",
+        tableName: "member",
+        value: cloneRow(member)
+      });
+    }
+  }
+  return rows;
+}
+function visibleProjectIDSet(tables, userID) {
+  const projectIDs = /* @__PURE__ */new Set();
+  for (const project of tables.project.values()) {
+    if (project.ownerId === userID) projectIDs.add(project.id);
+  }
+  for (const member of tables.member.values()) {
+    if (member.userId === userID && tables.project.has(member.projectId)) {
+      projectIDs.add(member.projectId);
+    }
+  }
+  return projectIDs;
+}
+function findMutationGap(lmids, clientGroupID, mutations) {
+  const nextLMIDs = /* @__PURE__ */new Map();
+  for (const mutation of mutations) {
+    const current = nextLMIDs.get(mutation.clientID) ?? lmidFor(lmids, clientGroupID, mutation.clientID);
+    if (mutation.id <= current) continue;
+    if (mutation.id !== current + 1) {
+      return `mutation id gap for ${mutation.clientID}: got ${mutation.id}, expected ${current + 1}`;
+    }
+    nextLMIDs.set(mutation.clientID, mutation.id);
+  }
+  return null;
+}
+function applyMutation(tables, userID, mutation) {
+  if (mutation.type !== "custom") return appError("unsupported");
+  const args = mutation.args[0] || {};
+  if (mutation.name === "project|create") {
+    if (tables.project.has(args.id)) return appError("exists");
+    if (args.ownerId !== userID) return appError("forbidden");
+    tables.project.set(args.id, {
+      id: args.id,
+      ownerId: args.ownerId,
+      name: args.name
+    });
+    return {};
+  }
+  if (mutation.name === "project|rename") {
+    const project = tables.project.get(args.id);
+    if (!project) return appError("not-found");
+    if (project.ownerId !== userID) return appError("forbidden");
+    tables.project.set(args.id, {
+      ...project,
+      name: args.name
+    });
+    return {};
+  }
+  if (mutation.name === "member|add") {
+    const project = tables.project.get(args.projectId);
+    if (!project) return appError("not-found");
+    if (project.ownerId !== userID) return appError("forbidden");
+    if (tables.member.has(args.id)) return appError("exists");
+    tables.member.set(args.id, {
+      id: args.id,
+      projectId: args.projectId,
+      userId: args.userId
+    });
+    return {};
+  }
+  if (mutation.name === "member|remove") {
+    const member = tables.member.get(args.id);
+    if (!member) return appError("not-found");
+    const project = tables.project.get(member.projectId);
+    if (!project) return appError("not-found");
+    if (project.ownerId !== userID) return appError("forbidden");
+    tables.member.delete(args.id);
+    return {};
+  }
+  return appError("unsupported");
+}
+function appError(details) {
+  return {
+    error: "app",
+    details
+  };
+}
+function lastMutationIDChanges(lmids, clientGroupID) {
+  return Object.fromEntries(lmids.get(clientGroupID) || []);
+}
+function lmidFor(lmids, clientGroupID, clientID) {
+  return lmids.get(clientGroupID)?.get(clientID) || 0;
+}
+function setLMID(lmids, clientGroupID, clientID, id) {
+  let group = lmids.get(clientGroupID);
+  if (!group) {
+    group = /* @__PURE__ */new Map();
+    lmids.set(clientGroupID, group);
+  }
+  group.set(clientID, id);
+}
+function resultForMutation(results, clientGroupID, clientID, id) {
+  return results.get(clientGroupID)?.get(clientID)?.get(id);
+}
+function setMutationResult(results, clientGroupID, clientID, id, result) {
+  let group = results.get(clientGroupID);
+  if (!group) {
+    group = /* @__PURE__ */new Map();
+    results.set(clientGroupID, group);
+  }
+  let client = group.get(clientID);
+  if (!client) {
+    client = /* @__PURE__ */new Map();
+    group.set(clientID, client);
+  }
+  client.set(id, result);
+}
+function rowsForTable(tables, table) {
+  if (!isTableName(table)) return [];
+  return [...tables[table].values()].map(cloneRow);
+}
+function isTableName(table) {
+  return tableNames.includes(table);
+}
+function cloneRow(row) {
+  return {
+    ...row
+  };
+}
+async function readJSON(req) {
+  let body = "";
+  for await (const chunk of req) body += chunk;
+  return body ? JSON.parse(body) : {};
+}
+function sendJSON(res, status, body) {
+  res.writeHead(status, {
+    "content-type": "application/json"
+  });
+  res.end(JSON.stringify(body));
+}