on-zero 0.4.26 → 0.4.28

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));
+}