@rocicorp/zero 0.18.2025032400 → 0.18.2025032800

package/out/{inspector-ROITQB3J.js → inspector-SH2ZK7O3.js}

@@ -2,21 +2,22 @@ import {
   ENTITIES_KEY_PREFIX,
   Latest,
   SUBQ_PREFIX,
-  astSchema,
   clientToServer,
-  desiredQueriesPrefixForClient,
   getClient,
   getClientGroup,
-  getClientGroups,
   getClients,
-  parse,
+  inspectQueriesDownSchema,
+  nanoid,
   readFromHash,
-  toGotQueriesKey,
+  readonly,
+  test,
   valita_exports,
   withRead,
   zip
-} from "./chunk-DSUPSGE4.js";
-import "./chunk-2B2QE5AT.js";
+} from "./chunk-NBZURO2P.js";
+import {
+  normalizeTTL
+} from "./chunk-MB3DEFRC.js";
 import {
   assert,
   must,
@@ -185,21 +186,111 @@ function transformParameter(param) {
 }
 
 // ../z2s/src/sql.ts
-import baseSql from "@databases/sql";
+import baseSql, { SQLItemType } from "@databases/sql/web";
 import {
   escapePostgresIdentifier,
   escapeSQLiteIdentifier
 } from "@databases/escape-identifier";
-var pgFormat = {
-  escapeIdentifier: (str) => escapePostgresIdentifier(str),
-  formatValue: (value, index) => ({ placeholder: `$${index + 1}`, value })
-};
 function formatPg(sql2) {
-  return sql2.format(pgFormat);
+  const format = new ReusingFormat(escapePostgresIdentifier);
+  return sql2.format((items) => formatFn(items, format));
+}
+var sqlConvert = Symbol("fromJson");
+function sqlConvertArg(type, value, plural) {
+  return sql.value({ [sqlConvert]: true, type, value, plural });
+}
+function sqlConvertArgUnsafe(type, value, plural) {
+  return sqlConvertArg(type, value, plural);
 }
+var ReusingFormat = class {
+  #seen = /* @__PURE__ */ new Map();
+  escapeIdentifier;
+  constructor(escapeIdentifier) {
+    this.escapeIdentifier = escapeIdentifier;
+  }
+  formatValue = (value) => {
+    if (this.#seen.has(value)) {
+      return {
+        placeholder: `$${this.#seen.get(value)}`,
+        value: PREVIOUSLY_SEEN_VALUE
+      };
+    }
+    this.#seen.set(value, this.#seen.size + 1);
+    return { placeholder: `$${this.#seen.size}`, value };
+  };
+};
 var sql = baseSql.default;
+var PREVIOUSLY_SEEN_VALUE = Symbol("PREVIOUSLY_SEEN_VALUE");
+function formatFn(items, { escapeIdentifier, formatValue }) {
+  let text = "";
+  const values = [];
+  const localIdentifiers = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    switch (item.type) {
+      // If this is just raw text, we add it directly to the query text.
+      case SQLItemType.RAW: {
+        text += item.text;
+        break;
+      }
+      // If we got a value SQL item, add a placeholder and add the value to our
+      // placeholder values array.
+      case SQLItemType.VALUE: {
+        const { placeholder, value } = formatValue(item.value, values.length);
+        text += placeholder;
+        if (value !== PREVIOUSLY_SEEN_VALUE) {
+          values.push(value);
+        }
+        break;
+      }
+      // If we got an identifier type, escape the strings and get a local
+      // identifier for non-string identifiers.
+      case SQLItemType.IDENTIFIER: {
+        text += item.names.map((name) => {
+          if (typeof name === "string") return escapeIdentifier(name);
+          if (!localIdentifiers.has(name))
+            localIdentifiers.set(name, `__local_${localIdentifiers.size}__`);
+          return escapeIdentifier(localIdentifiers.get(name));
+        }).join(".");
+        break;
+      }
+    }
+  }
+  if (text.trim()) {
+    const lines = text.split("\n");
+    const min = Math.min(
+      ...lines.filter((l) => l.trim() !== "").map((l) => /^\s*/.exec(l)[0].length)
+    );
+    if (min) {
+      text = lines.map((line) => line.substr(min)).join("\n");
+    }
+  }
+  return {
+    text: text.trim(),
+    values
+  };
+}
+
+// ../zero-cache/src/types/bigint-json.ts
+import {
+  parse as customParse,
+  stringify as customStringify
+} from "json-custom-numbers";
+var jsonValueSchema = valita_exports.lazy(() => {
+  const jsonObjectSchema2 = readonly(valita_exports.record(jsonValueSchema));
+  return valita_exports.union(
+    valita_exports.null(),
+    valita_exports.string(),
+    valita_exports.number(),
+    valita_exports.bigint(),
+    valita_exports.boolean(),
+    readonly(valita_exports.array(jsonValueSchema)),
+    jsonObjectSchema2
+  );
+});
+var jsonObjectSchema = readonly(valita_exports.record(jsonValueSchema));
 
 // ../z2s/src/compiler.ts
+var ZQL_RESULT_KEY = "zql_result";
 function compile(ast, tables, format) {
   const compiler = new Compiler(tables);
   return compiler.compile(ast, format);
@@ -212,15 +303,20 @@ var Compiler = class {
     this.#nameMapper = clientToServer(tables);
   }
   compile(ast, format) {
-    return this.select(ast, format, void 0);
+    return sql`SELECT ${this.#toJSON(
+      `root`,
+      format?.singular
+    )}::TEXT as ${sql.ident(ZQL_RESULT_KEY)} FROM (${this.select(
+      ast,
+      format,
+      void 0
+    )})${sql.ident(`root`)}`;
   }
   select(ast, format, correlation) {
     const selectionSet = this.related(ast.related ?? [], format, ast.table);
-    const table = this.#tables[ast.table];
-    for (const column of Object.keys(table.columns)) {
-      selectionSet.push(
-        sql`${sql.ident(ast.table)}.${this.#mapColumn(ast.table, column)}`
-      );
+    const tableSchema = this.#tables[ast.table];
+    for (const [column, columnSchema] of Object.entries(tableSchema.columns)) {
+      selectionSet.push(this.#selectCol(ast.table, column, columnSchema.type));
     }
     return sql`SELECT ${sql.join(selectionSet, ",")} FROM ${this.#mapTable(
       ast.table
@@ -245,7 +341,7 @@ var Compiler = class {
     if (!limit) {
       return sql``;
     }
-    return sql`LIMIT ${sql.value(limit)}`;
+    return sql`LIMIT ${sqlConvertArg("number", limit)}`;
   }
   related(relationships, format, parentTable) {
     return relationships.map(
@@ -261,7 +357,10 @@ var Compiler = class {
       const [join, lastAlias, lastLimit, lastTable] = this.makeJunctionJoin(relationship);
       const lastClientColumns = Object.keys(this.#tables[lastTable].columns);
       return sql`(
-        SELECT ${format?.singular ? sql`` : sql`COALESCE(array_agg`}(row_to_json(${sql.ident(`inner_${relationship.subquery.alias}`)})) ${format?.singular ? sql`` : sql`, ARRAY[]::json[])`} FROM (SELECT ${sql.join(
+        SELECT ${this.#toJSON(
+        `inner_${relationship.subquery.alias}`,
+        format?.singular
+      )} FROM (SELECT ${sql.join(
         lastClientColumns.map(
           (c) => sql`${sql.ident(lastAlias)}.${this.#mapColumn(lastTable, c)}`
         ),
@@ -283,7 +382,7 @@ var Compiler = class {
       ) as ${sql.ident(relationship.subquery.alias)}`;
     }
     return sql`(
-      SELECT ${format?.singular ? sql`` : sql`COALESCE(array_agg`}(row_to_json(${sql.ident(`inner_${relationship.subquery.alias}`)})) ${format?.singular ? sql`` : sql`, ARRAY[]::json[])`} FROM (${this.select(
+      SELECT ${format?.singular ? sql`` : sql`COALESCE(json_agg`}(row_to_json(${sql.ident(`inner_${relationship.subquery.alias}`)})) ${format?.singular ? sql`` : sql`, '[]'::json)`} FROM (${this.select(
       relationship.subquery,
       format,
       this.correlate(
@@ -381,10 +480,14 @@ var Compiler = class {
       case "NOT LIKE":
         return sql`${this.valuePosition(
           condition.left,
-          table
+          table,
+          this.#extractType(table, condition.left, condition.right),
+          false
         )} ${sql.__dangerous__rawValue(condition.op)} ${this.valuePosition(
           condition.right,
-          table
+          table,
+          this.#extractType(table, condition.right, condition.left),
+          false
         )}`;
       case "NOT IN":
       case "IN":
@@ -395,17 +498,17 @@ var Compiler = class {
     }
   }
   distinctFrom(condition, table) {
-    return sql`${this.valuePosition(condition.left, table)} ${condition.op === "IS" ? sql`IS NOT DISTINCT FROM` : sql`IS DISTINCT FROM`} ${this.valuePosition(condition.right, table)}`;
+    return sql`${this.valuePosition(condition.left, table, this.#extractType(table, condition.left, condition.right), false)} ${condition.op === "IS" ? sql`IS NOT DISTINCT FROM` : sql`IS DISTINCT FROM`} ${this.valuePosition(condition.right, table, this.#extractType(table, condition.right, condition.left), false)}`;
   }
   any(condition, table) {
-    return sql`${this.valuePosition(condition.left, table)} ${condition.op === "IN" ? sql`= ANY` : sql`!= ANY`} (${this.valuePosition(condition.right, table)})`;
+    return sql`${this.valuePosition(condition.left, table, this.#extractType(table, condition.left, condition.right), false)} ${condition.op === "IN" ? sql`= ANY` : sql`!= ANY`} (${this.valuePosition(condition.right, table, this.#extractType(table, condition.right, condition.left), true)})`;
   }
-  valuePosition(value, table) {
+  valuePosition(value, table, valueType, plural) {
     switch (value.type) {
       case "column":
         return this.#mapColumnNoAlias(table, value.name);
       case "literal":
-        return sql.value(value.value);
+        return sqlConvertArgUnsafe(valueType, value.value, plural);
       case "static":
         throw new Error(
           "Static parameters must be bound to a value before compiling to SQL"
@@ -471,77 +574,125 @@ var Compiler = class {
     const mapped = this.#nameMapper.tableName(table);
     return sql.ident(mapped);
   }
+  #selectCol(table, column, type) {
+    if (type === "date" || type === "timestamp") {
+      return sql`EXTRACT(EPOCH FROM ${sql.ident(
+        table
+      )}.${this.#mapColumnNoAlias(
+        table,
+        column
+      )}::timestamp AT TIME ZONE 'UTC') * 1000 as ${sql.ident(column)}`;
+    }
+    return sql`${sql.ident(table)}.${this.#mapColumn(table, column)}`;
+  }
+  #toJSON(table, singular = false) {
+    return sql`${singular ? sql`` : sql`COALESCE(json_agg`}(row_to_json(${sql.ident(table)})) ${singular ? sql`` : sql`, '[]'::json)`}`;
+  }
+  #extractType(table, first, second) {
+    const column = first.type === "column" ? first.name : second.type === "column" ? second.name : void 0;
+    if (column) {
+      return this.#tables[table].columns[column].type;
+    }
+    const literalValue = first.type === "literal" ? first.value : second.type === "literal" ? second.value : void 0;
+    assert(literalValue, "Literal value not found");
+    if (literalValue === null) {
+      return "null";
+    }
+    const jsType = typeof literalValue;
+    switch (jsType) {
+      case "boolean":
+      case "number":
+      case "string":
+        return jsType;
+      case "object":
+      case "bigint":
+      case "function":
+      case "symbol":
+      case "undefined":
+        throw new Error("Unsupported type: " + jsType);
+      default:
+        unreachable(jsType);
+    }
+  }
 };
 
 // ../zero-client/src/client/inspector/inspector.ts
-async function newInspector(rep, schema) {
+async function newInspector(rep, schema, socket) {
   const clientGroupID = await rep.clientGroupID;
-  return new Inspector(rep, schema, rep.clientID, clientGroupID);
+  return new Inspector(rep, schema, rep.clientID, clientGroupID, socket);
 }
 var Inspector = class {
   #rep;
   client;
   clientGroup;
   #schema;
-  constructor(rep, schema, clientID, clientGroupID) {
+  socket;
+  constructor(rep, schema, clientID, clientGroupID, socket) {
     this.#rep = rep;
     this.#schema = schema;
-    this.client = new Client(rep, schema, clientID, clientGroupID);
+    this.client = new Client(rep, schema, socket, clientID, clientGroupID);
     this.clientGroup = this.client.clientGroup;
+    this.socket = socket;
   }
   clients() {
     return withDagRead(
       this.#rep,
-      (dagRead) => clients(this.#rep, this.#schema, dagRead)
+      (dagRead) => clients(this.#rep, this.socket, this.#schema, dagRead)
     );
   }
   clientsWithQueries() {
     return withDagRead(
       this.#rep,
-      (dagRead) => clientsWithQueries(this.#rep, this.#schema, dagRead)
+      (dagRead) => clientsWithQueries(this.#rep, this.socket, this.#schema, dagRead)
     );
   }
-  clientGroups() {
-    return withDagRead(this.#rep, async (dagRead) => {
-      const clientGroups = await getClientGroups(dagRead);
-      return [...clientGroups.keys()].map(
-        (clientGroupID) => new ClientGroup(this.#rep, this.#schema, clientGroupID)
-      );
-    });
-  }
 };
+function rpc(socket, arg, downSchema) {
+  assert(socket, "WebSocket not available");
+  return new Promise((resolve, reject) => {
+    const id = nanoid();
+    const f = (ev) => {
+      const msg = JSON.parse(ev.data);
+      if (msg[0] === "inspect") {
+        const body = msg[1];
+        if (body.id !== id) {
+          return;
+        }
+        const res = test(body, downSchema);
+        if (res.ok) {
+          resolve(res.value.value);
+        } else {
+          reject(res.error);
+        }
+        socket.removeEventListener("message", f);
+      }
+    };
+    socket.addEventListener("message", f);
+    socket.send(
+      JSON.stringify(["inspect", { ...arg, id }])
+    );
+  });
+}
 var Client = class {
   #rep;
   id;
   clientGroup;
   #schema;
-  constructor(rep, schema, id, clientGroupID) {
+  #socket;
+  constructor(rep, schema, socket, id, clientGroupID) {
     this.#rep = rep;
     this.#schema = schema;
+    this.#socket = socket;
     this.id = id;
-    this.clientGroup = new ClientGroup(rep, schema, clientGroupID);
+    this.clientGroup = new ClientGroup(rep, socket, schema, clientGroupID);
   }
-  queries() {
-    return withDagRead(this.#rep, async (dagRead) => {
-      const prefix = desiredQueriesPrefixForClient(this.id);
-      const tree = await getBTree(dagRead, this.id);
-      const qs = [];
-      for await (const [key, value] of tree.scan(prefix)) {
-        if (!key.startsWith(prefix)) {
-          break;
-        }
-        const hash = key.substring(prefix.length);
-        const got = await tree.has(toGotQueriesKey(hash));
-        const q = new Query(
-          hash,
-          parse(value, astSchema),
-          got,
-          this.#schema
-        );
-        qs.push(q);
-      }
-      return qs;
-    });
+  async queries() {
+    const rows = await rpc(
+      this.#socket(),
+      { op: "queries", clientID: this.id },
+      inspectQueriesDownSchema
+    );
+    return rows.map((row) => new Query(row, this.#schema));
   }
   map() {
     return withDagRead(this.#rep, async (dagRead) => {
@@ -572,8 +723,10 @@ var ClientGroup = class {
   #rep;
   id;
   #schema;
-  constructor(rep, schema, id) {
+  #socket;
+  constructor(rep, socket, schema, id) {
     this.#rep = rep;
+    this.#socket = socket;
     this.#schema = schema;
     this.id = id;
   }
@@ -582,6 +735,7 @@ var ClientGroup = class {
       this.#rep,
       (dagRead) => clients(
         this.#rep,
+        this.#socket,
         this.#schema,
         dagRead,
         ([_, v]) => v.clientGroupID === this.id
@@ -593,29 +747,20 @@ var ClientGroup = class {
       this.#rep,
       (dagRead) => clientsWithQueries(
         this.#rep,
+        this.#socket,
         this.#schema,
         dagRead,
         ([_, v]) => v.clientGroupID === this.id
       )
     );
   }
-  queries() {
-    return withDagRead(this.#rep, async (dagRead) => {
-      const cs = await clients(
-        this.#rep,
-        this.#schema,
-        dagRead,
-        ([_, v]) => v.clientGroupID === this.id
-      );
-      const qs = /* @__PURE__ */ new Map();
-      await Promise.all(
-        cs.map(async (client) => {
-          const clientQueries = await client.queries();
-          clientQueries.forEach((q) => qs.set(q.id, q));
-        })
-      );
-      return [...qs.values()];
-    });
+  async queries() {
+    const rows = await rpc(
+      this.#socket(),
+      { op: "queries" },
+      inspectQueriesDownSchema
+    );
+    return rows.map((row) => new Query(row, this.#schema));
   }
 };
 async function withDagRead(rep, f) {
@@ -636,14 +781,14 @@ async function getBTree(dagRead, clientID) {
   );
   return dbRead.map;
 }
-async function clients(rep, schema, dagRead, predicate = () => true) {
+async function clients(rep, socket, schema, dagRead, predicate = () => true) {
   const clients2 = await getClients(dagRead);
   return [...clients2.entries()].filter(predicate).map(
-    ([clientID, { clientGroupID }]) => new Client(rep, schema, clientID, clientGroupID)
+    ([clientID, { clientGroupID }]) => new Client(rep, schema, socket, clientID, clientGroupID)
   );
 }
-async function clientsWithQueries(rep, schema, dagRead, predicate = () => true) {
-  const allClients = await clients(rep, schema, dagRead, predicate);
+async function clientsWithQueries(rep, socket, schema, dagRead, predicate = () => true) {
+  const allClients = await clients(rep, socket, schema, dagRead, predicate);
   const clientsWithQueries2 = [];
   await Promise.all(
     allClients.map(async (client) => {
@@ -656,29 +801,35 @@ async function clientsWithQueries(rep, schema, dagRead, predicate = () => true)
   return clientsWithQueries2;
 }
 var Query = class {
-  id;
   ast;
   got;
-  #schema;
-  constructor(id, ast, got, schema) {
-    this.id = id;
-    this.ast = ast;
-    this.got = got;
-    this.#schema = schema;
-  }
-  get sql() {
+  ttl;
+  inactivatedAt;
+  rowCount;
+  deleted;
+  id;
+  sql;
+  zql;
+  clientID;
+  constructor(row, schema) {
+    this.clientID = row.clientID;
+    this.id = row.queryID;
+    this.inactivatedAt = row.inactivatedAt === null ? null : new Date(row.inactivatedAt);
+    this.ttl = normalizeTTL(row.ttl);
+    this.ast = row.ast;
+    this.got = row.got;
+    this.rowCount = row.rowCount;
+    this.deleted = row.deleted;
     const format = {
       singular: false,
       relationships: {}
     };
-    const sqlQuery = formatPg(compile(this.ast, this.#schema.tables, format));
-    return sqlQuery.text;
-  }
-  get zql() {
-    return this.ast.table + astToZQL(this.ast);
+    const sqlQuery = formatPg(compile(this.ast, schema.tables, format));
+    this.sql = sqlQuery.text;
+    this.zql = this.ast.table + astToZQL(this.ast);
   }
 };
 export {
   newInspector
 };
-//# sourceMappingURL=inspector-ROITQB3J.js.map
+//# sourceMappingURL=inspector-SH2ZK7O3.js.map