@rocicorp/zero 0.18.2025032000 → 0.18.2025032002

package/out/inspector-SVHRQAQN.js

@@ -0,0 +1,691 @@
+import {
+  ENTITIES_KEY_PREFIX,
+  Latest,
+  SUBQ_PREFIX,
+  astSchema,
+  clientToServer,
+  desiredQueriesPrefixForClient,
+  getClient,
+  getClientGroup,
+  getClientGroups,
+  getClients,
+  parse,
+  readFromHash,
+  toGotQueriesKey,
+  valita_exports,
+  withRead
+} from "./chunk-KRZMF5WQ.js";
+import "./chunk-2B2QE5AT.js";
+import {
+  assert,
+  must,
+  unreachable
+} from "./chunk-2NCGIK6G.js";
+import "./chunk-424PT5DM.js";
+
+// ../z2s/src/sql.ts
+import baseSql from "@databases/sql";
+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);
+}
+var sql = baseSql.default;
+
+// ../z2s/src/compiler.ts
+function compile(ast, tables, format) {
+  const compiler = new Compiler(tables);
+  return compiler.compile(ast, format);
+}
+var Compiler = class {
+  #tables;
+  #nameMapper;
+  constructor(tables) {
+    this.#tables = tables;
+    this.#nameMapper = clientToServer(tables);
+  }
+  compile(ast, format) {
+    return this.select(ast, format, void 0);
+  }
+  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)}`
+      );
+    }
+    return sql`SELECT ${sql.join(selectionSet, ",")} FROM ${this.#mapTable(
+      ast.table
+    )} ${ast.where ? sql`WHERE ${this.where(ast.where, ast.table)}` : sql``} ${correlation ? sql`${ast.where ? sql`AND` : sql`WHERE`} (${correlation})` : sql``} ${this.orderBy(ast.orderBy, ast.table)} ${format?.singular ? this.limit(1) : this.limit(ast.limit)}`;
+  }
+  orderBy(orderBy, table) {
+    if (!orderBy) {
+      return sql``;
+    }
+    return sql`ORDER BY ${sql.join(
+      orderBy.map(
+        ([col, dir]) => dir === "asc" ? (
+          // Oh postgres. The table must be referred to be client name but the column by server name.
+          // E.g., `SELECT server_col as client_col FROM server_table as client_table ORDER BY client_Table.server_col`
+          sql`${sql.ident(table)}.${this.#mapColumnNoAlias(table, col)} ASC`
+        ) : sql`${sql.ident(table)}.${this.#mapColumnNoAlias(table, col)} DESC`
+      ),
+      ", "
+    )}`;
+  }
+  limit(limit) {
+    if (!limit) {
+      return sql``;
+    }
+    return sql`LIMIT ${sql.value(limit)}`;
+  }
+  related(relationships, format, parentTable) {
+    return relationships.map(
+      (relationship) => this.relationshipSubquery(
+        relationship,
+        format?.relationships[must(relationship.subquery.alias)],
+        parentTable
+      )
+    );
+  }
+  relationshipSubquery(relationship, format, parentTable) {
+    if (relationship.hidden) {
+      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(
+        lastClientColumns.map(
+          (c) => sql`${sql.ident(lastAlias)}.${this.#mapColumn(lastTable, c)}`
+        ),
+        ","
+      )} FROM ${join} WHERE (${this.correlate(
+        parentTable,
+        parentTable,
+        relationship.correlation.parentField,
+        relationship.subquery.table,
+        relationship.subquery.table,
+        relationship.correlation.childField
+      )}) ${relationship.subquery.where ? sql`AND ${this.where(
+        relationship.subquery.where,
+        relationship.subquery.table
+      )}` : sql``} ${this.orderBy(
+        relationship.subquery.orderBy,
+        relationship.subquery.table
+      )} ${format?.singular ? this.limit(1) : this.limit(lastLimit)} ) ${sql.ident(`inner_${relationship.subquery.alias}`)}
+      ) 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(
+      relationship.subquery,
+      format,
+      this.correlate(
+        parentTable,
+        parentTable,
+        relationship.correlation.parentField,
+        relationship.subquery.table,
+        relationship.subquery.table,
+        relationship.correlation.childField
+      )
+    )}) ${sql.ident(`inner_${relationship.subquery.alias}`)}
+    ) as ${sql.ident(relationship.subquery.alias)}`;
+  }
+  pullTablesForJunction(relationship, tables = []) {
+    tables.push([
+      relationship.subquery.table,
+      relationship.correlation,
+      relationship.subquery.limit
+    ]);
+    assert(
+      relationship.subquery.related?.length || 0 <= 1,
+      "Too many related tables for a junction edge"
+    );
+    for (const subRelationship of relationship.subquery.related ?? []) {
+      this.pullTablesForJunction(subRelationship, tables);
+    }
+    return tables;
+  }
+  makeJunctionJoin(relationship) {
+    const participatingTables = this.pullTablesForJunction(relationship);
+    const joins = [];
+    function alias(index) {
+      if (index === 0) {
+        return participatingTables[0][0];
+      }
+      return `table_${index}`;
+    }
+    for (const [table, _correlation] of participatingTables) {
+      if (joins.length === 0) {
+        joins.push(this.#mapTable(table));
+        continue;
+      }
+      joins.push(
+        sql` JOIN ${this.#mapTableNoAlias(table)} as ${sql.ident(
+          alias(joins.length)
+        )} ON ${this.correlate(
+          participatingTables[joins.length - 1][0],
+          alias(joins.length - 1),
+          participatingTables[joins.length][1].parentField,
+          participatingTables[joins.length][0],
+          alias(joins.length),
+          participatingTables[joins.length][1].childField
+        )}`
+      );
+    }
+    return [
+      sql.join(joins, ""),
+      alias(joins.length - 1),
+      participatingTables[participatingTables.length - 1][2],
+      participatingTables[participatingTables.length - 1][0]
+    ];
+  }
+  where(condition, table) {
+    if (!condition) {
+      return sql``;
+    }
+    switch (condition.type) {
+      case "and":
+        return sql`(${sql.join(
+          condition.conditions.map((c) => this.where(c, table)),
+          " AND "
+        )})`;
+      case "or":
+        return sql`(${sql.join(
+          condition.conditions.map((c) => this.where(c, table)),
+          " OR "
+        )})`;
+      case "correlatedSubquery":
+        return this.exists(condition, table);
+      case "simple":
+        return this.simple(condition, table);
+    }
+  }
+  simple(condition, table) {
+    switch (condition.op) {
+      case "!=":
+      case "<":
+      case "<=":
+      case "=":
+      case ">":
+      case ">=":
+      case "ILIKE":
+      case "LIKE":
+      case "NOT ILIKE":
+      case "NOT LIKE":
+        return sql`${this.valuePosition(
+          condition.left,
+          table
+        )} ${sql.__dangerous__rawValue(condition.op)} ${this.valuePosition(
+          condition.right,
+          table
+        )}`;
+      case "NOT IN":
+      case "IN":
+        return this.any(condition, table);
+      case "IS":
+      case "IS NOT":
+        return this.distinctFrom(condition, table);
+    }
+  }
+  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)}`;
+  }
+  any(condition, table) {
+    return sql`${this.valuePosition(condition.left, table)} ${condition.op === "IN" ? sql`= ANY` : sql`!= ANY`} (${this.valuePosition(condition.right, table)})`;
+  }
+  valuePosition(value, table) {
+    switch (value.type) {
+      case "column":
+        return this.#mapColumnNoAlias(table, value.name);
+      case "literal":
+        return sql.value(value.value);
+      case "static":
+        throw new Error(
+          "Static parameters must be bound to a value before compiling to SQL"
+        );
+    }
+  }
+  exists(condition, parentTable) {
+    switch (condition.op) {
+      case "EXISTS":
+        return sql`EXISTS (${this.select(
+          condition.related.subquery,
+          void 0,
+          this.correlate(
+            parentTable,
+            parentTable,
+            condition.related.correlation.parentField,
+            condition.related.subquery.table,
+            condition.related.subquery.table,
+            condition.related.correlation.childField
+          )
+        )})`;
+      case "NOT EXISTS":
+        return sql`NOT EXISTS (${this.select(
+          condition.related.subquery,
+          void 0,
+          void 0
+        )})`;
+    }
+  }
+  correlate(parentTable, parentTableAlias, parentColumns, childTable, childTableAlias, childColumns) {
+    return sql.join(
+      zip(parentColumns, childColumns).map(
+        ([parentColumn, childColumn]) => sql`${sql.ident(parentTableAlias)}.${this.#mapColumnNoAlias(
+          parentTable,
+          parentColumn
+        )} = ${sql.ident(childTableAlias)}.${this.#mapColumnNoAlias(
+          childTable,
+          childColumn
+        )}`
+      ),
+      " AND "
+    );
+  }
+  #mapColumn(table, column) {
+    const mapped = this.#nameMapper.columnName(table, column);
+    if (mapped === column) {
+      return sql.ident(column);
+    }
+    return sql`${sql.ident(mapped)} as ${sql.ident(column)}`;
+  }
+  #mapColumnNoAlias(table, column) {
+    const mapped = this.#nameMapper.columnName(table, column);
+    return sql.ident(mapped);
+  }
+  #mapTable(table) {
+    const mapped = this.#nameMapper.tableName(table);
+    if (mapped === table) {
+      return sql.ident(table);
+    }
+    return sql`${sql.ident(mapped)} as ${sql.ident(table)}`;
+  }
+  #mapTableNoAlias(table) {
+    const mapped = this.#nameMapper.tableName(table);
+    return sql.ident(mapped);
+  }
+};
+function zip(a1, a2) {
+  assert(a1.length === a2.length);
+  const result = [];
+  for (let i = 0; i < a1.length; i++) {
+    result.push([a1[i], a2[i]]);
+  }
+  return result;
+}
+
+// ../zql/src/query/ast-to-zql.ts
+function astToZQL(ast) {
+  let code = "";
+  if (ast.where) {
+    code += transformCondition(ast.where, ".where", /* @__PURE__ */ new Set());
+  }
+  if (ast.related && ast.related.length > 0) {
+    for (const related of ast.related) {
+      if (!related.hidden) {
+        code += transformRelated(related);
+      }
+    }
+  }
+  if (ast.orderBy && ast.orderBy.length > 0) {
+    code += transformOrder(ast.orderBy);
+  }
+  if (ast.limit !== void 0) {
+    code += `.limit(${ast.limit})`;
+  }
+  if (ast.start) {
+    const { row, exclusive } = ast.start;
+    code += `.start(${JSON.stringify(row)}${exclusive ? "" : ", { inclusive: true }"})`;
+  }
+  return code;
+}
+function transformCondition(condition, prefix, args) {
+  switch (condition.type) {
+    case "simple":
+      return transformSimpleCondition(condition, prefix);
+    case "and":
+    case "or":
+      return transformLogicalCondition(condition, prefix, args);
+    case "correlatedSubquery":
+      return transformExistsCondition(condition, prefix, args);
+    default:
+      unreachable(condition);
+  }
+}
+function transformSimpleCondition(condition, prefix) {
+  const { left, op, right } = condition;
+  const leftCode = transformValuePosition(left);
+  const rightCode = transformValuePosition(right);
+  if (op === "=") {
+    return `${prefix}(${leftCode}, ${rightCode})`;
+  }
+  return `${prefix}(${leftCode}, '${op}', ${rightCode})`;
+}
+function transformLogicalCondition(condition, prefix, args) {
+  const { type, conditions } = condition;
+  if (conditions.length === 1) {
+    return transformCondition(conditions[0], prefix, args);
+  }
+  if (type === "and") {
+    const parts = conditions.map((c) => transformCondition(c, prefix, args));
+    if (prefix === ".where") {
+      return parts.join("");
+    }
+    args.add("and");
+    return "and(" + parts.join(", ") + ")";
+  }
+  args = /* @__PURE__ */ new Set();
+  const conditionsCode = conditions.map((c) => transformCondition(c, "cmp", args)).join(", ");
+  args.add("cmp");
+  args.add(type);
+  const argsCode = [...args].sort().join(", ");
+  return `.where(({${argsCode}}) => ${type}(${conditionsCode}))`;
+}
+function transformExistsCondition(condition, prefix, args) {
+  const { related, op } = condition;
+  const relationship = extractRelationshipName(related);
+  const hasSubQueryProps = related.subquery.where || related.subquery.related && related.subquery.related.length > 0 || related.subquery.orderBy || related.subquery.limit;
+  if (op === "EXISTS") {
+    if (!hasSubQueryProps) {
+      if (prefix === ".where") {
+        return `.whereExists('${relationship}')`;
+      }
+      args.add("exists");
+      return `exists('${relationship}')`;
+    }
+    if (prefix === ".where") {
+      return `.whereExists('${relationship}', q => q${astToZQL(
+        related.subquery
+      )}))`;
+    }
+    prefix;
+    args.add("exists");
+    return `exists('${relationship}', q => q${astToZQL(related.subquery)})`;
+  }
+  op;
+  if (hasSubQueryProps) {
+    if (prefix === ".where") {
+      return `.where(({exists, not}) => not(exists('${relationship}', q => q${astToZQL(
+        related.subquery
+      )})))`;
+    }
+    prefix;
+    args.add("not");
+    args.add("exists");
+    return `not(exists('${relationship}', q => q${astToZQL(
+      related.subquery
+    )}))`;
+  }
+  if (prefix === ".where") {
+    return `.where(({exists, not}) => not(exists('${relationship}')))`;
+  }
+  args.add("not");
+  args.add("exists");
+  return `not(exists('${relationship}')))`;
+}
+function extractRelationshipName(related) {
+  const alias = must(related.subquery.alias);
+  return alias.startsWith(SUBQ_PREFIX) ? alias.substring(SUBQ_PREFIX.length) : alias;
+}
+function transformRelated(related) {
+  const { alias } = related.subquery;
+  if (!alias) return "";
+  const relationship = alias;
+  let code = `.related('${relationship}'`;
+  if (related.subquery.where || related.subquery.related && related.subquery.related.length > 0 || related.subquery.orderBy || related.subquery.limit) {
+    code += ", q => q" + astToZQL(related.subquery);
+  }
+  code += ")";
+  return code;
+}
+function transformOrder(orderBy) {
+  let code = "";
+  for (const [field, direction] of orderBy) {
+    code += `.orderBy('${field}', '${direction}')`;
+  }
+  return code;
+}
+function transformValuePosition(value) {
+  switch (value.type) {
+    case "literal":
+      return transformLiteral(value);
+    case "column":
+      return `'${value.name}'`;
+    case "static":
+      return transformParameter(value);
+    default:
+      unreachable(value);
+  }
+}
+function transformLiteral(literal) {
+  if (literal.value === null) {
+    return "null";
+  }
+  if (Array.isArray(literal.value)) {
+    return JSON.stringify(literal.value);
+  }
+  if (typeof literal.value === "string") {
+    return `'${literal.value.replace(/'/g, "\\'")}'`;
+  }
+  return String(literal.value);
+}
+function transformParameter(param) {
+  const fieldStr = Array.isArray(param.field) ? `[${param.field.map((f) => `'${f}'`).join(", ")}]` : `'${param.field}'`;
+  return `authParam(${fieldStr})`;
+}
+
+// ../zero-client/src/client/inspector/inspector.ts
+async function newInspector(rep, schema) {
+  const clientGroupID = await rep.clientGroupID;
+  return new Inspector(rep, schema, rep.clientID, clientGroupID);
+}
+var Inspector = class {
+  #rep;
+  client;
+  clientGroup;
+  #schema;
+  constructor(rep, schema, clientID, clientGroupID) {
+    this.#rep = rep;
+    this.#schema = schema;
+    this.client = new Client(rep, schema, clientID, clientGroupID);
+    this.clientGroup = this.client.clientGroup;
+  }
+  clients() {
+    return withDagRead(
+      this.#rep,
+      (dagRead) => clients(this.#rep, this.#schema, dagRead)
+    );
+  }
+  clientsWithQueries() {
+    return withDagRead(
+      this.#rep,
+      (dagRead) => clientsWithQueries(this.#rep, 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)
+      );
+    });
+  }
+};
+var Client = class {
+  #rep;
+  id;
+  clientGroup;
+  #schema;
+  constructor(rep, schema, id, clientGroupID) {
+    this.#rep = rep;
+    this.#schema = schema;
+    this.id = id;
+    this.clientGroup = new ClientGroup(rep, 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;
+    });
+  }
+  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;
+  constructor(rep, schema, id) {
+    this.#rep = rep;
+    this.#schema = schema;
+    this.id = id;
+  }
+  clients() {
+    return withDagRead(
+      this.#rep,
+      (dagRead) => clients(
+        this.#rep,
+        this.#schema,
+        dagRead,
+        ([_, v]) => v.clientGroupID === this.id
+      )
+    );
+  }
+  clientsWithQueries() {
+    return withDagRead(
+      this.#rep,
+      (dagRead) => clientsWithQueries(
+        this.#rep,
+        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 function withDagRead(rep, f) {
+  await rep.refresh();
+  await rep.persist();
+  return withRead(rep.perdag, f);
+}
+async function getBTree(dagRead, clientID) {
+  const client = await getClient(clientID, dagRead);
+  assert(client, `Client not found: ${clientID}`);
+  const { clientGroupID } = client;
+  const clientGroup = await getClientGroup(clientGroupID, dagRead);
+  assert(clientGroup, `Client group not found: ${clientGroupID}`);
+  const dbRead = await readFromHash(
+    clientGroup.headHash,
+    dagRead,
+    Latest
+  );
+  return dbRead.map;
+}
+async function clients(rep, schema, dagRead, predicate = () => true) {
+  const clients2 = await getClients(dagRead);
+  return [...clients2.entries()].filter(predicate).map(
+    ([clientID, { clientGroupID }]) => new Client(rep, schema, clientID, clientGroupID)
+  );
+}
+async function clientsWithQueries(rep, schema, dagRead, predicate = () => true) {
+  const allClients = await clients(rep, schema, dagRead, predicate);
+  const clientsWithQueries2 = [];
+  await Promise.all(
+    allClients.map(async (client) => {
+      const queries = await client.queries();
+      if (queries.length > 0) {
+        clientsWithQueries2.push(client);
+      }
+    })
+  );
+  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() {
+    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);
+  }
+};
+export {
+  newInspector
+};
+//# sourceMappingURL=inspector-SVHRQAQN.js.map