@rocicorp/zero 0.25.0-canary.7 → 0.25.0-canary.9

package/out/zql/src/query/query-impl.js

@@ -1,470 +1,551 @@
-import { resolver } from '@rocicorp/resolver';
+import { resolver } from "@rocicorp/resolver";
 import { assert } from "../../../shared/src/asserts.js";
-import { SUBQ_PREFIX, } from "../../../zero-protocol/src/ast.js";
-import { hashOfAST, hashOfNameAndArgs, } from "../../../zero-protocol/src/query-hash.js";
+import { SUBQ_PREFIX } from "../../../zero-protocol/src/ast.js";
+import { hashOfAST, hashOfNameAndArgs } from "../../../zero-protocol/src/query-hash.js";
 import { buildPipeline } from "../builder/builder.js";
 import { NotImplementedError } from "../error.js";
 import { ArrayView } from "../ivm/array-view.js";
-import { defaultFormat } from "../ivm/default-format.js";
-import { and, cmp, ExpressionBuilder, simplifyCondition, } from "./expression.js";
-import { queryInternalsTag } from "./query-internals.js";
-import {} from "./query.js";
-import { DEFAULT_PRELOAD_TTL_MS, DEFAULT_TTL_MS } from "./ttl.js";
-export function newQuery(schema, table) {
-    return new QueryImpl(schema, table, { table }, defaultFormat, undefined);
+import { defaultFormat } from "../../../zero-types/src/format.js";
+import { ExpressionBuilder, cmp, and, simplifyCondition } from "./expression.js";
+import { queryInternalsTag, asQueryInternals } from "./query-internals.js";
+import { DEFAULT_TTL_MS, DEFAULT_PRELOAD_TTL_MS } from "./ttl.js";
+function newQuery(schema, table) {
+  return new QueryImpl(schema, table, { table }, defaultFormat, void 0);
 }
-export function staticParam(anchorClass, field) {
-    return {
-        type: 'static',
-        anchor: anchorClass,
-        // for backwards compatibility
-        field: field.length === 1 ? field[0] : field,
-    };
-}
-export class AbstractQuery {
-    [queryInternalsTag] = true;
-    #schema;
-    #tableName;
-    #ast;
-    format;
-    #hash = '';
-    #system;
-    #currentJunction;
-    customQueryID;
-    #newQuery;
-    constructor(schema, tableName, ast, format, system, customQueryID, currentJunction, newQuery) {
-        this.#schema = schema;
-        this.#tableName = tableName;
-        this.#ast = ast;
-        this.format = format;
-        this.#system = system;
-        this.#currentJunction = currentJunction;
-        this.customQueryID = customQueryID;
-        this.#newQuery = newQuery;
+class AbstractQuery {
+  [queryInternalsTag] = true;
+  #schema;
+  #tableName;
+  #ast;
+  format;
+  #hash = "";
+  #system;
+  #currentJunction;
+  customQueryID;
+  #newQuery;
+  constructor(schema, tableName, ast, format, system, customQueryID, currentJunction, newQuery2) {
+    this.#schema = schema;
+    this.#tableName = tableName;
+    this.#ast = ast;
+    this.format = format;
+    this.#system = system;
+    this.#currentJunction = currentJunction;
+    this.customQueryID = customQueryID;
+    this.#newQuery = newQuery2;
+  }
+  nameAndArgs(name, args) {
+    return this.#newQuery(
+      this.#tableName,
+      this.#ast,
+      this.format,
+      {
+        name,
+        args
+      },
+      this.#currentJunction
+    );
+  }
+  hash() {
+    if (!this.#hash) {
+      this.#hash = hashOfAST(this.#ast);
     }
-    withContext(_ctx) {
-        return this;
+    return this.#hash;
+  }
+  one = () => this.#newQuery(
+    this.#tableName,
+    {
+      ...this.#ast,
+      limit: 1
+    },
+    {
+      ...this.format,
+      singular: true
+    },
+    this.customQueryID,
+    this.#currentJunction
+  );
+  whereExists = (relationship, cbOrOptions, options) => {
+    const cb = typeof cbOrOptions === "function" ? cbOrOptions : void 0;
+    const opts = typeof cbOrOptions === "function" ? options : cbOrOptions;
+    const flipped = opts?.flip;
+    return this.where(
+      ({ exists }) => exists(
+        relationship,
+        cb,
+        flipped !== void 0 ? { flip: flipped } : void 0
+      )
+    );
+  };
+  related = (relationship, cb) => {
+    if (relationship.startsWith(SUBQ_PREFIX)) {
+      throw new Error(
+        `Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`
+      );
     }
-    nameAndArgs(name, args) {
-        return this.#newQuery(this.#tableName, this.#ast, this.format, {
-            name,
-            args,
-        }, this.#currentJunction);
-    }
-    hash() {
-        if (!this.#hash) {
-            this.#hash = hashOfAST(this.#completeAst());
-        }
-        return this.#hash;
+    cb = cb ?? ((q) => q);
+    const related = this.#schema.relationships[this.#tableName][relationship];
+    assert(related, "Invalid relationship");
+    if (isOneHop(related)) {
+      const { destSchema, destField, sourceField, cardinality } = related[0];
+      const q = this.#newQuery(
+        destSchema,
+        {
+          table: destSchema,
+          alias: relationship
+        },
+        {
+          relationships: {},
+          singular: cardinality === "one"
+        },
+        this.customQueryID,
+        void 0
+      );
+      const subQuery = asAbstractQuery(cb(q));
+      assert(
+        isCompoundKey(sourceField),
+        "The source of a relationship must specify at last 1 field"
+      );
+      assert(
+        isCompoundKey(destField),
+        "The destination of a relationship must specify at last 1 field"
+      );
+      assert(
+        sourceField.length === destField.length,
+        "The source and destination of a relationship must have the same number of fields"
+      );
+      return this.#newQuery(
+        this.#tableName,
+        {
+          ...this.#ast,
+          related: [
+            ...this.#ast.related ?? [],
+            {
+              system: this.#system,
+              correlation: {
+                parentField: sourceField,
+                childField: destField
+              },
+              subquery: subQuery.#ast
+            }
+          ]
+        },
+        {
+          ...this.format,
+          relationships: {
+            ...this.format.relationships,
+            [relationship]: subQuery.format
+          }
+        },
+        this.customQueryID,
+        this.#currentJunction
+      );
     }
-    one = () => this.#newQuery(this.#tableName, {
-        ...this.#ast,
-        limit: 1,
-    }, {
-        ...this.format,
-        singular: true,
-    }, this.customQueryID, this.#currentJunction);
-    whereExists = (relationship, cbOrOptions, options) => {
-        const cb = typeof cbOrOptions === 'function' ? cbOrOptions : undefined;
-        const opts = typeof cbOrOptions === 'function' ? options : cbOrOptions;
-        const flipped = opts?.flip;
-        return this.where(({ exists }) => exists(relationship, cb, flipped !== undefined ? { flip: flipped } : undefined));
-    };
-    related = (relationship, cb) => {
-        if (relationship.startsWith(SUBQ_PREFIX)) {
-            throw new Error(`Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`);
-        }
-        cb = cb ?? (q => q);
-        const related = this.#schema.relationships[this.#tableName][relationship];
-        assert(related, 'Invalid relationship');
-        if (isOneHop(related)) {
-            const { destSchema, destField, sourceField, cardinality } = related[0];
-            const q = this.#newQuery(destSchema, {
-                table: destSchema,
-                alias: relationship,
-            }, {
-                relationships: {},
-                singular: cardinality === 'one',
-            }, this.customQueryID, undefined);
-            // Intentionally not setting to `one` as it is a perf degradation
-            // and the user should not be making the mistake of setting cardinality to
-            // `one` when it is actually not.
-            // if (cardinality === 'one') {
-            //   q = q.one();
-            // }
-            const subQuery = asAbstractQuery(cb(q));
-            assert(isCompoundKey(sourceField), 'The source of a relationship must specify at last 1 field');
-            assert(isCompoundKey(destField), 'The destination of a relationship must specify at last 1 field');
-            assert(sourceField.length === destField.length, 'The source and destination of a relationship must have the same number of fields');
-            return this.#newQuery(this.#tableName, {
-                ...this.#ast,
-                related: [
-                    ...(this.#ast.related ?? []),
-                    {
-                        system: this.#system,
-                        correlation: {
-                            parentField: sourceField,
-                            childField: destField,
-                        },
-                        subquery: addPrimaryKeysToAst(this.#schema.tables[destSchema], subQuery.#ast),
-                    },
-                ],
-            }, {
-                ...this.format,
-                relationships: {
-                    ...this.format.relationships,
-                    [relationship]: subQuery.format,
-                },
-            }, this.customQueryID, this.#currentJunction);
-        }
-        if (isTwoHop(related)) {
-            const [firstRelation, secondRelation] = related;
-            const { destSchema } = secondRelation;
-            const junctionSchema = firstRelation.destSchema;
-            const sq = asAbstractQuery(cb(this.#newQuery(destSchema, {
-                table: destSchema,
+    if (isTwoHop(related)) {
+      const [firstRelation, secondRelation] = related;
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
+      const sq = asAbstractQuery(
+        cb(
+          this.#newQuery(
+            destSchema,
+            {
+              table: destSchema,
+              alias: relationship
+            },
+            {
+              relationships: {},
+              singular: secondRelation.cardinality === "one"
+            },
+            this.customQueryID,
+            relationship
+          )
+        )
+      );
+      assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
+      return this.#newQuery(
+        this.#tableName,
+        {
+          ...this.#ast,
+          related: [
+            ...this.#ast.related ?? [],
+            {
+              system: this.#system,
+              correlation: {
+                parentField: firstRelation.sourceField,
+                childField: firstRelation.destField
+              },
+              hidden: true,
+              subquery: {
+                table: junctionSchema,
                 alias: relationship,
-            }, {
-                relationships: {},
-                singular: secondRelation.cardinality === 'one',
-            }, this.customQueryID, relationship)));
-            assert(isCompoundKey(firstRelation.sourceField), 'Invalid relationship');
-            assert(isCompoundKey(firstRelation.destField), 'Invalid relationship');
-            assert(isCompoundKey(secondRelation.sourceField), 'Invalid relationship');
-            assert(isCompoundKey(secondRelation.destField), 'Invalid relationship');
-            return this.#newQuery(this.#tableName, {
-                ...this.#ast,
                 related: [
-                    ...(this.#ast.related ?? []),
-                    {
-                        system: this.#system,
-                        correlation: {
-                            parentField: firstRelation.sourceField,
-                            childField: firstRelation.destField,
-                        },
-                        hidden: true,
-                        subquery: {
-                            table: junctionSchema,
-                            alias: relationship,
-                            orderBy: addPrimaryKeys(this.#schema.tables[junctionSchema], undefined),
-                            related: [
-                                {
-                                    system: this.#system,
-                                    correlation: {
-                                        parentField: secondRelation.sourceField,
-                                        childField: secondRelation.destField,
-                                    },
-                                    subquery: addPrimaryKeysToAst(this.#schema.tables[destSchema], sq.#ast),
-                                },
-                            ],
-                        },
-                    },
-                ],
-            }, {
-                ...this.format,
-                relationships: {
-                    ...this.format.relationships,
-                    [relationship]: sq.format,
-                },
-            }, this.customQueryID, this.#currentJunction);
-        }
-        throw new Error(`Invalid relationship ${relationship}`);
-    };
-    where = (fieldOrExpressionFactory, opOrValue, value) => {
-        let cond;
-        if (typeof fieldOrExpressionFactory === 'function') {
-            cond = fieldOrExpressionFactory(new ExpressionBuilder(this._exists));
-        }
-        else {
-            assert(opOrValue !== undefined, 'Invalid condition');
-            cond = cmp(fieldOrExpressionFactory, opOrValue, value);
-        }
-        const existingWhere = this.#ast.where;
-        if (existingWhere) {
-            cond = and(existingWhere, cond);
-        }
-        const where = simplifyCondition(cond);
-        return this.#newQuery(this.#tableName, {
-            ...this.#ast,
-            where,
-        }, this.format, this.customQueryID, this.#currentJunction);
-    };
-    start = (row, opts) => this.#newQuery(this.#tableName, {
-        ...this.#ast,
-        start: {
-            row,
-            exclusive: !opts?.inclusive,
-        },
-    }, this.format, this.customQueryID, this.#currentJunction);
-    limit = (limit) => {
-        if (limit < 0) {
-            throw new Error('Limit must be non-negative');
-        }
-        if ((limit | 0) !== limit) {
-            throw new Error('Limit must be an integer');
-        }
-        if (this.#currentJunction) {
-            throw new NotImplementedError('Limit is not supported in junction relationships yet. Junction relationship being limited: ' +
-                this.#currentJunction);
-        }
-        return this.#newQuery(this.#tableName, {
-            ...this.#ast,
-            limit,
-        }, this.format, this.customQueryID, this.#currentJunction);
-    };
-    orderBy = (field, direction) => {
-        if (this.#currentJunction) {
-            throw new NotImplementedError('Order by is not supported in junction relationships yet. Junction relationship being ordered: ' +
-                this.#currentJunction);
-        }
-        return this.#newQuery(this.#tableName, {
-            ...this.#ast,
-            orderBy: [...(this.#ast.orderBy ?? []), [field, direction]],
-        }, this.format, this.customQueryID, this.#currentJunction);
-    };
-    _exists = (relationship, cb, options) => {
-        cb = cb ?? (q => q);
-        const flip = options?.flip;
-        const related = this.#schema.relationships[this.#tableName][relationship];
-        assert(related, 'Invalid relationship');
-        if (isOneHop(related)) {
-            const { destSchema: destTableName, sourceField, destField } = related[0];
-            assert(isCompoundKey(sourceField), 'Invalid relationship');
-            assert(isCompoundKey(destField), 'Invalid relationship');
-            const subQuery = asAbstractQuery(cb(this.#newQuery(destTableName, {
-                table: destTableName,
-                alias: `${SUBQ_PREFIX}${relationship}`,
-            }, defaultFormat, this.customQueryID, undefined)));
-            return {
-                type: 'correlatedSubquery',
-                related: {
-                    system: this.#system,
-                    correlation: {
-                        parentField: sourceField,
-                        childField: destField,
-                    },
-                    subquery: addPrimaryKeysToAst(this.#schema.tables[destTableName], subQuery.#ast),
-                },
-                op: 'EXISTS',
-                flip,
-            };
-        }
-        if (isTwoHop(related)) {
-            const [firstRelation, secondRelation] = related;
-            assert(isCompoundKey(firstRelation.sourceField), 'Invalid relationship');
-            assert(isCompoundKey(firstRelation.destField), 'Invalid relationship');
-            assert(isCompoundKey(secondRelation.sourceField), 'Invalid relationship');
-            assert(isCompoundKey(secondRelation.destField), 'Invalid relationship');
-            const { destSchema } = secondRelation;
-            const junctionSchema = firstRelation.destSchema;
-            const queryToDest = cb(this.#newQuery(destSchema, {
-                table: destSchema,
-                alias: `${SUBQ_PREFIX}zhidden_${relationship}`,
-            }, defaultFormat, this.customQueryID, relationship));
-            return {
-                type: 'correlatedSubquery',
-                related: {
+                  {
                     system: this.#system,
                     correlation: {
-                        parentField: firstRelation.sourceField,
-                        childField: firstRelation.destField,
+                      parentField: secondRelation.sourceField,
+                      childField: secondRelation.destField
                     },
-                    subquery: {
-                        table: junctionSchema,
-                        alias: `${SUBQ_PREFIX}${relationship}`,
-                        orderBy: addPrimaryKeys(this.#schema.tables[junctionSchema], undefined),
-                        where: {
-                            type: 'correlatedSubquery',
-                            related: {
-                                system: this.#system,
-                                correlation: {
-                                    parentField: secondRelation.sourceField,
-                                    childField: secondRelation.destField,
-                                },
-                                subquery: addPrimaryKeysToAst(this.#schema.tables[destSchema], queryToDest
-                                    .#ast),
-                            },
-                            op: 'EXISTS',
-                            flip,
-                        },
-                    },
-                },
-                op: 'EXISTS',
-                flip,
-            };
-        }
-        throw new Error(`Invalid relationship ${relationship}`);
-    };
-    #completedAST;
-    get ast() {
-        return this.#completeAst();
-    }
-    #completeAst() {
-        if (!this.#completedAST) {
-            const finalOrderBy = addPrimaryKeys(this.#schema.tables[this.#tableName], this.#ast.orderBy);
-            if (this.#ast.start) {
-                const { row } = this.#ast.start;
-                const narrowedRow = {};
-                for (const [field] of finalOrderBy) {
-                    narrowedRow[field] = row[field];
-                }
-                this.#completedAST = {
-                    ...this.#ast,
-                    start: {
-                        ...this.#ast.start,
-                        row: narrowedRow,
-                    },
-                    orderBy: finalOrderBy,
-                };
+                    subquery: sq.#ast
+                  }
+                ]
+              }
             }
-            else {
-                this.#completedAST = {
-                    ...this.#ast,
-                    orderBy: addPrimaryKeys(this.#schema.tables[this.#tableName], this.#ast.orderBy),
-                };
+          ]
+        },
+        {
+          ...this.format,
+          relationships: {
+            ...this.format.relationships,
+            [relationship]: sq.format
+          }
+        },
+        this.customQueryID,
+        this.#currentJunction
+      );
+    }
+    throw new Error(`Invalid relationship ${relationship}`);
+  };
+  where = (fieldOrExpressionFactory, opOrValue, value) => {
+    let cond;
+    if (typeof fieldOrExpressionFactory === "function") {
+      cond = fieldOrExpressionFactory(
+        new ExpressionBuilder(this._exists)
+      );
+    } else {
+      assert(opOrValue !== void 0, "Invalid condition");
+      cond = cmp(fieldOrExpressionFactory, opOrValue, value);
+    }
+    const existingWhere = this.#ast.where;
+    if (existingWhere) {
+      cond = and(existingWhere, cond);
+    }
+    const where = simplifyCondition(cond);
+    return this.#newQuery(
+      this.#tableName,
+      {
+        ...this.#ast,
+        where
+      },
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  };
+  start = (row, opts) => this.#newQuery(
+    this.#tableName,
+    {
+      ...this.#ast,
+      start: {
+        row,
+        exclusive: !opts?.inclusive
+      }
+    },
+    this.format,
+    this.customQueryID,
+    this.#currentJunction
+  );
+  limit = (limit) => {
+    if (limit < 0) {
+      throw new Error("Limit must be non-negative");
+    }
+    if ((limit | 0) !== limit) {
+      throw new Error("Limit must be an integer");
+    }
+    if (this.#currentJunction) {
+      throw new NotImplementedError(
+        "Limit is not supported in junction relationships yet. Junction relationship being limited: " + this.#currentJunction
+      );
+    }
+    return this.#newQuery(
+      this.#tableName,
+      {
+        ...this.#ast,
+        limit
+      },
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  };
+  orderBy = (field, direction) => {
+    if (this.#currentJunction) {
+      throw new NotImplementedError(
+        "Order by is not supported in junction relationships yet. Junction relationship being ordered: " + this.#currentJunction
+      );
+    }
+    return this.#newQuery(
+      this.#tableName,
+      {
+        ...this.#ast,
+        orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
+      },
+      this.format,
+      this.customQueryID,
+      this.#currentJunction
+    );
+  };
+  _exists = (relationship, cb, options) => {
+    cb = cb ?? ((q) => q);
+    const flip = options?.flip;
+    const related = this.#schema.relationships[this.#tableName][relationship];
+    assert(related, "Invalid relationship");
+    if (isOneHop(related)) {
+      const { destSchema: destTableName, sourceField, destField } = related[0];
+      assert(isCompoundKey(sourceField), "Invalid relationship");
+      assert(isCompoundKey(destField), "Invalid relationship");
+      const subQuery = asAbstractQuery(
+        cb(
+          this.#newQuery(
+            destTableName,
+            {
+              table: destTableName,
+              alias: `${SUBQ_PREFIX}${relationship}`
+            },
+            defaultFormat,
+            this.customQueryID,
+            void 0
+          )
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          system: this.#system,
+          correlation: {
+            parentField: sourceField,
+            childField: destField
+          },
+          subquery: subQuery.#ast
+        },
+        op: "EXISTS",
+        flip
+      };
+    }
+    if (isTwoHop(related)) {
+      const [firstRelation, secondRelation] = related;
+      assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
+      const queryToDest = cb(
+        this.#newQuery(
+          destSchema,
+          {
+            table: destSchema,
+            alias: `${SUBQ_PREFIX}zhidden_${relationship}`
+          },
+          defaultFormat,
+          this.customQueryID,
+          relationship
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          system: this.#system,
+          correlation: {
+            parentField: firstRelation.sourceField,
+            childField: firstRelation.destField
+          },
+          subquery: {
+            table: junctionSchema,
+            alias: `${SUBQ_PREFIX}${relationship}`,
+            where: {
+              type: "correlatedSubquery",
+              related: {
+                system: this.#system,
+                correlation: {
+                  parentField: secondRelation.sourceField,
+                  childField: secondRelation.destField
+                },
+                subquery: queryToDest.#ast
+              },
+              op: "EXISTS",
+              flip
             }
-        }
-        return this.#completedAST;
+          }
+        },
+        op: "EXISTS",
+        flip
+      };
     }
+    throw new Error(`Invalid relationship ${relationship}`);
+  };
+  get ast() {
+    return this.#ast;
+  }
+  toQuery(_context) {
+    return this;
+  }
 }
 function asAbstractQuery(q) {
-    assert(q instanceof AbstractQuery);
-    return q;
-}
-export function materializeImpl(query, delegate, factory = arrayViewFactory, options) {
-    let ttl = options?.ttl ?? DEFAULT_TTL_MS;
-    const qi = delegate.withContext(query);
-    const { ast: ast, format, customQueryID } = qi;
-    const queryHash = qi.hash();
-    const queryID = customQueryID
-        ? hashOfNameAndArgs(customQueryID.name, customQueryID.args)
-        : queryHash;
-    const queryCompleteResolver = resolver();
-    let queryComplete = delegate.defaultQueryComplete;
-    const updateTTL = customQueryID
-        ? (newTTL) => delegate.updateCustomQuery(customQueryID, newTTL)
-        : (newTTL) => delegate.updateServerQuery(ast, newTTL);
-    const gotCallback = (got, error) => {
-        if (error) {
-            queryCompleteResolver.reject(error);
-            queryComplete = error;
-            return;
-        }
-        if (got) {
-            delegate.addMetric('query-materialization-end-to-end', performance.now() - t0, queryID, ast);
-            queryComplete = true;
-            queryCompleteResolver.resolve(true);
-        }
-    };
-    let removeCommitObserver;
-    const onDestroy = () => {
-        input.destroy();
-        removeCommitObserver?.();
-        removeAddedQuery();
-    };
-    const t0 = performance.now();
-    const removeAddedQuery = customQueryID
-        ? delegate.addCustomQuery(ast, customQueryID, ttl, gotCallback)
-        : delegate.addServerQuery(ast, ttl, gotCallback);
-    const input = buildPipeline(ast, delegate, queryID);
-    const view = delegate.batchViewUpdates(() => (factory ?? arrayViewFactory)(query, input, format, onDestroy, cb => {
-        removeCommitObserver = delegate.onTransactionCommit(cb);
-    }, queryComplete || queryCompleteResolver.promise, updateTTL));
-    delegate.addMetric('query-materialization-client', performance.now() - t0, queryID);
-    return view;
+  assert(q instanceof AbstractQuery);
+  return q;
 }
-// oxlint-disable-next-line require-await
-export async function runImpl(query, delegate, options) {
-    delegate.assertValidRunOptions(options);
-    const v = materializeImpl(query, delegate, undefined, {
-        ttl: options?.ttl,
-    });
-    if (options?.type === 'complete') {
-        return new Promise(resolve => {
-            v.addListener((data, type) => {
-                if (type === 'complete') {
-                    v.destroy();
-                    resolve(data);
-                }
-                else if (type === 'error') {
-                    v.destroy();
-                    resolve(Promise.reject(data));
-                }
-            });
-        });
+function materializeImpl(query, delegate, factory = arrayViewFactory, options) {
+  let ttl = options?.ttl ?? DEFAULT_TTL_MS;
+  const qi = asQueryInternals(query);
+  const { ast, format, customQueryID } = qi;
+  const queryHash = qi.hash();
+  const queryID = customQueryID ? hashOfNameAndArgs(customQueryID.name, customQueryID.args) : queryHash;
+  const queryCompleteResolver = resolver();
+  let queryComplete = delegate.defaultQueryComplete;
+  const updateTTL = customQueryID ? (newTTL) => delegate.updateCustomQuery(customQueryID, newTTL) : (newTTL) => delegate.updateServerQuery(ast, newTTL);
+  const gotCallback = (got, error) => {
+    if (error) {
+      queryCompleteResolver.reject(error);
+      queryComplete = error;
+      return;
     }
-    options?.type;
-    const ret = v.data;
-    v.destroy();
-    return ret;
+    if (got) {
+      delegate.addMetric(
+        "query-materialization-end-to-end",
+        performance.now() - t0,
+        queryID,
+        ast
+      );
+      queryComplete = true;
+      queryCompleteResolver.resolve(true);
+    }
+  };
+  let removeCommitObserver;
+  const onDestroy = () => {
+    input.destroy();
+    removeCommitObserver?.();
+    removeAddedQuery();
+  };
+  const t0 = performance.now();
+  const removeAddedQuery = customQueryID ? delegate.addCustomQuery(ast, customQueryID, ttl, gotCallback) : delegate.addServerQuery(ast, ttl, gotCallback);
+  const input = buildPipeline(ast, delegate, queryID);
+  const view = delegate.batchViewUpdates(
+    () => (factory ?? arrayViewFactory)(
+      query,
+      input,
+      format,
+      onDestroy,
+      (cb) => {
+        removeCommitObserver = delegate.onTransactionCommit(cb);
+      },
+      queryComplete || queryCompleteResolver.promise,
+      updateTTL
+    )
+  );
+  delegate.addMetric(
+    "query-materialization-client",
+    performance.now() - t0,
+    queryID
+  );
+  return view;
 }
-export function preloadImpl(query, delegate, options) {
-    const qi = delegate.withContext(query);
-    const ttl = options?.ttl ?? DEFAULT_PRELOAD_TTL_MS;
-    const { resolve, promise: complete } = resolver();
-    const { customQueryID, ast: ast } = qi;
-    if (customQueryID) {
-        const cleanup = delegate.addCustomQuery(ast, customQueryID, ttl, got => {
-            if (got) {
-                resolve();
-            }
-        });
-        return {
-            cleanup,
-            complete,
-        };
+async function runImpl(query, delegate, options) {
+  delegate.assertValidRunOptions(options);
+  const v = materializeImpl(
+    query,
+    delegate,
+    void 0,
+    {
+      ttl: options?.ttl
     }
-    const cleanup = delegate.addServerQuery(ast, ttl, got => {
-        if (got) {
-            resolve();
+  );
+  if (options?.type === "complete") {
+    return new Promise((resolve) => {
+      v.addListener((data, type) => {
+        if (type === "complete") {
+          v.destroy();
+          resolve(data);
+        } else if (type === "error") {
+          v.destroy();
+          resolve(Promise.reject(data));
         }
+      });
+    });
+  }
+  options?.type;
+  const ret = v.data;
+  v.destroy();
+  return ret;
+}
+function preloadImpl(query, delegate, options) {
+  const qi = asQueryInternals(query);
+  const ttl = options?.ttl ?? DEFAULT_PRELOAD_TTL_MS;
+  const { resolve, promise: complete } = resolver();
+  const { customQueryID, ast } = qi;
+  if (customQueryID) {
+    const cleanup2 = delegate.addCustomQuery(ast, customQueryID, ttl, (got) => {
+      if (got) {
+        resolve();
+      }
     });
     return {
-        cleanup,
-        complete,
+      cleanup: cleanup2,
+      complete
     };
-}
-export class QueryImpl extends AbstractQuery {
-    constructor(schema, tableName, ast = { table: tableName }, format = defaultFormat, system = 'client', customQueryID, currentJunction) {
-        super(schema, tableName, ast, format, system, customQueryID, currentJunction, (tableName, ast, format, customQueryID, currentJunction) => new QueryImpl(schema, tableName, ast, format, system, customQueryID, currentJunction));
-    }
-}
-function addPrimaryKeys(schema, orderBy) {
-    orderBy = orderBy ?? [];
-    const { primaryKey } = schema;
-    const primaryKeysToAdd = new Set(primaryKey);
-    for (const [field] of orderBy) {
-        primaryKeysToAdd.delete(field);
-    }
-    if (primaryKeysToAdd.size === 0) {
-        return orderBy;
+  }
+  const cleanup = delegate.addServerQuery(ast, ttl, (got) => {
+    if (got) {
+      resolve();
     }
-    return [
-        ...orderBy,
-        ...[...primaryKeysToAdd].map(key => [key, 'asc']),
-    ];
+  });
+  return {
+    cleanup,
+    complete
+  };
 }
-function addPrimaryKeysToAst(schema, ast) {
-    return {
-        ...ast,
-        orderBy: addPrimaryKeys(schema, ast.orderBy),
-    };
+class QueryImpl extends AbstractQuery {
+  constructor(schema, tableName, ast = { table: tableName }, format = defaultFormat, system = "client", customQueryID, currentJunction) {
+    super(
+      schema,
+      tableName,
+      ast,
+      format,
+      system,
+      customQueryID,
+      currentJunction,
+      (tableName2, ast2, format2, customQueryID2, currentJunction2) => new QueryImpl(
+        schema,
+        tableName2,
+        ast2,
+        format2,
+        system,
+        customQueryID2,
+        currentJunction2
+      )
+    );
+  }
 }
 function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete, updateTTL) {
-    const v = new ArrayView(input, format, queryComplete, updateTTL);
-    v.onDestroy = onDestroy;
-    onTransactionCommit(() => {
-        v.flush();
-    });
-    return v;
+  const v = new ArrayView(
+    input,
+    format,
+    queryComplete,
+    updateTTL
+  );
+  v.onDestroy = onDestroy;
+  onTransactionCommit(() => {
+    v.flush();
+  });
+  return v;
 }
 function isCompoundKey(field) {
-    return Array.isArray(field) && field.length >= 1;
+  return Array.isArray(field) && field.length >= 1;
 }
 function isOneHop(r) {
-    return r.length === 1;
+  return r.length === 1;
 }
 function isTwoHop(r) {
-    return r.length === 2;
+  return r.length === 2;
 }
-//# sourceMappingURL=query-impl.js.map
+export {
+  AbstractQuery,
+  QueryImpl,
+  materializeImpl,
+  newQuery,
+  preloadImpl,
+  runImpl
+};
+//# sourceMappingURL=query-impl.js.map