@rocicorp/zero 1.11.0-canary.4 → 1.11.0-canary.41

package/out/zero-cache/src/services/view-syncer/push-cost.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Learns what it costs to push a change of each table through each query of
+ * a client group, and estimates from it what pushing a batch of changes
+ * would cost.
+ *
+ * The estimates only decide whether a query skips pushing and starts an
+ * advancement on rebuild (see {@link shouldStartOnRebuild}). Nothing depends
+ * on their accuracy: a query that starts on push when it should not have is
+ * cut off (see `PushCutoff`), and one that starts on rebuild costs its
+ * hydration time, as it would have at the cutoff.
+ */
+export declare class PushCostEstimator {
+    #private;
+    /**
+     * Records what an advancement cost a query.
+     *
+     * @param tables The tables the query reads.
+     * @param timeMsByTable The time spent pushing the changes of each table
+     *        to the query. Absent for a table whose changes cost it nothing,
+     *        e.g. because the rows did not match its filters.
+     * @param changesByTable The entries of each table that the advancement
+     *        read from the change log, whether or not they reached the query,
+     *        or changed anything at all (a row that is inserted and deleted
+     *        between two snapshots is an entry that changes nothing). These
+     *        are the entries that {@link estimate} is given the count of.
+     */
+    record(queryID: string, tables: Iterable<string>, timeMsByTable: ReadonlyMap<string, number> | undefined, changesByTable: ReadonlyMap<string, number>): void;
+    /**
+     * The estimated time to push `changes` to the query, or `undefined` if it
+     * has never been pushed any change. A table that the query has never been
+     * pushed a change of is estimated to cost nothing.
+     *
+     * @param tables The tables the query reads.
+     * @param changes The number of changes to push, by table.
+     */
+    estimate(queryID: string, tables: Iterable<string>, changes: ReadonlyMap<string, number>): number | undefined;
+    /** Forgets what was learned about a query. */
+    forget(queryID: string): void;
+}
+/**
+ * Learns what it costs a client group to read a batch of changes, apart from
+ * pushing them through its queries, and estimates from it what reading the
+ * next one would cost.
+ *
+ * Reading has three parts, which do not cost the same entries (see
+ * {@link ReadParts}): walking the change log, parsing the entries that
+ * the walk returns, and looking up the rows of the entries of the tables
+ * that are read. What each costs is learned per entry that it was done for.
+ * A cost learned per entry of some other count is only right for a batch
+ * with the same mix of entries: charged to the entries that are pushed, for
+ * instance, the parsing of a batch that is mostly of tables that no query
+ * reads makes the next batch that is not look many times as expensive as it
+ * is.
+ *
+ * No query can be cut off for what this costs, as it is not a cost of any
+ * one query. It is what pushing costs all of them together, on top of what
+ * it costs each (see {@link shouldRebuildInsteadOfReading}).
+ */
+export declare class ReadCostEstimator {
+    #private;
+    /**
+     * Records what reading a batch cost. Only for a batch that was read to
+     * its end.
+     *
+     * @param timeMs The time spent on each part of reading the batch.
+     * @param entries The entries that each part was done for.
+     */
+    record(timeMs: ReadParts, entries: ReadParts): void;
+    /**
+     * The estimated time to read a batch, or `undefined` if none has been
+     * read yet.
+     *
+     * @param entries The entries that each part of reading the batch would be
+     *        done for.
+     */
+    estimate(entries: ReadParts): number | undefined;
+}
+/**
+ * A number for each part of reading a batch of changes: the entries of the
+ * change log that the part is done for, or the time that it takes.
+ */
+export type ReadParts = {
+    /**
+     * Walking the change log, which is done for every entry since the
+     * previous snapshot, whether or not the entry is of a table that is read:
+     * the entries are in the order they were committed in, not grouped by
+     * table.
+     */
+    readonly walk: number;
+    /**
+     * Parsing, which is done for every entry that the walk returns. That is
+     * all of them, unless the walk is told which tables are read.
+     */
+    readonly parse: number;
+    /**
+     * Looking up the row in both snapshots, which is done for every entry of
+     * a table that is read. This includes the entries that then turn out to
+     * change nothing (e.g. a row inserted and deleted since the previous
+     * snapshot).
+     */
+    readonly lookup: number;
+};
+/**
+ * Whether the queries that are left to push a batch to should all be
+ * hydrated again instead, without the batch being read: when reading it and
+ * pushing it to them is estimated to cost at least `margin` times what
+ * hydrating them does.
+ *
+ * This is {@link shouldStartOnRebuild} for the queries together, with what
+ * reading the batch costs added to what pushing it costs each of them. A
+ * query that few of the batch's changes reach is cheap to push to, but the
+ * whole batch still has to be walked to find those changes.
+ *
+ * @param estimatedReadMs `undefined` if there is no estimate, in which case
+ *        the batch is read.
+ * @param queries What pushing the batch is estimated to cost each query
+ *        (nothing, if it has no estimate), and what hydrating it took.
+ */
+export declare function shouldRebuildInsteadOfReading(estimatedReadMs: number | undefined, queries: Iterable<{
+    readonly estimatedPushMs: number | undefined;
+    readonly hydrationTimeMs: number;
+}>, margin: number): boolean;
+/**
+ * Whether a query should start an advancement on rebuild, i.e. be hydrated
+ * again without being pushed any of the advancement's changes: when pushing
+ * them is estimated to cost at least `margin` times what hydrating it does.
+ *
+ * The margin is for the imprecision of the estimate. A query without one
+ * starts on push.
+ */
+export declare function shouldStartOnRebuild(estimatedPushMs: number | undefined, hydrationTimeMs: number, margin: number): boolean;
+//# sourceMappingURL=push-cost.d.ts.map

package/out/zero-cache/src/services/view-syncer/push-cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-cost.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/push-cost.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;GAUG;AACH,qBAAa,iBAAiB;;IAI5B;;;;;;;;;;;;OAYG;IACH,MAAM,CACJ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxB,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACtD,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1C,IAAI,CAmBN;IAED;;;;;;;OAOG;IACH,QAAQ,CACN,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,GAAG,SAAS,CAUpB;IAED,8CAA8C;IAC9C,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5B;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,iBAAiB;;IAK5B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI,CAgBlD;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAS/C;CACF;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAgBF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,OAAO,EAAE,QAAQ,CAAC;IAChB,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC,CAAC,EACF,MAAM,EAAE,MAAM,GACb,OAAO,CAWT;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GACb,OAAO,CAKT"}

package/out/zero-cache/src/services/view-syncer/push-cost.js

@@ -0,0 +1,164 @@
+//#region ../zero-cache/src/services/view-syncer/push-cost.ts
+/**
+* The weight of the latest advancement in a query's cost per change. The
+* cost of a change depends on the row (one joined to many others costs more
+* than one that is filtered out), so it varies from one advancement to the
+* next, and workloads shift.
+*/
+var LATEST_WEIGHT = .3;
+/**
+* Learns what it costs to push a change of each table through each query of
+* a client group, and estimates from it what pushing a batch of changes
+* would cost.
+*
+* The estimates only decide whether a query skips pushing and starts an
+* advancement on rebuild (see {@link shouldStartOnRebuild}). Nothing depends
+* on their accuracy: a query that starts on push when it should not have is
+* cut off (see `PushCutoff`), and one that starts on rebuild costs its
+* hydration time, as it would have at the cutoff.
+*/
+var PushCostEstimator = class {
+	/** Milliseconds per change, by query ID and table. */
+	#costs = /* @__PURE__ */ new Map();
+	/**
+	* Records what an advancement cost a query.
+	*
+	* @param tables The tables the query reads.
+	* @param timeMsByTable The time spent pushing the changes of each table
+	*        to the query. Absent for a table whose changes cost it nothing,
+	*        e.g. because the rows did not match its filters.
+	* @param changesByTable The entries of each table that the advancement
+	*        read from the change log, whether or not they reached the query,
+	*        or changed anything at all (a row that is inserted and deleted
+	*        between two snapshots is an entry that changes nothing). These
+	*        are the entries that {@link estimate} is given the count of.
+	*/
+	record(queryID, tables, timeMsByTable, changesByTable) {
+		let costs = this.#costs.get(queryID);
+		for (const table of tables) {
+			const changes = changesByTable.get(table);
+			if (!changes) continue;
+			if (costs === void 0) {
+				costs = /* @__PURE__ */ new Map();
+				this.#costs.set(queryID, costs);
+			}
+			const latest = (timeMsByTable?.get(table) ?? 0) / changes;
+			const previous = costs.get(table);
+			const cost = previous === void 0 ? latest : previous + LATEST_WEIGHT * (latest - previous);
+			costs.set(table, cost);
+		}
+	}
+	/**
+	* The estimated time to push `changes` to the query, or `undefined` if it
+	* has never been pushed any change. A table that the query has never been
+	* pushed a change of is estimated to cost nothing.
+	*
+	* @param tables The tables the query reads.
+	* @param changes The number of changes to push, by table.
+	*/
+	estimate(queryID, tables, changes) {
+		const costs = this.#costs.get(queryID);
+		if (costs === void 0) return;
+		let total = 0;
+		for (const table of tables) total += (changes.get(table) ?? 0) * (costs.get(table) ?? 0);
+		return total;
+	}
+	/** Forgets what was learned about a query. */
+	forget(queryID) {
+		this.#costs.delete(queryID);
+	}
+};
+/**
+* Learns what it costs a client group to read a batch of changes, apart from
+* pushing them through its queries, and estimates from it what reading the
+* next one would cost.
+*
+* Reading has three parts, which do not cost the same entries (see
+* {@link ReadParts}): walking the change log, parsing the entries that
+* the walk returns, and looking up the rows of the entries of the tables
+* that are read. What each costs is learned per entry that it was done for.
+* A cost learned per entry of some other count is only right for a batch
+* with the same mix of entries: charged to the entries that are pushed, for
+* instance, the parsing of a batch that is mostly of tables that no query
+* reads makes the next batch that is not look many times as expensive as it
+* is.
+*
+* No query can be cut off for what this costs, as it is not a cost of any
+* one query. It is what pushing costs all of them together, on top of what
+* it costs each (see {@link shouldRebuildInsteadOfReading}).
+*/
+var ReadCostEstimator = class {
+	#walkMsPerEntry;
+	#parseMsPerEntry;
+	#lookupMsPerEntry;
+	/**
+	* Records what reading a batch cost. Only for a batch that was read to
+	* its end.
+	*
+	* @param timeMs The time spent on each part of reading the batch.
+	* @param entries The entries that each part was done for.
+	*/
+	record(timeMs, entries) {
+		this.#walkMsPerEntry = learn(this.#walkMsPerEntry, timeMs.walk, entries.walk);
+		this.#parseMsPerEntry = learn(this.#parseMsPerEntry, timeMs.parse, entries.parse);
+		this.#lookupMsPerEntry = learn(this.#lookupMsPerEntry, timeMs.lookup, entries.lookup);
+	}
+	/**
+	* The estimated time to read a batch, or `undefined` if none has been
+	* read yet.
+	*
+	* @param entries The entries that each part of reading the batch would be
+	*        done for.
+	*/
+	estimate(entries) {
+		if (this.#walkMsPerEntry === void 0) return;
+		return entries.walk * this.#walkMsPerEntry + entries.parse * (this.#parseMsPerEntry ?? 0) + entries.lookup * (this.#lookupMsPerEntry ?? 0);
+	}
+};
+function learn(msPerEntry, timeMs, entries) {
+	return entries > 0 ? decay(msPerEntry, timeMs / entries) : msPerEntry;
+}
+function decay(previous, latest) {
+	return previous === void 0 ? latest : previous + LATEST_WEIGHT * (latest - previous);
+}
+/**
+* Whether the queries that are left to push a batch to should all be
+* hydrated again instead, without the batch being read: when reading it and
+* pushing it to them is estimated to cost at least `margin` times what
+* hydrating them does.
+*
+* This is {@link shouldStartOnRebuild} for the queries together, with what
+* reading the batch costs added to what pushing it costs each of them. A
+* query that few of the batch's changes reach is cheap to push to, but the
+* whole batch still has to be walked to find those changes.
+*
+* @param estimatedReadMs `undefined` if there is no estimate, in which case
+*        the batch is read.
+* @param queries What pushing the batch is estimated to cost each query
+*        (nothing, if it has no estimate), and what hydrating it took.
+*/
+function shouldRebuildInsteadOfReading(estimatedReadMs, queries, margin) {
+	if (estimatedReadMs === void 0) return false;
+	let pushMs = estimatedReadMs;
+	let hydrationMs = 0;
+	for (const query of queries) {
+		pushMs += query.estimatedPushMs ?? 0;
+		hydrationMs += Math.max(query.hydrationTimeMs, 2);
+	}
+	return hydrationMs > 0 && pushMs >= margin * hydrationMs;
+}
+/**
+* Whether a query should start an advancement on rebuild, i.e. be hydrated
+* again without being pushed any of the advancement's changes: when pushing
+* them is estimated to cost at least `margin` times what hydrating it does.
+*
+* The margin is for the imprecision of the estimate. A query without one
+* starts on push.
+*/
+function shouldStartOnRebuild(estimatedPushMs, hydrationTimeMs, margin) {
+	return estimatedPushMs !== void 0 && estimatedPushMs >= margin * Math.max(hydrationTimeMs, 2);
+}
+//#endregion
+export { PushCostEstimator, ReadCostEstimator, shouldRebuildInsteadOfReading, shouldStartOnRebuild };
+
+//# sourceMappingURL=push-cost.js.map

package/out/zero-cache/src/services/view-syncer/push-cost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-cost.js","names":["#costs","#walkMsPerEntry","#parseMsPerEntry","#lookupMsPerEntry"],"sources":["../../../../../../zero-cache/src/services/view-syncer/push-cost.ts"],"sourcesContent":["import {MIN_PUSH_CUTOFF_MS} from './push-cutoff.ts';\n\n/**\n * The weight of the latest advancement in a query's cost per change. The\n * cost of a change depends on the row (one joined to many others costs more\n * than one that is filtered out), so it varies from one advancement to the\n * next, and workloads shift.\n */\nconst LATEST_WEIGHT = 0.3;\n\n/**\n * Learns what it costs to push a change of each table through each query of\n * a client group, and estimates from it what pushing a batch of changes\n * would cost.\n *\n * The estimates only decide whether a query skips pushing and starts an\n * advancement on rebuild (see {@link shouldStartOnRebuild}). Nothing depends\n * on their accuracy: a query that starts on push when it should not have is\n * cut off (see `PushCutoff`), and one that starts on rebuild costs its\n * hydration time, as it would have at the cutoff.\n */\nexport class PushCostEstimator {\n  /** Milliseconds per change, by query ID and table. */\n  readonly #costs = new Map<string, Map<string, number>>();\n\n  /**\n   * Records what an advancement cost a query.\n   *\n   * @param tables The tables the query reads.\n   * @param timeMsByTable The time spent pushing the changes of each table\n   *        to the query. Absent for a table whose changes cost it nothing,\n   *        e.g. because the rows did not match its filters.\n   * @param changesByTable The entries of each table that the advancement\n   *        read from the change log, whether or not they reached the query,\n   *        or changed anything at all (a row that is inserted and deleted\n   *        between two snapshots is an entry that changes nothing). These\n   *        are the entries that {@link estimate} is given the count of.\n   */\n  record(\n    queryID: string,\n    tables: Iterable<string>,\n    timeMsByTable: ReadonlyMap<string, number> | undefined,\n    changesByTable: ReadonlyMap<string, number>,\n  ): void {\n    let costs = this.#costs.get(queryID);\n    for (const table of tables) {\n      const changes = changesByTable.get(table);\n      if (!changes) {\n        continue;\n      }\n      if (costs === undefined) {\n        costs = new Map();\n        this.#costs.set(queryID, costs);\n      }\n      const latest = (timeMsByTable?.get(table) ?? 0) / changes;\n      const previous = costs.get(table);\n      const cost =\n        previous === undefined\n          ? latest\n          : previous + LATEST_WEIGHT * (latest - previous);\n      costs.set(table, cost);\n    }\n  }\n\n  /**\n   * The estimated time to push `changes` to the query, or `undefined` if it\n   * has never been pushed any change. A table that the query has never been\n   * pushed a change of is estimated to cost nothing.\n   *\n   * @param tables The tables the query reads.\n   * @param changes The number of changes to push, by table.\n   */\n  estimate(\n    queryID: string,\n    tables: Iterable<string>,\n    changes: ReadonlyMap<string, number>,\n  ): number | undefined {\n    const costs = this.#costs.get(queryID);\n    if (costs === undefined) {\n      return undefined;\n    }\n    let total = 0;\n    for (const table of tables) {\n      total += (changes.get(table) ?? 0) * (costs.get(table) ?? 0);\n    }\n    return total;\n  }\n\n  /** Forgets what was learned about a query. */\n  forget(queryID: string): void {\n    this.#costs.delete(queryID);\n  }\n}\n\n/**\n * Learns what it costs a client group to read a batch of changes, apart from\n * pushing them through its queries, and estimates from it what reading the\n * next one would cost.\n *\n * Reading has three parts, which do not cost the same entries (see\n * {@link ReadParts}): walking the change log, parsing the entries that\n * the walk returns, and looking up the rows of the entries of the tables\n * that are read. What each costs is learned per entry that it was done for.\n * A cost learned per entry of some other count is only right for a batch\n * with the same mix of entries: charged to the entries that are pushed, for\n * instance, the parsing of a batch that is mostly of tables that no query\n * reads makes the next batch that is not look many times as expensive as it\n * is.\n *\n * No query can be cut off for what this costs, as it is not a cost of any\n * one query. It is what pushing costs all of them together, on top of what\n * it costs each (see {@link shouldRebuildInsteadOfReading}).\n */\nexport class ReadCostEstimator {\n  #walkMsPerEntry: number | undefined;\n  #parseMsPerEntry: number | undefined;\n  #lookupMsPerEntry: number | undefined;\n\n  /**\n   * Records what reading a batch cost. Only for a batch that was read to\n   * its end.\n   *\n   * @param timeMs The time spent on each part of reading the batch.\n   * @param entries The entries that each part was done for.\n   */\n  record(timeMs: ReadParts, entries: ReadParts): void {\n    this.#walkMsPerEntry = learn(\n      this.#walkMsPerEntry,\n      timeMs.walk,\n      entries.walk,\n    );\n    this.#parseMsPerEntry = learn(\n      this.#parseMsPerEntry,\n      timeMs.parse,\n      entries.parse,\n    );\n    this.#lookupMsPerEntry = learn(\n      this.#lookupMsPerEntry,\n      timeMs.lookup,\n      entries.lookup,\n    );\n  }\n\n  /**\n   * The estimated time to read a batch, or `undefined` if none has been\n   * read yet.\n   *\n   * @param entries The entries that each part of reading the batch would be\n   *        done for.\n   */\n  estimate(entries: ReadParts): number | undefined {\n    if (this.#walkMsPerEntry === undefined) {\n      return undefined;\n    }\n    return (\n      entries.walk * this.#walkMsPerEntry +\n      entries.parse * (this.#parseMsPerEntry ?? 0) +\n      entries.lookup * (this.#lookupMsPerEntry ?? 0)\n    );\n  }\n}\n\n/**\n * A number for each part of reading a batch of changes: the entries of the\n * change log that the part is done for, or the time that it takes.\n */\nexport type ReadParts = {\n  /**\n   * Walking the change log, which is done for every entry since the\n   * previous snapshot, whether or not the entry is of a table that is read:\n   * the entries are in the order they were committed in, not grouped by\n   * table.\n   */\n  readonly walk: number;\n  /**\n   * Parsing, which is done for every entry that the walk returns. That is\n   * all of them, unless the walk is told which tables are read.\n   */\n  readonly parse: number;\n  /**\n   * Looking up the row in both snapshots, which is done for every entry of\n   * a table that is read. This includes the entries that then turn out to\n   * change nothing (e.g. a row inserted and deleted since the previous\n   * snapshot).\n   */\n  readonly lookup: number;\n};\n\nfunction learn(\n  msPerEntry: number | undefined,\n  timeMs: number,\n  entries: number,\n): number | undefined {\n  return entries > 0 ? decay(msPerEntry, timeMs / entries) : msPerEntry;\n}\n\nfunction decay(previous: number | undefined, latest: number): number {\n  return previous === undefined\n    ? latest\n    : previous + LATEST_WEIGHT * (latest - previous);\n}\n\n/**\n * Whether the queries that are left to push a batch to should all be\n * hydrated again instead, without the batch being read: when reading it and\n * pushing it to them is estimated to cost at least `margin` times what\n * hydrating them does.\n *\n * This is {@link shouldStartOnRebuild} for the queries together, with what\n * reading the batch costs added to what pushing it costs each of them. A\n * query that few of the batch's changes reach is cheap to push to, but the\n * whole batch still has to be walked to find those changes.\n *\n * @param estimatedReadMs `undefined` if there is no estimate, in which case\n *        the batch is read.\n * @param queries What pushing the batch is estimated to cost each query\n *        (nothing, if it has no estimate), and what hydrating it took.\n */\nexport function shouldRebuildInsteadOfReading(\n  estimatedReadMs: number | undefined,\n  queries: Iterable<{\n    readonly estimatedPushMs: number | undefined;\n    readonly hydrationTimeMs: number;\n  }>,\n  margin: number,\n): boolean {\n  if (estimatedReadMs === undefined) {\n    return false;\n  }\n  let pushMs = estimatedReadMs;\n  let hydrationMs = 0;\n  for (const query of queries) {\n    pushMs += query.estimatedPushMs ?? 0;\n    hydrationMs += Math.max(query.hydrationTimeMs, MIN_PUSH_CUTOFF_MS);\n  }\n  return hydrationMs > 0 && pushMs >= margin * hydrationMs;\n}\n\n/**\n * Whether a query should start an advancement on rebuild, i.e. be hydrated\n * again without being pushed any of the advancement's changes: when pushing\n * them is estimated to cost at least `margin` times what hydrating it does.\n *\n * The margin is for the imprecision of the estimate. A query without one\n * starts on push.\n */\nexport function shouldStartOnRebuild(\n  estimatedPushMs: number | undefined,\n  hydrationTimeMs: number,\n  margin: number,\n): boolean {\n  return (\n    estimatedPushMs !== undefined &&\n    estimatedPushMs >= margin * Math.max(hydrationTimeMs, MIN_PUSH_CUTOFF_MS)\n  );\n}\n"],"mappings":";;;;;;;AAQA,IAAM,gBAAgB;;;;;;;;;;;;AAatB,IAAa,oBAAb,MAA+B;;CAE7B,yBAAkB,IAAI,IAAiC;;;;;;;;;;;;;;CAevD,OACE,SACA,QACA,eACA,gBACM;EACN,IAAI,QAAQ,KAAKA,OAAO,IAAI,OAAO;EACnC,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,UAAU,eAAe,IAAI,KAAK;GACxC,IAAI,CAAC,SACH;GAEF,IAAI,UAAU,KAAA,GAAW;IACvB,wBAAQ,IAAI,IAAI;IAChB,KAAKA,OAAO,IAAI,SAAS,KAAK;GAChC;GACA,MAAM,UAAU,eAAe,IAAI,KAAK,KAAK,KAAK;GAClD,MAAM,WAAW,MAAM,IAAI,KAAK;GAChC,MAAM,OACJ,aAAa,KAAA,IACT,SACA,WAAW,iBAAiB,SAAS;GAC3C,MAAM,IAAI,OAAO,IAAI;EACvB;CACF;;;;;;;;;CAUA,SACE,SACA,QACA,SACoB;EACpB,MAAM,QAAQ,KAAKA,OAAO,IAAI,OAAO;EACrC,IAAI,UAAU,KAAA,GACZ;EAEF,IAAI,QAAQ;EACZ,KAAK,MAAM,SAAS,QAClB,UAAU,QAAQ,IAAI,KAAK,KAAK,MAAM,MAAM,IAAI,KAAK,KAAK;EAE5D,OAAO;CACT;;CAGA,OAAO,SAAuB;EAC5B,KAAKA,OAAO,OAAO,OAAO;CAC5B;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,oBAAb,MAA+B;CAC7B;CACA;CACA;;;;;;;;CASA,OAAO,QAAmB,SAA0B;EAClD,KAAKC,kBAAkB,MACrB,KAAKA,iBACL,OAAO,MACP,QAAQ,IACV;EACA,KAAKC,mBAAmB,MACtB,KAAKA,kBACL,OAAO,OACP,QAAQ,KACV;EACA,KAAKC,oBAAoB,MACvB,KAAKA,mBACL,OAAO,QACP,QAAQ,MACV;CACF;;;;;;;;CASA,SAAS,SAAwC;EAC/C,IAAI,KAAKF,oBAAoB,KAAA,GAC3B;EAEF,OACE,QAAQ,OAAO,KAAKA,kBACpB,QAAQ,SAAS,KAAKC,oBAAoB,KAC1C,QAAQ,UAAU,KAAKC,qBAAqB;CAEhD;AACF;AA4BA,SAAS,MACP,YACA,QACA,SACoB;CACpB,OAAO,UAAU,IAAI,MAAM,YAAY,SAAS,OAAO,IAAI;AAC7D;AAEA,SAAS,MAAM,UAA8B,QAAwB;CACnE,OAAO,aAAa,KAAA,IAChB,SACA,WAAW,iBAAiB,SAAS;AAC3C;;;;;;;;;;;;;;;;;AAkBA,SAAgB,8BACd,iBACA,SAIA,QACS;CACT,IAAI,oBAAoB,KAAA,GACtB,OAAO;CAET,IAAI,SAAS;CACb,IAAI,cAAc;CAClB,KAAK,MAAM,SAAS,SAAS;EAC3B,UAAU,MAAM,mBAAmB;EACnC,eAAe,KAAK,IAAI,MAAM,iBAAA,CAAmC;CACnE;CACA,OAAO,cAAc,KAAK,UAAU,SAAS;AAC/C;;;;;;;;;AAUA,SAAgB,qBACd,iBACA,iBACA,QACS;CACT,OACE,oBAAoB,KAAA,KACpB,mBAAmB,SAAS,KAAK,IAAI,iBAAA,CAAmC;AAE5E"}

package/out/zero-cache/src/services/view-syncer/push-cutoff.d.ts

@@ -0,0 +1,55 @@
+/** What an advancement has pushed to a query so far. */
+export type QueryPushProgress = {
+    readonly queryID: string;
+    /** The time spent processing pushes to the query in this advancement. */
+    readonly pushTimeMs: number;
+    /** The number of changes pushed to the query in this advancement. */
+    readonly changes: number;
+    /** The query's hydration time, i.e. what rebuilding it is expected to cost. */
+    readonly hydrationTimeMs: number;
+};
+/** Whether to stop pushing an advancement's changes to a query. */
+export type ShouldCutOffPush = (progress: QueryPushProgress) => boolean;
+/**
+ * The least a query's hydration is taken to cost when deciding whether to
+ * stop pushing to it. Small queries hydrate in well under a millisecond,
+ * where one push can take longer than the hydration did on timer noise alone,
+ * and hydrating again saves too little to be worth its fixed costs.
+ */
+export declare const MIN_PUSH_CUTOFF_MS = 2;
+/**
+ * Whether to stop pushing an advancement's changes to a query and hydrate it
+ * again instead: once the pushes have taken as long as the hydration is
+ * expected to.
+ *
+ * This is the ski-rental strategy (rent until the rent paid equals the
+ * purchase price, then buy). Whatever the actual costs turn out to be, the
+ * query costs at most about twice the cheaper of pushing every change and
+ * hydrating from the start, plus the one change that crossed the line. It
+ * needs no estimate of what the remaining changes will cost.
+ */
+export declare function shouldCutOffPush({ pushTimeMs, hydrationTimeMs, }: Pick<QueryPushProgress, 'pushTimeMs' | 'hydrationTimeMs'>): boolean;
+/**
+ * Bounds the cost of one advancement query by query: each query is pushed
+ * changes until {@link ShouldCutOffPush} says to stop, and is then hydrated
+ * again once the advancement is done.
+ *
+ * An advancement with a cutoff is not subject to the client group's
+ * advancement time limit, which resets every pipeline of the client group.
+ * The two are alternatives and are never applied together.
+ */
+export declare class PushCutoff {
+    #private;
+    constructor(shouldCutOff?: ShouldCutOffPush);
+    /** Called for each push to a query. */
+    recordPush(queryID: string): void;
+    /**
+     * Called between changes, when no push is in progress. Returns the queries
+     * to stop pushing to, of those pushed to since the last call.
+     *
+     * @param progressOf The progress of a query, or `undefined` if it is no
+     *        longer being pushed to.
+     */
+    takeCutOff(progressOf: (queryID: string) => QueryPushProgress | undefined): QueryPushProgress[];
+}
+//# sourceMappingURL=push-cutoff.d.ts.map

package/out/zero-cache/src/services/view-syncer/push-cutoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-cutoff.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/push-cutoff.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,mEAAmE;AACnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,iBAAiB,KAAK,OAAO,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,UAAU,EACV,eAAe,GAChB,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,GAAG,iBAAiB,CAAC,GAAG,OAAO,CAErE;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU;;IAKrB,YAAY,YAAY,GAAE,gBAAmC,EAE5D;IAED,uCAAuC;IACvC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEhC;IAED;;;;;;OAMG;IACH,UAAU,CACR,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,GAC7D,iBAAiB,EAAE,CAarB;CACF"}

package/out/zero-cache/src/services/view-syncer/push-cutoff.js

@@ -0,0 +1,56 @@
+/**
+* Whether to stop pushing an advancement's changes to a query and hydrate it
+* again instead: once the pushes have taken as long as the hydration is
+* expected to.
+*
+* This is the ski-rental strategy (rent until the rent paid equals the
+* purchase price, then buy). Whatever the actual costs turn out to be, the
+* query costs at most about twice the cheaper of pushing every change and
+* hydrating from the start, plus the one change that crossed the line. It
+* needs no estimate of what the remaining changes will cost.
+*/
+function shouldCutOffPush({ pushTimeMs, hydrationTimeMs }) {
+	return pushTimeMs >= Math.max(hydrationTimeMs, 2);
+}
+/**
+* Bounds the cost of one advancement query by query: each query is pushed
+* changes until {@link ShouldCutOffPush} says to stop, and is then hydrated
+* again once the advancement is done.
+*
+* An advancement with a cutoff is not subject to the client group's
+* advancement time limit, which resets every pipeline of the client group.
+* The two are alternatives and are never applied together.
+*/
+var PushCutoff = class {
+	#shouldCutOff;
+	/** The queries pushed to since the last {@link takeCutOff}. */
+	#pushed = /* @__PURE__ */ new Set();
+	constructor(shouldCutOff = shouldCutOffPush) {
+		this.#shouldCutOff = shouldCutOff;
+	}
+	/** Called for each push to a query. */
+	recordPush(queryID) {
+		this.#pushed.add(queryID);
+	}
+	/**
+	* Called between changes, when no push is in progress. Returns the queries
+	* to stop pushing to, of those pushed to since the last call.
+	*
+	* @param progressOf The progress of a query, or `undefined` if it is no
+	*        longer being pushed to.
+	*/
+	takeCutOff(progressOf) {
+		if (this.#pushed.size === 0) return [];
+		const cutOff = [];
+		for (const queryID of this.#pushed) {
+			const progress = progressOf(queryID);
+			if (progress !== void 0 && this.#shouldCutOff(progress)) cutOff.push(progress);
+		}
+		this.#pushed.clear();
+		return cutOff;
+	}
+};
+//#endregion
+export { PushCutoff, shouldCutOffPush };
+
+//# sourceMappingURL=push-cutoff.js.map

package/out/zero-cache/src/services/view-syncer/push-cutoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-cutoff.js","names":["#shouldCutOff","#pushed"],"sources":["../../../../../../zero-cache/src/services/view-syncer/push-cutoff.ts"],"sourcesContent":["/** What an advancement has pushed to a query so far. */\nexport type QueryPushProgress = {\n  readonly queryID: string;\n  /** The time spent processing pushes to the query in this advancement. */\n  readonly pushTimeMs: number;\n  /** The number of changes pushed to the query in this advancement. */\n  readonly changes: number;\n  /** The query's hydration time, i.e. what rebuilding it is expected to cost. */\n  readonly hydrationTimeMs: number;\n};\n\n/** Whether to stop pushing an advancement's changes to a query. */\nexport type ShouldCutOffPush = (progress: QueryPushProgress) => boolean;\n\n/**\n * The least a query's hydration is taken to cost when deciding whether to\n * stop pushing to it. Small queries hydrate in well under a millisecond,\n * where one push can take longer than the hydration did on timer noise alone,\n * and hydrating again saves too little to be worth its fixed costs.\n */\nexport const MIN_PUSH_CUTOFF_MS = 2;\n\n/**\n * Whether to stop pushing an advancement's changes to a query and hydrate it\n * again instead: once the pushes have taken as long as the hydration is\n * expected to.\n *\n * This is the ski-rental strategy (rent until the rent paid equals the\n * purchase price, then buy). Whatever the actual costs turn out to be, the\n * query costs at most about twice the cheaper of pushing every change and\n * hydrating from the start, plus the one change that crossed the line. It\n * needs no estimate of what the remaining changes will cost.\n */\nexport function shouldCutOffPush({\n  pushTimeMs,\n  hydrationTimeMs,\n}: Pick<QueryPushProgress, 'pushTimeMs' | 'hydrationTimeMs'>): boolean {\n  return pushTimeMs >= Math.max(hydrationTimeMs, MIN_PUSH_CUTOFF_MS);\n}\n\n/**\n * Bounds the cost of one advancement query by query: each query is pushed\n * changes until {@link ShouldCutOffPush} says to stop, and is then hydrated\n * again once the advancement is done.\n *\n * An advancement with a cutoff is not subject to the client group's\n * advancement time limit, which resets every pipeline of the client group.\n * The two are alternatives and are never applied together.\n */\nexport class PushCutoff {\n  readonly #shouldCutOff: ShouldCutOffPush;\n  /** The queries pushed to since the last {@link takeCutOff}. */\n  readonly #pushed = new Set<string>();\n\n  constructor(shouldCutOff: ShouldCutOffPush = shouldCutOffPush) {\n    this.#shouldCutOff = shouldCutOff;\n  }\n\n  /** Called for each push to a query. */\n  recordPush(queryID: string): void {\n    this.#pushed.add(queryID);\n  }\n\n  /**\n   * Called between changes, when no push is in progress. Returns the queries\n   * to stop pushing to, of those pushed to since the last call.\n   *\n   * @param progressOf The progress of a query, or `undefined` if it is no\n   *        longer being pushed to.\n   */\n  takeCutOff(\n    progressOf: (queryID: string) => QueryPushProgress | undefined,\n  ): QueryPushProgress[] {\n    if (this.#pushed.size === 0) {\n      return [];\n    }\n    const cutOff: QueryPushProgress[] = [];\n    for (const queryID of this.#pushed) {\n      const progress = progressOf(queryID);\n      if (progress !== undefined && this.#shouldCutOff(progress)) {\n        cutOff.push(progress);\n      }\n    }\n    this.#pushed.clear();\n    return cutOff;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAiCA,SAAgB,iBAAiB,EAC/B,YACA,mBACqE;CACrE,OAAO,cAAc,KAAK,IAAI,iBAAA,CAAmC;AACnE;;;;;;;;;;AAWA,IAAa,aAAb,MAAwB;CACtB;;CAEA,0BAAmB,IAAI,IAAY;CAEnC,YAAY,eAAiC,kBAAkB;EAC7D,KAAKA,gBAAgB;CACvB;;CAGA,WAAW,SAAuB;EAChC,KAAKC,QAAQ,IAAI,OAAO;CAC1B;;;;;;;;CASA,WACE,YACqB;EACrB,IAAI,KAAKA,QAAQ,SAAS,GACxB,OAAO,CAAC;EAEV,MAAM,SAA8B,CAAC;EACrC,KAAK,MAAM,WAAW,KAAKA,SAAS;GAClC,MAAM,WAAW,WAAW,OAAO;GACnC,IAAI,aAAa,KAAA,KAAa,KAAKD,cAAc,QAAQ,GACvD,OAAO,KAAK,QAAQ;EAExB;EACA,KAAKC,QAAQ,MAAM;EACnB,OAAO;CACT;AACF"}

package/out/zero-cache/src/services/view-syncer/query-covering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-covering.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/query-covering.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,GAAG,EAOT,MAAM,sCAAsC,CAAC;AAE9C,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAOF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,OAAO,CAErE;AAED,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GAChD,aAAa,GAAG,SAAS,CAK3B;AAED,qBAAa,kBAAkB;;IAI7B,YAAY,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAM7D;IAED,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAY9C;IAED,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAgB5B;IAED,iBAAiB,CACf,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,GAAG,GACd,aAAa,GAAG,SAAS,CAoB3B;CACF"}
+{"version":3,"file":"query-covering.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/query-covering.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,GAAG,EAOT,MAAM,sCAAsC,CAAC;AAE9C,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAOF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,OAAO,CAErE;AAED,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GAChD,aAAa,GAAG,SAAS,CAK3B;AAED,qBAAa,kBAAkB;;IAI7B,YAAY,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAM7D;IAED,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAU9C;IAED,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAgB5B;IAED,iBAAiB,CACf,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,GAAG,GACd,aAAa,GAAG,SAAS,CAoB3B;CACF"}

package/out/zero-cache/src/services/view-syncer/query-covering.js

@@ -1,4 +1,5 @@
 import { deepEqual } from "../../../../shared/src/json.js";
+import { getOrInsertComputed, newMap } from "../../../../shared/src/map.js";
 import { normalizeAST } from "../../../../zero-protocol/src/ast.js";
 //#region ../zero-cache/src/services/view-syncer/query-covering.ts
 var QueryCoveringIndex = class {
@@ -11,12 +12,7 @@ var QueryCoveringIndex = class {
 		this.remove(queryID);
 		const normalizedAst = normalizeAST(query.transformedAst);
 		const root = rootKey(normalizedAst);
-		let queries = this.#byRoot.get(root);
-		if (!queries) {
-			queries = /* @__PURE__ */ new Map();
-			this.#byRoot.set(root, queries);
-		}
-		queries.set(queryID, {
+		getOrInsertComputed(this.#byRoot, root, newMap).set(queryID, {
 			...query,
 			normalizedAst
 		});

package/out/zero-cache/src/services/view-syncer/query-covering.js.map

@@ -1 +1 @@
-{"version":3,"file":"query-covering.js","names":["#byRoot","#queryIDToRoot"],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-covering.ts"],"sourcesContent":["import {\n  deepEqual,\n  type ReadonlyJSONValue,\n} from '../../../../shared/src/json.ts';\nimport {\n  normalizeAST,\n  type AST,\n  type Condition,\n  type CorrelatedSubquery,\n  type CorrelatedSubqueryCondition,\n  type LiteralValue,\n  type NormalizedAST,\n  type SimpleCondition,\n} from '../../../../zero-protocol/src/ast.ts';\n\nexport type RunningQuery = {\n  readonly transformedAst: AST;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\nexport type CoveringQuery = {\n  readonly queryID: string;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\ntype NonNullScalarLiteralValue = string | number | boolean;\ntype IndexedRunningQuery = RunningQuery & {\n  readonly normalizedAst: NormalizedAST;\n};\n\n/**\n * Returns true when every row that can be produced by `covered` is also\n * produced by `covering`.\n *\n * This is intentionally conservative: unsupported cases return false rather\n * than guessing. It is used for shadow logging only.\n */\nexport function isQueryCoveredBy(covered: AST, covering: AST): boolean {\n  return astCoveredBy(normalizeAST(covered), normalizeAST(covering));\n}\n\nexport function findCoveringQuery(\n  coveredQueryID: string,\n  coveredAst: AST,\n  runningQueries: ReadonlyMap<string, RunningQuery>,\n): CoveringQuery | undefined {\n  return new QueryCoveringIndex(runningQueries).findCoveringQuery(\n    coveredQueryID,\n    coveredAst,\n  );\n}\n\nexport class QueryCoveringIndex {\n  readonly #byRoot = new Map<string, Map<string, IndexedRunningQuery>>();\n  readonly #queryIDToRoot = new Map<string, string>();\n\n  constructor(runningQueries?: ReadonlyMap<string, RunningQuery>) {\n    if (runningQueries) {\n      for (const [queryID, query] of runningQueries) {\n        this.add(queryID, query);\n      }\n    }\n  }\n\n  add(queryID: string, query: RunningQuery): void {\n    this.remove(queryID);\n\n    const normalizedAst = normalizeAST(query.transformedAst);\n    const root = rootKey(normalizedAst);\n    let queries = this.#byRoot.get(root);\n    if (!queries) {\n      queries = new Map();\n      this.#byRoot.set(root, queries);\n    }\n    queries.set(queryID, {...query, normalizedAst});\n    this.#queryIDToRoot.set(queryID, root);\n  }\n\n  remove(queryID: string): void {\n    const root = this.#queryIDToRoot.get(queryID);\n    if (root === undefined) {\n      return;\n    }\n\n    this.#queryIDToRoot.delete(queryID);\n    const queries = this.#byRoot.get(root);\n    if (!queries) {\n      return;\n    }\n\n    queries.delete(queryID);\n    if (queries.size === 0) {\n      this.#byRoot.delete(root);\n    }\n  }\n\n  findCoveringQuery(\n    coveredQueryID: string,\n    coveredAst: AST,\n  ): CoveringQuery | undefined {\n    const normalizedCoveredAst = normalizeAST(coveredAst);\n    const queries = this.#byRoot.get(rootKey(normalizedCoveredAst));\n    if (!queries) {\n      return undefined;\n    }\n\n    for (const [queryID, query] of queries) {\n      if (queryID === coveredQueryID) {\n        continue;\n      }\n      if (astCoveredBy(normalizedCoveredAst, query.normalizedAst)) {\n        return {\n          queryID,\n          transformationHash: query.transformationHash,\n          ...(query.queryName !== undefined && {queryName: query.queryName}),\n        };\n      }\n    }\n    return undefined;\n  }\n}\n\nfunction rootKey(ast: NormalizedAST): string {\n  return JSON.stringify([ast.schema, ast.table, ast.alias]);\n}\n\nfunction astCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  return (\n    covered.schema === covering.schema &&\n    covered.table === covering.table &&\n    covered.alias === covering.alias &&\n    conditionImplies(covered.where, covering.where) &&\n    relatedCoveredBy(covered.related, covering.related) &&\n    boundsCoveredBy(covered, covering)\n  );\n}\n\nfunction boundsCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  if (covering.limit === undefined) {\n    if (covering.start === undefined) {\n      return true;\n    }\n    return (\n      jsonEqual(covered.start, covering.start) &&\n      jsonEqual(covered.orderBy, covering.orderBy)\n    );\n  }\n\n  if (covered.limit === undefined || covering.limit < covered.limit) {\n    return false;\n  }\n\n  // A limited broader query does not necessarily contain a limited narrower\n  // query. The ordered input to the limit must be equivalent.\n  return (\n    conditionEquivalent(covered.where, covering.where) &&\n    jsonEqual(covered.start, covering.start) &&\n    jsonEqual(covered.orderBy, covering.orderBy)\n  );\n}\n\nfunction relatedCoveredBy(\n  covered: readonly CorrelatedSubquery[] | undefined,\n  covering: readonly CorrelatedSubquery[] | undefined,\n): boolean {\n  if (covered === undefined || covered.length === 0) {\n    return true;\n  }\n  if (covering === undefined) {\n    return false;\n  }\n  return covered.every(coveredRelated =>\n    covering.some(\n      coveringRelated =>\n        sameRelatedEdge(coveredRelated, coveringRelated) &&\n        astCoveredBy(\n          coveredRelated.subquery as NormalizedAST,\n          coveringRelated.subquery as NormalizedAST,\n        ),\n    ),\n  );\n}\n\nfunction conditionEquivalent(\n  a: Condition | undefined,\n  b: Condition | undefined,\n): boolean {\n  return conditionImplies(a, b) && conditionImplies(b, a);\n}\n\nfunction conditionImplies(\n  covered: Condition | undefined,\n  covering: Condition | undefined,\n): boolean {\n  if (covering === undefined) {\n    return true;\n  }\n  if (covered === undefined) {\n    return false;\n  }\n  if (jsonEqual(covered, covering)) {\n    return true;\n  }\n\n  if (covered.type === 'or') {\n    return covered.conditions.every(c => conditionImplies(c, covering));\n  }\n  if (covering.type === 'or') {\n    return covering.conditions.some(c => conditionImplies(covered, c));\n  }\n  if (covering.type === 'and') {\n    return covering.conditions.every(c => conditionImplies(covered, c));\n  }\n  if (covered.type === 'and') {\n    return covered.conditions.some(c => conditionImplies(c, covering));\n  }\n  if (covered.type === 'simple' && covering.type === 'simple') {\n    return simpleConditionImplies(covered, covering);\n  }\n  if (\n    covered.type === 'correlatedSubquery' &&\n    covering.type === 'correlatedSubquery'\n  ) {\n    return correlatedConditionImplies(covered, covering);\n  }\n  return false;\n}\n\nfunction correlatedConditionImplies(\n  covered: CorrelatedSubqueryCondition,\n  covering: CorrelatedSubqueryCondition,\n): boolean {\n  if (\n    covered.op !== covering.op ||\n    covered.scalar !== covering.scalar ||\n    !sameRelatedEdge(covered.related, covering.related)\n  ) {\n    return false;\n  }\n\n  if (covered.op === 'EXISTS') {\n    return astCoveredBy(\n      covered.related.subquery as NormalizedAST,\n      covering.related.subquery as NormalizedAST,\n    );\n  }\n\n  return astCoveredBy(\n    covering.related.subquery as NormalizedAST,\n    covered.related.subquery as NormalizedAST,\n  );\n}\n\nfunction sameRelatedEdge(\n  a: CorrelatedSubquery,\n  b: CorrelatedSubquery,\n): boolean {\n  return (\n    jsonEqual(a.correlation, b.correlation) &&\n    a.hidden === b.hidden &&\n    a.system === b.system &&\n    a.subquery.alias === b.subquery.alias\n  );\n}\n\nfunction simpleConditionImplies(\n  covered: SimpleCondition,\n  covering: SimpleCondition,\n): boolean {\n  const coveredParts = columnLiteralParts(covered);\n  const coveringParts = columnLiteralParts(covering);\n  if (!coveredParts || !coveringParts) {\n    return false;\n  }\n  if (coveredParts.column !== coveringParts.column) {\n    return false;\n  }\n\n  const {op: coveredOp, value: coveredValue} = coveredParts;\n  const {op: coveringOp, value: coveringValue} = coveringParts;\n\n  if (isEqualityOp(coveredOp) && isNonNullScalarLiteralValue(coveredValue)) {\n    return equalityImplies(coveredValue, coveringOp, coveringValue);\n  }\n\n  if (\n    coveredOp === 'IN' &&\n    coveringOp === 'IN' &&\n    Array.isArray(coveredValue) &&\n    Array.isArray(coveringValue)\n  ) {\n    return coveredValue.every(v => literalArrayIncludes(coveringValue, v));\n  }\n\n  if (isNumericOrderOp(coveredOp) && isNumericOrderOp(coveringOp)) {\n    return orderConditionImplies(\n      coveredOp,\n      coveredValue,\n      coveringOp,\n      coveringValue,\n    );\n  }\n\n  return false;\n}\n\nfunction equalityImplies(\n  value: NonNullScalarLiteralValue,\n  coveringOp: SimpleCondition['op'],\n  coveringValue: LiteralValue,\n): boolean {\n  switch (coveringOp) {\n    case '=':\n    case 'IS':\n      return jsonEqual(value, coveringValue);\n    case '!=':\n    case 'IS NOT':\n      return !jsonEqual(value, coveringValue);\n    case 'IN':\n      return (\n        Array.isArray(coveringValue) &&\n        literalArrayIncludes(coveringValue, value)\n      );\n    case '<':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value < coveringValue\n      );\n    case '<=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value <= coveringValue\n      );\n    case '>':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value > coveringValue\n      );\n    case '>=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value >= coveringValue\n      );\n    case 'NOT IN':\n    case 'LIKE':\n    case 'NOT LIKE':\n    case 'ILIKE':\n    case 'NOT ILIKE':\n      return false;\n  }\n}\n\nfunction orderConditionImplies(\n  coveredOp: '<' | '>' | '<=' | '>=',\n  coveredValue: LiteralValue,\n  coveringOp: '<' | '>' | '<=' | '>=',\n  coveringValue: LiteralValue,\n): boolean {\n  if (typeof coveredValue !== 'number' || typeof coveringValue !== 'number') {\n    return false;\n  }\n\n  switch (coveredOp) {\n    case '>':\n      return (\n        (coveringOp === '>' && coveredValue >= coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '>=':\n      return (\n        (coveringOp === '>' && coveredValue > coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '<':\n      return (\n        (coveringOp === '<' && coveredValue <= coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n    case '<=':\n      return (\n        (coveringOp === '<' && coveredValue < coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n  }\n}\n\nfunction columnLiteralParts(condition: SimpleCondition):\n  | {\n      readonly column: string;\n      readonly op: SimpleCondition['op'];\n      readonly value: LiteralValue;\n    }\n  | undefined {\n  if (condition.left.type !== 'column' || condition.right.type !== 'literal') {\n    return undefined;\n  }\n  return {\n    column: condition.left.name,\n    op: condition.op,\n    value: condition.right.value,\n  };\n}\n\nfunction isEqualityOp(op: SimpleCondition['op']): op is '=' | 'IS' {\n  return op === '=' || op === 'IS';\n}\n\nfunction isNumericOrderOp(\n  op: SimpleCondition['op'],\n): op is '<' | '>' | '<=' | '>=' {\n  return op === '<' || op === '>' || op === '<=' || op === '>=';\n}\n\nfunction isNonNullScalarLiteralValue(\n  value: LiteralValue,\n): value is NonNullScalarLiteralValue {\n  return value !== null && !Array.isArray(value);\n}\n\nfunction literalArrayIncludes(\n  values: ReadonlyArray<string | number | boolean>,\n  value: string | number | boolean | null,\n): boolean {\n  return values.some(v => jsonEqual(v, value));\n}\n\nfunction jsonEqual(a: unknown, b: unknown): boolean {\n  return deepEqual(\n    a as ReadonlyJSONValue | undefined,\n    b as ReadonlyJSONValue | undefined,\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"query-covering.js","names":["#byRoot","#queryIDToRoot"],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-covering.ts"],"sourcesContent":["import {\n  deepEqual,\n  type ReadonlyJSONValue,\n} from '../../../../shared/src/json.ts';\nimport {getOrInsertComputed, newMap} from '../../../../shared/src/map.ts';\nimport {\n  normalizeAST,\n  type AST,\n  type Condition,\n  type CorrelatedSubquery,\n  type CorrelatedSubqueryCondition,\n  type LiteralValue,\n  type NormalizedAST,\n  type SimpleCondition,\n} from '../../../../zero-protocol/src/ast.ts';\n\nexport type RunningQuery = {\n  readonly transformedAst: AST;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\nexport type CoveringQuery = {\n  readonly queryID: string;\n  readonly transformationHash: string;\n  readonly queryName?: string | undefined;\n};\n\ntype NonNullScalarLiteralValue = string | number | boolean;\ntype IndexedRunningQuery = RunningQuery & {\n  readonly normalizedAst: NormalizedAST;\n};\n\n/**\n * Returns true when every row that can be produced by `covered` is also\n * produced by `covering`.\n *\n * This is intentionally conservative: unsupported cases return false rather\n * than guessing. It is used for shadow logging only.\n */\nexport function isQueryCoveredBy(covered: AST, covering: AST): boolean {\n  return astCoveredBy(normalizeAST(covered), normalizeAST(covering));\n}\n\nexport function findCoveringQuery(\n  coveredQueryID: string,\n  coveredAst: AST,\n  runningQueries: ReadonlyMap<string, RunningQuery>,\n): CoveringQuery | undefined {\n  return new QueryCoveringIndex(runningQueries).findCoveringQuery(\n    coveredQueryID,\n    coveredAst,\n  );\n}\n\nexport class QueryCoveringIndex {\n  readonly #byRoot = new Map<string, Map<string, IndexedRunningQuery>>();\n  readonly #queryIDToRoot = new Map<string, string>();\n\n  constructor(runningQueries?: ReadonlyMap<string, RunningQuery>) {\n    if (runningQueries) {\n      for (const [queryID, query] of runningQueries) {\n        this.add(queryID, query);\n      }\n    }\n  }\n\n  add(queryID: string, query: RunningQuery): void {\n    this.remove(queryID);\n\n    const normalizedAst = normalizeAST(query.transformedAst);\n    const root = rootKey(normalizedAst);\n    getOrInsertComputed(this.#byRoot, root, newMap).set(queryID, {\n      ...query,\n      normalizedAst,\n    });\n    this.#queryIDToRoot.set(queryID, root);\n  }\n\n  remove(queryID: string): void {\n    const root = this.#queryIDToRoot.get(queryID);\n    if (root === undefined) {\n      return;\n    }\n\n    this.#queryIDToRoot.delete(queryID);\n    const queries = this.#byRoot.get(root);\n    if (!queries) {\n      return;\n    }\n\n    queries.delete(queryID);\n    if (queries.size === 0) {\n      this.#byRoot.delete(root);\n    }\n  }\n\n  findCoveringQuery(\n    coveredQueryID: string,\n    coveredAst: AST,\n  ): CoveringQuery | undefined {\n    const normalizedCoveredAst = normalizeAST(coveredAst);\n    const queries = this.#byRoot.get(rootKey(normalizedCoveredAst));\n    if (!queries) {\n      return undefined;\n    }\n\n    for (const [queryID, query] of queries) {\n      if (queryID === coveredQueryID) {\n        continue;\n      }\n      if (astCoveredBy(normalizedCoveredAst, query.normalizedAst)) {\n        return {\n          queryID,\n          transformationHash: query.transformationHash,\n          ...(query.queryName !== undefined && {queryName: query.queryName}),\n        };\n      }\n    }\n    return undefined;\n  }\n}\n\nfunction rootKey(ast: NormalizedAST): string {\n  return JSON.stringify([ast.schema, ast.table, ast.alias]);\n}\n\nfunction astCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  return (\n    covered.schema === covering.schema &&\n    covered.table === covering.table &&\n    covered.alias === covering.alias &&\n    conditionImplies(covered.where, covering.where) &&\n    relatedCoveredBy(covered.related, covering.related) &&\n    boundsCoveredBy(covered, covering)\n  );\n}\n\nfunction boundsCoveredBy(\n  covered: NormalizedAST,\n  covering: NormalizedAST,\n): boolean {\n  if (covering.limit === undefined) {\n    if (covering.start === undefined) {\n      return true;\n    }\n    return (\n      jsonEqual(covered.start, covering.start) &&\n      jsonEqual(covered.orderBy, covering.orderBy)\n    );\n  }\n\n  if (covered.limit === undefined || covering.limit < covered.limit) {\n    return false;\n  }\n\n  // A limited broader query does not necessarily contain a limited narrower\n  // query. The ordered input to the limit must be equivalent.\n  return (\n    conditionEquivalent(covered.where, covering.where) &&\n    jsonEqual(covered.start, covering.start) &&\n    jsonEqual(covered.orderBy, covering.orderBy)\n  );\n}\n\nfunction relatedCoveredBy(\n  covered: readonly CorrelatedSubquery[] | undefined,\n  covering: readonly CorrelatedSubquery[] | undefined,\n): boolean {\n  if (covered === undefined || covered.length === 0) {\n    return true;\n  }\n  if (covering === undefined) {\n    return false;\n  }\n  return covered.every(coveredRelated =>\n    covering.some(\n      coveringRelated =>\n        sameRelatedEdge(coveredRelated, coveringRelated) &&\n        astCoveredBy(\n          coveredRelated.subquery as NormalizedAST,\n          coveringRelated.subquery as NormalizedAST,\n        ),\n    ),\n  );\n}\n\nfunction conditionEquivalent(\n  a: Condition | undefined,\n  b: Condition | undefined,\n): boolean {\n  return conditionImplies(a, b) && conditionImplies(b, a);\n}\n\nfunction conditionImplies(\n  covered: Condition | undefined,\n  covering: Condition | undefined,\n): boolean {\n  if (covering === undefined) {\n    return true;\n  }\n  if (covered === undefined) {\n    return false;\n  }\n  if (jsonEqual(covered, covering)) {\n    return true;\n  }\n\n  if (covered.type === 'or') {\n    return covered.conditions.every(c => conditionImplies(c, covering));\n  }\n  if (covering.type === 'or') {\n    return covering.conditions.some(c => conditionImplies(covered, c));\n  }\n  if (covering.type === 'and') {\n    return covering.conditions.every(c => conditionImplies(covered, c));\n  }\n  if (covered.type === 'and') {\n    return covered.conditions.some(c => conditionImplies(c, covering));\n  }\n  if (covered.type === 'simple' && covering.type === 'simple') {\n    return simpleConditionImplies(covered, covering);\n  }\n  if (\n    covered.type === 'correlatedSubquery' &&\n    covering.type === 'correlatedSubquery'\n  ) {\n    return correlatedConditionImplies(covered, covering);\n  }\n  return false;\n}\n\nfunction correlatedConditionImplies(\n  covered: CorrelatedSubqueryCondition,\n  covering: CorrelatedSubqueryCondition,\n): boolean {\n  if (\n    covered.op !== covering.op ||\n    covered.scalar !== covering.scalar ||\n    !sameRelatedEdge(covered.related, covering.related)\n  ) {\n    return false;\n  }\n\n  if (covered.op === 'EXISTS') {\n    return astCoveredBy(\n      covered.related.subquery as NormalizedAST,\n      covering.related.subquery as NormalizedAST,\n    );\n  }\n\n  return astCoveredBy(\n    covering.related.subquery as NormalizedAST,\n    covered.related.subquery as NormalizedAST,\n  );\n}\n\nfunction sameRelatedEdge(\n  a: CorrelatedSubquery,\n  b: CorrelatedSubquery,\n): boolean {\n  return (\n    jsonEqual(a.correlation, b.correlation) &&\n    a.hidden === b.hidden &&\n    a.system === b.system &&\n    a.subquery.alias === b.subquery.alias\n  );\n}\n\nfunction simpleConditionImplies(\n  covered: SimpleCondition,\n  covering: SimpleCondition,\n): boolean {\n  const coveredParts = columnLiteralParts(covered);\n  const coveringParts = columnLiteralParts(covering);\n  if (!coveredParts || !coveringParts) {\n    return false;\n  }\n  if (coveredParts.column !== coveringParts.column) {\n    return false;\n  }\n\n  const {op: coveredOp, value: coveredValue} = coveredParts;\n  const {op: coveringOp, value: coveringValue} = coveringParts;\n\n  if (isEqualityOp(coveredOp) && isNonNullScalarLiteralValue(coveredValue)) {\n    return equalityImplies(coveredValue, coveringOp, coveringValue);\n  }\n\n  if (\n    coveredOp === 'IN' &&\n    coveringOp === 'IN' &&\n    Array.isArray(coveredValue) &&\n    Array.isArray(coveringValue)\n  ) {\n    return coveredValue.every(v => literalArrayIncludes(coveringValue, v));\n  }\n\n  if (isNumericOrderOp(coveredOp) && isNumericOrderOp(coveringOp)) {\n    return orderConditionImplies(\n      coveredOp,\n      coveredValue,\n      coveringOp,\n      coveringValue,\n    );\n  }\n\n  return false;\n}\n\nfunction equalityImplies(\n  value: NonNullScalarLiteralValue,\n  coveringOp: SimpleCondition['op'],\n  coveringValue: LiteralValue,\n): boolean {\n  switch (coveringOp) {\n    case '=':\n    case 'IS':\n      return jsonEqual(value, coveringValue);\n    case '!=':\n    case 'IS NOT':\n      return !jsonEqual(value, coveringValue);\n    case 'IN':\n      return (\n        Array.isArray(coveringValue) &&\n        literalArrayIncludes(coveringValue, value)\n      );\n    case '<':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value < coveringValue\n      );\n    case '<=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value <= coveringValue\n      );\n    case '>':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value > coveringValue\n      );\n    case '>=':\n      return (\n        typeof value === 'number' &&\n        typeof coveringValue === 'number' &&\n        value >= coveringValue\n      );\n    case 'NOT IN':\n    case 'LIKE':\n    case 'NOT LIKE':\n    case 'ILIKE':\n    case 'NOT ILIKE':\n      return false;\n  }\n}\n\nfunction orderConditionImplies(\n  coveredOp: '<' | '>' | '<=' | '>=',\n  coveredValue: LiteralValue,\n  coveringOp: '<' | '>' | '<=' | '>=',\n  coveringValue: LiteralValue,\n): boolean {\n  if (typeof coveredValue !== 'number' || typeof coveringValue !== 'number') {\n    return false;\n  }\n\n  switch (coveredOp) {\n    case '>':\n      return (\n        (coveringOp === '>' && coveredValue >= coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '>=':\n      return (\n        (coveringOp === '>' && coveredValue > coveringValue) ||\n        (coveringOp === '>=' && coveredValue >= coveringValue)\n      );\n    case '<':\n      return (\n        (coveringOp === '<' && coveredValue <= coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n    case '<=':\n      return (\n        (coveringOp === '<' && coveredValue < coveringValue) ||\n        (coveringOp === '<=' && coveredValue <= coveringValue)\n      );\n  }\n}\n\nfunction columnLiteralParts(condition: SimpleCondition):\n  | {\n      readonly column: string;\n      readonly op: SimpleCondition['op'];\n      readonly value: LiteralValue;\n    }\n  | undefined {\n  if (condition.left.type !== 'column' || condition.right.type !== 'literal') {\n    return undefined;\n  }\n  return {\n    column: condition.left.name,\n    op: condition.op,\n    value: condition.right.value,\n  };\n}\n\nfunction isEqualityOp(op: SimpleCondition['op']): op is '=' | 'IS' {\n  return op === '=' || op === 'IS';\n}\n\nfunction isNumericOrderOp(\n  op: SimpleCondition['op'],\n): op is '<' | '>' | '<=' | '>=' {\n  return op === '<' || op === '>' || op === '<=' || op === '>=';\n}\n\nfunction isNonNullScalarLiteralValue(\n  value: LiteralValue,\n): value is NonNullScalarLiteralValue {\n  return value !== null && !Array.isArray(value);\n}\n\nfunction literalArrayIncludes(\n  values: ReadonlyArray<string | number | boolean>,\n  value: string | number | boolean | null,\n): boolean {\n  return values.some(v => jsonEqual(v, value));\n}\n\nfunction jsonEqual(a: unknown, b: unknown): boolean {\n  return deepEqual(\n    a as ReadonlyJSONValue | undefined,\n    b as ReadonlyJSONValue | undefined,\n  );\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/view-syncer/query-shape.d.ts

@@ -0,0 +1,25 @@
+import type { AST } from '../../../../zero-protocol/src/ast.ts';
+/**
+ * A query with its literal values redacted, for logging.
+ */
+export type QueryShape = {
+    /**
+     * The query as ZQL with every literal (and the `start` row) rendered as
+     * `?`, so it can be logged without leaking row data, query arguments, or
+     * auth data substituted in by permissions.
+     */
+    readonly zql: string;
+    /**
+     * A hash of {@link zql}. Queries that differ only in their literal values,
+     * e.g. the same named query called with different arguments, share a hash,
+     * which makes it a key for grouping and throttling logs.
+     */
+    readonly hash: string;
+};
+/**
+ * Never throws: it is computed for every hydration, and a query that cannot be
+ * rendered as ZQL (e.g. a subquery without an alias) must still hydrate. Such
+ * a query is shaped by its AST with the literal values redacted instead.
+ */
+export declare function queryShape(ast: AST): QueryShape;
+//# sourceMappingURL=query-shape.d.ts.map

package/out/zero-cache/src/services/view-syncer/query-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-shape.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/view-syncer/query-shape.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,sCAAsC,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAQ/C"}

package/out/zero-cache/src/services/view-syncer/query-shape.js

@@ -0,0 +1,28 @@
+import { h64 } from "../../../../shared/src/hash.js";
+import { astToZQL } from "../../../../ast-to-zql/src/ast-to-zql.js";
+//#region ../zero-cache/src/services/view-syncer/query-shape.ts
+/**
+* Never throws: it is computed for every hydration, and a query that cannot be
+* rendered as ZQL (e.g. a subquery without an alias) must still hydrate. Such
+* a query is shaped by its AST with the literal values redacted instead.
+*/
+function queryShape(ast) {
+	let zql;
+	try {
+		zql = ast.table + astToZQL(ast, { redactLiterals: true });
+	} catch {
+		zql = JSON.stringify(ast, redactLiterals);
+	}
+	return {
+		zql,
+		hash: h64(zql).toString(36)
+	};
+}
+function redactLiterals(key, value) {
+	if (key === "value" && this.type === "literal" || key === "start") return "?";
+	return value;
+}
+//#endregion
+export { queryShape };
+
+//# sourceMappingURL=query-shape.js.map

package/out/zero-cache/src/services/view-syncer/query-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-shape.js","names":[],"sources":["../../../../../../zero-cache/src/services/view-syncer/query-shape.ts"],"sourcesContent":["// @circular-dep-ignore\nimport {astToZQL} from '../../../../ast-to-zql/src/ast-to-zql.ts';\nimport {h64} from '../../../../shared/src/hash.ts';\nimport type {AST} from '../../../../zero-protocol/src/ast.ts';\n\n/**\n * A query with its literal values redacted, for logging.\n */\nexport type QueryShape = {\n  /**\n   * The query as ZQL with every literal (and the `start` row) rendered as\n   * `?`, so it can be logged without leaking row data, query arguments, or\n   * auth data substituted in by permissions.\n   */\n  readonly zql: string;\n\n  /**\n   * A hash of {@link zql}. Queries that differ only in their literal values,\n   * e.g. the same named query called with different arguments, share a hash,\n   * which makes it a key for grouping and throttling logs.\n   */\n  readonly hash: string;\n};\n\n/**\n * Never throws: it is computed for every hydration, and a query that cannot be\n * rendered as ZQL (e.g. a subquery without an alias) must still hydrate. Such\n * a query is shaped by its AST with the literal values redacted instead.\n */\nexport function queryShape(ast: AST): QueryShape {\n  let zql: string;\n  try {\n    zql = ast.table + astToZQL(ast, {redactLiterals: true});\n  } catch {\n    zql = JSON.stringify(ast, redactLiterals);\n  }\n  return {zql, hash: h64(zql).toString(36)};\n}\n\nfunction redactLiterals(this: unknown, key: string, value: unknown) {\n  if (\n    (key === 'value' && (this as {type?: unknown}).type === 'literal') ||\n    key === 'start'\n  ) {\n    return '?';\n  }\n  return value;\n}\n"],"mappings":";;;;;;;;AA6BA,SAAgB,WAAW,KAAsB;CAC/C,IAAI;CACJ,IAAI;EACF,MAAM,IAAI,QAAQ,SAAS,KAAK,EAAC,gBAAgB,KAAI,CAAC;CACxD,QAAQ;EACN,MAAM,KAAK,UAAU,KAAK,cAAc;CAC1C;CACA,OAAO;EAAC;EAAK,MAAM,IAAI,GAAG,EAAE,SAAS,EAAE;CAAC;AAC1C;AAEA,SAAS,eAA8B,KAAa,OAAgB;CAClE,IACG,QAAQ,WAAY,KAA0B,SAAS,aACxD,QAAQ,SAER,OAAO;CAET,OAAO;AACT"}