@rocicorp/zero 0.24.2025091100 → 0.24.2025092400

package/out/{inspector-NC6TPMRA.js → lazy-inspector-TOTYUTBC.js}

@@ -1,4 +1,5 @@
 import {
+  Client,
   ENTITIES_KEY_PREFIX,
   Latest,
   SUBQ_PREFIX,
@@ -6,6 +7,8 @@ import {
   getClient,
   getClientGroup,
   getClients,
+  inspectAnalyzeQueryDownSchema,
+  inspectAuthenticatedDownSchema,
   inspectMetricsDownSchema,
   inspectQueriesDownSchema,
   inspectVersionDownSchema,
@@ -17,13 +20,88 @@ import {
   test,
   valita_exports,
   withRead
-} from "./chunk-MLYQCVBG.js";
+} from "./chunk-QZPMFA73.js";
 import {
   assert,
   unreachable
 } from "./chunk-SGW2EIVJ.js";
 import "./chunk-424PT5DM.js";
 
+// ../zero-client/src/client/inspector/html-dialog-prompt.ts
+function canUseHTMLDialog() {
+  try {
+    if (typeof globalThis !== "undefined" && "__vitest_worker__" in globalThis) {
+      return false;
+    }
+    return typeof document !== "undefined" && typeof document.createElement === "function" && typeof HTMLDialogElement !== "undefined" && document.body !== null && // Make sure we can actually create a dialog element
+    document.createElement("dialog") instanceof HTMLDialogElement;
+  } catch {
+    return false;
+  }
+}
+function createHTMLPasswordPrompt(message) {
+  if (!canUseHTMLDialog()) {
+    return Promise.resolve(prompt(message));
+  }
+  return new Promise((resolve) => {
+    const reset = "all:revert;";
+    const w = "rgba(255,255,255,";
+    const white = w + "1)";
+    const whiteTransp = w + "0.4)";
+    const r1 = "0.25rem";
+    const font = `font-family:system-ui,sans-serif;color:${white};`;
+    const btnBase = `${reset}${font}cursor:pointer;font-size:1rem;font-weight:500;border:none;padding:0.4rem 0.75rem;border-radius:${r1};background:`;
+    const dialog = document.createElement("dialog");
+    dialog.style.cssText = `${reset}${font}background:rgba(0,0,0,0.95);padding:2rem;border:1px solid ${whiteTransp};border-radius:0.5rem;`;
+    dialog.addEventListener("keydown", (e) => {
+      e.stopPropagation();
+    });
+    dialog.oncancel = () => {
+      dialog.remove();
+      resolve(null);
+    };
+    const form = document.createElement("form");
+    form.method = "dialog";
+    form.style.cssText = `${reset}margin:0;`;
+    const messagePara = document.createElement("p");
+    messagePara.style.cssText = `${reset}${font}font-size:1.5rem;margin:0 0 1rem 0;`;
+    messagePara.append(message);
+    const passwordInput = document.createElement("input");
+    passwordInput.type = "password";
+    passwordInput.placeholder = "Admin password";
+    passwordInput.autocomplete = "current-password";
+    passwordInput.autofocus = true;
+    passwordInput.style.cssText = `${reset}${font}font-size:1rem;display:block;margin:0 0 1rem 0;padding:0.5rem;background:rgba(0,0,0,0.5);border:1px solid ${whiteTransp};border-radius:${r1};`;
+    const buttonDiv = document.createElement("div");
+    buttonDiv.style.cssText = reset;
+    const cancelBtn = document.createElement("button");
+    cancelBtn.type = "reset";
+    cancelBtn.append("Cancel");
+    cancelBtn.style.cssText = btnBase + w + "0.25);";
+    const okBtn = document.createElement("button");
+    okBtn.type = "submit";
+    okBtn.value = "ok";
+    okBtn.append("OK");
+    okBtn.style.cssText = btnBase + "rgba(19,106,235,1);margin-right:0.5rem;";
+    buttonDiv.append(okBtn, cancelBtn);
+    form.append(messagePara, passwordInput, buttonDiv);
+    dialog.append(form);
+    form.onreset = () => {
+      dialog.close();
+    };
+    dialog.onclose = () => {
+      if (dialog.returnValue === "ok") {
+        resolve(passwordInput.value || null);
+      } else {
+        resolve(null);
+      }
+      dialog.remove();
+    };
+    document.body.append(dialog);
+    dialog.showModal();
+  });
+}
+
 // ../ast-to-zql/src/ast-to-zql.ts
 function astToZQL(ast) {
   let code = "";
@@ -194,72 +272,101 @@ function transformParameter(param) {
   return `authParam(${fieldStr})`;
 }
 
-// ../zero-client/src/client/inspector/inspector.ts
-async function newInspector(rep, delegate, schema, socket) {
-  const clientGroupID = await rep.clientGroupID;
-  return new Inspector(
-    rep,
-    delegate,
-    schema,
-    rep.clientID,
-    clientGroupID,
-    socket
-  );
-}
-var Inspector = class {
-  #rep;
-  client;
-  clientGroup;
-  #schema;
-  socket;
-  #delegate;
-  constructor(rep, delegate, schema, clientID, clientGroupID, socket) {
-    this.#rep = rep;
-    this.#schema = schema;
-    this.client = new Client(
-      rep,
-      delegate,
-      schema,
-      socket,
-      clientID,
-      clientGroupID
-    );
-    this.clientGroup = this.client.clientGroup;
-    this.socket = socket;
-    this.#delegate = delegate;
-  }
-  async metrics() {
-    const clientMetrics = this.#delegate.metrics;
-    const serverMetricsJSON = await rpc(
-      await this.socket(),
-      { op: "metrics" },
-      inspectMetricsDownSchema
-    );
-    return mergeMetrics(clientMetrics, serverMetricsJSON);
-  }
-  clients() {
-    return withDagRead(
-      this.#rep,
-      (dagRead) => clients(this.#rep, this.#delegate, this.socket, this.#schema, dagRead)
-    );
-  }
-  clientsWithQueries() {
-    return withDagRead(
-      this.#rep,
-      (dagRead) => clientsWithQueries(
-        this.#rep,
-        this.#delegate,
-        this.socket,
-        this.#schema,
-        dagRead
-      )
+// ../zero-client/src/client/inspector/query.ts
+var Query = class {
+  #socket;
+  name;
+  args;
+  got;
+  ttl;
+  inactivatedAt;
+  rowCount;
+  deleted;
+  id;
+  clientID;
+  metrics;
+  clientZQL;
+  serverZQL;
+  #serverAST;
+  hydrateClient;
+  hydrateServer;
+  hydrateTotal;
+  updateClientP50;
+  updateClientP95;
+  updateServerP50;
+  updateServerP95;
+  constructor(row, delegate, socket) {
+    this.#socket = socket;
+    const { ast, queryID, inactivatedAt } = row;
+    this.clientID = row.clientID;
+    this.id = queryID;
+    this.inactivatedAt = inactivatedAt === null ? null : new Date(inactivatedAt);
+    this.ttl = normalizeTTL(row.ttl);
+    this.name = row.name;
+    this.args = row.args;
+    this.got = row.got;
+    this.rowCount = row.rowCount;
+    this.deleted = row.deleted;
+    this.#serverAST = ast;
+    this.serverZQL = ast ? ast.table + astToZQL(ast) : null;
+    const clientAST = delegate.getAST(queryID);
+    this.clientZQL = clientAST ? clientAST.table + astToZQL(clientAST) : null;
+    const clientMetrics = delegate.getQueryMetrics(queryID);
+    const serverMetrics = row.metrics;
+    const merged = mergeMetrics(clientMetrics, serverMetrics);
+    this.metrics = merged;
+    const percentile = (name, percentile2) => {
+      if (!merged?.[name]) {
+        return null;
+      }
+      const n = merged[name].quantile(percentile2);
+      return Number.isNaN(n) ? null : n;
+    };
+    this.hydrateClient = percentile("query-materialization-client", 0.5);
+    this.hydrateServer = percentile("query-materialization-server", 0.5);
+    this.hydrateTotal = percentile("query-materialization-end-to-end", 0.5);
+    this.updateClientP50 = percentile("query-update-client", 0.5);
+    this.updateClientP95 = percentile("query-update-client", 0.95);
+    this.updateServerP50 = percentile("query-update-server", 0.5);
+    this.updateServerP95 = percentile("query-update-server", 0.95);
+  }
+  async analyze(options) {
+    assert(this.#serverAST, "No server AST available for this query");
+    return rpc(
+      await this.#socket(),
+      {
+        op: "analyze-query",
+        value: this.#serverAST,
+        options
+      },
+      inspectAnalyzeQueryDownSchema
     );
   }
-  async serverVersion() {
-    return rpc(await this.socket(), { op: "version" }, inspectVersionDownSchema);
-  }
 };
-function rpc(socket, arg, downSchema) {
+
+// ../zero-client/src/client/inspector/lazy-inspector.ts
+async function rpc(socket, arg, downSchema) {
+  try {
+    return await rpcNoAuthTry(socket, arg, downSchema);
+  } catch (e) {
+    if (e instanceof UnauthenticatedError) {
+      const password = await createHTMLPasswordPrompt("Enter password:");
+      if (password) {
+        const authRes = await rpcNoAuthTry(
+          socket,
+          { op: "authenticate", value: password },
+          inspectAuthenticatedDownSchema
+        );
+        if (authRes) {
+          return rpcNoAuthTry(socket, arg, downSchema);
+        }
+      }
+      throw new Error("Authentication failed");
+    }
+    throw e;
+  }
+}
+function rpcNoAuthTry(socket, arg, downSchema) {
   return new Promise((resolve, reject) => {
     const id = nanoid();
     const f = (ev) => {
@@ -273,118 +380,65 @@ function rpc(socket, arg, downSchema) {
         if (res.ok) {
           resolve(res.value.value);
         } else {
+          const authRes = test(body, inspectAuthenticatedDownSchema);
+          if (authRes.ok) {
+            assert(
+              authRes.value.value === false,
+              "Expected unauthenticated response"
+            );
+            reject(new UnauthenticatedError());
+          }
           reject(res.error);
         }
         socket.removeEventListener("message", f);
       }
     };
     socket.addEventListener("message", f);
-    socket.send(
-      JSON.stringify(["inspect", { ...arg, id }])
-    );
+    socket.send(JSON.stringify(["inspect", { ...arg, id }]));
   });
 }
-var Client = class {
-  #rep;
-  id;
-  clientGroup;
-  #socket;
-  #delegate;
-  constructor(rep, delegate, schema, socket, id, clientGroupID) {
-    this.#rep = rep;
-    this.#socket = socket;
-    this.id = id;
-    this.clientGroup = new ClientGroup(
-      rep,
-      delegate,
-      socket,
-      schema,
-      clientGroupID
-    );
-    this.#delegate = delegate;
-  }
-  async queries() {
-    const rows = await rpc(
-      await this.#socket(),
-      { op: "queries", clientID: this.id },
-      inspectQueriesDownSchema
-    );
-    return rows.map((row) => new Query(row, this.#delegate));
-  }
-  map() {
-    return withDagRead(this.#rep, async (dagRead) => {
-      const tree = await getBTree(dagRead, this.id);
-      const map = /* @__PURE__ */ new Map();
-      for await (const [key, value] of tree.scan("")) {
-        map.set(key, value);
-      }
-      return map;
-    });
-  }
-  rows(tableName) {
-    return withDagRead(this.#rep, async (dagRead) => {
-      const prefix = ENTITIES_KEY_PREFIX + tableName;
-      const tree = await getBTree(dagRead, this.id);
-      const rows = [];
-      for await (const [key, value] of tree.scan(prefix)) {
-        if (!key.startsWith(prefix)) {
-          break;
-        }
-        rows.push(value);
-      }
-      return rows;
-    });
-  }
-};
-var ClientGroup = class {
-  #rep;
-  id;
-  #schema;
-  #socket;
-  #delegate;
-  constructor(rep, delegate, socket, schema, id) {
-    this.#rep = rep;
-    this.#delegate = delegate;
-    this.#socket = socket;
-    this.#schema = schema;
-    this.id = id;
-  }
-  clients() {
-    return withDagRead(
-      this.#rep,
-      (dagRead) => clients(
-        this.#rep,
-        this.#delegate,
-        this.#socket,
-        this.#schema,
-        dagRead,
-        ([_, v]) => v.clientGroupID === this.id
-      )
-    );
-  }
-  clientsWithQueries() {
-    return withDagRead(
-      this.#rep,
-      (dagRead) => clientsWithQueries(
-        this.#rep,
-        this.#delegate,
-        this.#socket,
-        this.#schema,
-        dagRead,
-        ([_, v]) => v.clientGroupID === this.id
-      )
-    );
-  }
-  async queries() {
-    const rows = await rpc(
-      await this.#socket(),
-      { op: "queries" },
-      inspectQueriesDownSchema
-    );
-    return rows.map((row) => new Query(row, this.#delegate));
-  }
-};
-async function withDagRead(rep, f) {
+function mergeMetrics(clientMetrics, serverMetrics) {
+  return {
+    ...clientMetrics ?? newClientMetrics(),
+    ...serverMetrics ? convertServerMetrics(serverMetrics) : newServerMetrics()
+  };
+}
+function newClientMetrics() {
+  return {
+    "query-materialization-client": new TDigest(),
+    "query-materialization-end-to-end": new TDigest(),
+    "query-update-client": new TDigest()
+  };
+}
+function newServerMetrics() {
+  return {
+    "query-materialization-server": new TDigest(),
+    "query-update-server": new TDigest()
+  };
+}
+function convertServerMetrics(metrics) {
+  return mapValues(metrics, (v) => TDigest.fromJSON(v));
+}
+async function inspectorMetrics(delegate) {
+  const clientMetrics = delegate.metrics;
+  const serverMetricsJSON = await rpc(
+    await delegate.getSocket(),
+    { op: "metrics" },
+    inspectMetricsDownSchema
+  );
+  return mergeMetrics(clientMetrics, serverMetricsJSON);
+}
+function inspectorClients(delegate) {
+  return withDagRead(delegate, (dagRead) => clients(delegate, dagRead));
+}
+function inspectorClientsWithQueries(delegate) {
+  return withDagRead(
+    delegate,
+    (dagRead) => clientsWithQueries(delegate, dagRead)
+  );
+}
+async function withDagRead(delegate, f) {
+  const { rep } = delegate;
   await rep.refresh();
   await rep.persist();
   return withRead(rep.perdag, f);
@@ -402,21 +456,14 @@ async function getBTree(dagRead, clientID) {
   );
   return dbRead.map;
 }
-async function clients(rep, delegate, socket, schema, dagRead, predicate = () => true) {
+async function clients(delegate, dagRead, predicate = () => true) {
   const clients2 = await getClients(dagRead);
   return [...clients2.entries()].filter(predicate).map(
-    ([clientID, { clientGroupID }]) => new Client(rep, delegate, schema, socket, clientID, clientGroupID)
+    ([clientID, { clientGroupID }]) => new Client(delegate, clientID, clientGroupID)
   );
 }
-async function clientsWithQueries(rep, delegate, socket, schema, dagRead, predicate = () => true) {
-  const allClients = await clients(
-    rep,
-    delegate,
-    socket,
-    schema,
-    dagRead,
-    predicate
-  );
+async function clientsWithQueries(delegate, dagRead, predicate = () => true) {
+  const allClients = await clients(delegate, dagRead, predicate);
   const clientsWithQueries2 = [];
   await Promise.all(
     allClients.map(async (client) => {
@@ -428,61 +475,81 @@ async function clientsWithQueries(rep, delegate, socket, schema, dagRead, predic
   );
   return clientsWithQueries2;
 }
-var Query = class {
-  name;
-  args;
-  got;
-  ttl;
-  inactivatedAt;
-  rowCount;
-  deleted;
-  id;
-  clientID;
-  metrics;
-  clientZQL;
-  serverZQL;
-  constructor(row, delegate) {
-    const { ast, queryID, inactivatedAt } = row;
-    this.clientID = row.clientID;
-    this.id = queryID;
-    this.inactivatedAt = inactivatedAt === null ? null : new Date(inactivatedAt);
-    this.ttl = normalizeTTL(row.ttl);
-    this.name = row.name;
-    this.args = row.args;
-    this.got = row.got;
-    this.rowCount = row.rowCount;
-    this.deleted = row.deleted;
-    this.serverZQL = ast ? ast.table + astToZQL(ast) : null;
-    const clientAST = delegate.getAST(queryID);
-    this.clientZQL = clientAST ? clientAST.table + astToZQL(clientAST) : null;
-    const clientMetrics = delegate.getQueryMetrics(queryID);
-    const serverMetrics = row.metrics;
-    this.metrics = mergeMetrics(clientMetrics, serverMetrics);
-  }
-};
-function mergeMetrics(clientMetrics, serverMetrics) {
-  return {
-    ...clientMetrics ?? newClientMetrics(),
-    ...serverMetrics ? convertServerMetrics(serverMetrics) : newServerMetrics()
-  };
+async function clientGroupClients(delegate, clientGroupID) {
+  const id = await clientGroupID;
+  return withDagRead(
+    delegate,
+    (dagRead) => clients(delegate, dagRead, ([_, v]) => v.clientGroupID === id)
+  );
 }
-function newClientMetrics() {
-  return {
-    "query-materialization-client": new TDigest(),
-    "query-materialization-end-to-end": new TDigest(),
-    "query-update-client": new TDigest()
-  };
+async function clientGroupClientsWithQueries(delegate, clientGroupID) {
+  const id = await clientGroupID;
+  return withDagRead(
+    delegate,
+    (dagRead) => clientsWithQueries(delegate, dagRead, ([_, v]) => v.clientGroupID === id)
+  );
 }
-function newServerMetrics() {
-  return {
-    "query-materialization-server": new TDigest(),
-    "query-update-server": new TDigest()
-  };
+async function clientGroupQueries(delegate) {
+  const rows = await rpc(
+    await delegate.getSocket(),
+    { op: "queries" },
+    inspectQueriesDownSchema
+  );
+  return rows.map((row) => new Query(row, delegate, delegate.getSocket));
 }
-function convertServerMetrics(metrics) {
-  return mapValues(metrics, (v) => TDigest.fromJSON(v));
+function clientMap(delegate, clientID) {
+  return withDagRead(delegate, async (dagRead) => {
+    const tree = await getBTree(dagRead, clientID);
+    const map = /* @__PURE__ */ new Map();
+    for await (const [key, value] of tree.scan("")) {
+      map.set(key, value);
+    }
+    return map;
+  });
+}
+function clientRows(delegate, clientID, tableName) {
+  return withDagRead(delegate, async (dagRead) => {
+    const prefix = ENTITIES_KEY_PREFIX + tableName + "/";
+    const tree = await getBTree(dagRead, clientID);
+    const rows = [];
+    for await (const [key, value] of tree.scan(prefix)) {
+      if (!key.startsWith(prefix)) {
+        break;
+      }
+      rows.push(value);
+    }
+    return rows;
+  });
 }
+async function serverVersion(delegate) {
+  return rpc(
+    await delegate.getSocket(),
+    { op: "version" },
+    inspectVersionDownSchema
+  );
+}
+async function clientQueries(delegate, clientID) {
+  const rows = await rpc(
+    await delegate.getSocket(),
+    { op: "queries", clientID },
+    inspectQueriesDownSchema
+  );
+  return rows.map((row) => new Query(row, delegate, delegate.getSocket));
+}
+var UnauthenticatedError = class extends Error {
+};
 export {
-  newInspector
+  clientGroupClients,
+  clientGroupClientsWithQueries,
+  clientGroupQueries,
+  clientMap,
+  clientQueries,
+  clientRows,
+  inspectorClients,
+  inspectorClientsWithQueries,
+  inspectorMetrics,
+  mergeMetrics,
+  rpc,
+  serverVersion
 };
-//# sourceMappingURL=inspector-NC6TPMRA.js.map
+//# sourceMappingURL=lazy-inspector-TOTYUTBC.js.map