@rocicorp/zero 0.20.2025051200 → 0.20.2025051301

package/out/{chunk-EBZYAQDK.js → chunk-ZKX3QQMT.js}

@@ -21,6 +21,7 @@ __export(valita_exports, {
   deepPartial: () => deepPartial,
   instanceOfAbstractType: () => instanceOfAbstractType,
   is: () => is,
+  literalUnion: () => literalUnion,
   parse: () => parse,
   readonly: () => readonly,
   readonlyArray: () => readonlyArray,
@@ -222,6 +223,9 @@ function deepPartial(s) {
   }
   return v.object(shape);
 }
+function literalUnion(...literals) {
+  return v.union(...literals.map(v.literal));
+}
 
 // ../zql/src/query/ttl.ts
 var DEFAULT_TTL = "none";
@@ -495,7 +499,7 @@ var rowSchema = readonlyRecord(valueSchema);
 var selectorSchema = valita_exports.string();
 var toStaticParam = Symbol();
 var orderingElementSchema = readonly(
-  valita_exports.tuple([selectorSchema, valita_exports.union(valita_exports.literal("asc"), valita_exports.literal("desc"))])
+  valita_exports.tuple([selectorSchema, literalUnion("asc", "desc")])
 );
 var orderingSchema = readonlyArray(orderingElementSchema);
 var primitiveSchema = valita_exports.union(
@@ -504,25 +508,15 @@ var primitiveSchema = valita_exports.union(
   valita_exports.boolean(),
   valita_exports.null()
 );
-var equalityOpsSchema = valita_exports.union(
-  valita_exports.literal("="),
-  valita_exports.literal("!="),
-  valita_exports.literal("IS"),
-  valita_exports.literal("IS NOT")
-);
-var orderOpsSchema = valita_exports.union(
-  valita_exports.literal("<"),
-  valita_exports.literal(">"),
-  valita_exports.literal("<="),
-  valita_exports.literal(">=")
-);
-var likeOpsSchema = valita_exports.union(
-  valita_exports.literal("LIKE"),
-  valita_exports.literal("NOT LIKE"),
-  valita_exports.literal("ILIKE"),
-  valita_exports.literal("NOT ILIKE")
+var equalityOpsSchema = literalUnion("=", "!=", "IS", "IS NOT");
+var orderOpsSchema = literalUnion("<", ">", "<=", ">=");
+var likeOpsSchema = literalUnion(
+  "LIKE",
+  "NOT LIKE",
+  "ILIKE",
+  "NOT ILIKE"
 );
-var inOpsSchema = valita_exports.union(valita_exports.literal("IN"), valita_exports.literal("NOT IN"));
+var inOpsSchema = literalUnion("IN", "NOT IN");
 var simpleOperatorSchema = valita_exports.union(
   equalityOpsSchema,
   orderOpsSchema,
@@ -550,7 +544,7 @@ var parameterReferenceSchema = readonlyObject({
   // prior to the mutation being run (preMutationRow).
   // Read and write authorization will both send the
   // current authentication data (authData).
-  anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
+  anchor: literalUnion("authData", "preMutationRow"),
   field: valita_exports.union(valita_exports.string(), valita_exports.array(valita_exports.string()))
 });
 var conditionValueSchema = valita_exports.union(
@@ -564,7 +558,7 @@ var simpleConditionSchema = readonlyObject({
   left: conditionValueSchema,
   right: valita_exports.union(parameterReferenceSchema, literalReferenceSchema)
 });
-var correlatedSubqueryConditionOperatorSchema = valita_exports.union(valita_exports.literal("EXISTS"), valita_exports.literal("NOT EXISTS"));
+var correlatedSubqueryConditionOperatorSchema = literalUnion("EXISTS", "NOT EXISTS");
 var correlatedSubqueryConditionSchema = readonlyObject({
   type: valita_exports.literal("correlatedSubquery"),
   related: valita_exports.lazy(() => correlatedSubquerySchema),
@@ -598,7 +592,7 @@ var correlationSchema = readonlyObject({
 var correlatedSubquerySchemaOmitSubquery = readonlyObject({
   correlation: correlationSchema,
   hidden: valita_exports.boolean().optional(),
-  system: valita_exports.union(valita_exports.literal("permissions"), valita_exports.literal("client"), valita_exports.literal("test")).optional()
+  system: literalUnion("permissions", "client", "test").optional()
 });
 var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
   subquery: valita_exports.lazy(() => astSchema)
@@ -832,6 +826,91 @@ function hashOfAST(ast) {
   return hash2;
 }
 
+// ../zql/src/ivm/filter-operators.ts
+var throwFilterOutput = {
+  push(_change) {
+    throw new Error("Output not set");
+  },
+  filter(_node, _cleanup) {
+    throw new Error("Output not set");
+  }
+};
+var FilterStart = class {
+  #input;
+  #output = throwFilterOutput;
+  constructor(input) {
+    this.#input = input;
+    input.setOutput(this);
+  }
+  setFilterOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  push(change) {
+    this.#output.push(change);
+  }
+  *fetch(req) {
+    for (const node of this.#input.fetch(req)) {
+      if (this.#output.filter(node, false)) {
+        yield node;
+      }
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#input.cleanup(req)) {
+      if (this.#output.filter(node, true)) {
+        yield node;
+      } else {
+        drainStreams(node);
+      }
+    }
+  }
+};
+var FilterEnd = class {
+  #start;
+  #input;
+  #output = throwFilterOutput;
+  constructor(start, input) {
+    this.#start = start;
+    this.#input = input;
+    input.setFilterOutput(this);
+  }
+  *fetch(req) {
+    for (const node of this.#start.fetch(req)) {
+      yield node;
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#start.cleanup(req)) {
+      yield node;
+    }
+  }
+  filter(_node, _cleanup) {
+    return true;
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  push(change) {
+    this.#output.push(change);
+  }
+};
+function buildFilterPipeline(input, pipeline) {
+  const filterStart = new FilterStart(input);
+  return new FilterEnd(filterStart, pipeline(filterStart));
+}
+
 // ../zql/src/ivm/operator.ts
 var throwOutput = {
   push(_change) {
@@ -867,7 +946,7 @@ var Exists = class {
   #not;
   #parentJoinKey;
   #noSizeReuse;
-  #output = throwOutput;
+  #output = throwFilterOutput;
   /**
    * This instance variable is `true` when this operator is processing a `push`,
    * and is used to disable reuse of cached sizes across rows with the
@@ -880,7 +959,7 @@ var Exists = class {
   constructor(input, storage, relationshipName, parentJoinKey, type) {
     this.#input = input;
     this.#relationshipName = relationshipName;
-    this.#input.setOutput(this);
+    this.#input.setFilterOutput(this);
     this.#storage = storage;
     assert(
       this.#input.getSchema().relationships[relationshipName],
@@ -893,33 +972,24 @@ var Exists = class {
       this.#input.getSchema().primaryKey
     );
   }
-  setOutput(output) {
+  setFilterOutput(output) {
     this.#output = output;
   }
+  filter(node, cleanup) {
+    const result = this.#filter(node) && this.#output.filter(node, cleanup);
+    if (cleanup) {
+      this.#delSize(node);
+    }
+    return result;
+  }
   destroy() {
     this.#input.destroy();
   }
   getSchema() {
     return this.#input.getSchema();
   }
-  *fetch(req) {
-    for (const node of this.#input.fetch(req)) {
-      if (this.#filter(node)) {
-        yield node;
-      }
-    }
-  }
-  *cleanup(req) {
-    for (const node of this.#input.cleanup(req)) {
-      if (this.#filter(node)) {
-        yield node;
-      } else {
-        drainStreams(node);
-      }
-      this.#delSize(node);
-    }
-  }
   push(change) {
+    assert(!this.#inPush, "Unexpected re-entrancy");
     this.#inPush = true;
     try {
       switch (change.type) {
@@ -1094,93 +1164,21 @@ var Exists = class {
   }
 };
 
-// ../shared/src/iterables.ts
-function* joinIterables(...iters) {
-  for (const iter of iters) {
-    yield* iter;
-  }
-}
-function* filterIter(iter, p) {
-  let index = 0;
-  for (const t of iter) {
-    if (p(t, index++)) {
-      yield t;
-    }
-  }
-}
-function* mapIter(iter, f) {
-  let index = 0;
-  for (const t of iter) {
-    yield f(t, index++);
-  }
-}
-var IterWrapper = class _IterWrapper {
-  iter;
-  constructor(iter) {
-    this.iter = iter;
-  }
-  [Symbol.iterator]() {
-    return this.iter[Symbol.iterator]();
-  }
-  map(f) {
-    return new _IterWrapper(mapIter(this.iter, f));
-  }
-  filter(p) {
-    return new _IterWrapper(filterIter(this.iter, p));
-  }
-};
-function wrapIterable(iter) {
-  return new IterWrapper(iter);
-}
-function* mergeIterables(iterables, comparator, distinct = false) {
-  const iterators = iterables.map((i) => i[Symbol.iterator]());
-  try {
-    const current = iterators.map((i) => i.next());
-    let lastYielded;
-    while (current.some((c) => !c.done)) {
-      const min = current.reduce(
-        (acc, c, i) => {
-          if (c.done) {
-            return acc;
-          }
-          if (acc === void 0 || comparator(c.value, acc[0]) < 0) {
-            return [c.value, i];
-          }
-          return acc;
-        },
-        void 0
-      );
-      assert(min !== void 0, "min is undefined");
-      current[min[1]] = iterators[min[1]].next();
-      if (lastYielded !== void 0 && distinct && comparator(lastYielded, min[0]) === 0) {
-        continue;
-      }
-      lastYielded = min[0];
-      yield min[0];
-    }
-  } finally {
-    for (const it of iterators) {
-      it.return?.();
-    }
-  }
-}
-
 // ../zql/src/ivm/fan-in.ts
 var FanIn = class {
   #inputs;
   #schema;
-  #output = throwOutput;
-  #accumulatedPushes;
+  #output = throwFilterOutput;
+  #accumulatedPushes = [];
   constructor(fanOut, inputs) {
     this.#inputs = inputs;
     this.#schema = fanOut.getSchema();
     for (const input of inputs) {
-      input.setOutput(this);
+      input.setFilterOutput(this);
       assert(this.#schema === input.getSchema(), `Schema mismatch in fan-in`);
     }
-    this.#accumulatedPushes = [];
   }
-  setOutput(output) {
+  setFilterOutput(output) {
     this.#output = output;
   }
   destroy() {
@@ -1191,19 +1189,8 @@ var FanIn = class {
   getSchema() {
     return this.#schema;
   }
-  fetch(req) {
-    return this.#fetchOrCleanup((input) => input.fetch(req));
-  }
-  cleanup(req) {
-    return this.#fetchOrCleanup((input) => input.cleanup(req));
-  }
-  *#fetchOrCleanup(streamProvider) {
-    const iterables = this.#inputs.map((input) => streamProvider(input));
-    yield* mergeIterables(
-      iterables,
-      (l, r) => must(this.#schema).compareRows(l.row, r.row),
-      true
-    );
+  filter(node, cleanup) {
+    return this.#output.filter(node, cleanup);
   }
   push(change) {
     this.#accumulatedPushes.push(change);
@@ -1313,12 +1300,12 @@ var FanOut = class {
   #destroyCount = 0;
   constructor(input) {
     this.#input = input;
-    input.setOutput(this);
+    input.setFilterOutput(this);
   }
   setFanIn(fanIn) {
     this.#fanIn = fanIn;
   }
-  setOutput(output) {
+  setFilterOutput(output) {
     this.#outputs.push(output);
   }
   destroy() {
@@ -1334,11 +1321,15 @@ var FanOut = class {
   getSchema() {
     return this.#input.getSchema();
   }
-  fetch(req) {
-    return this.#input.fetch(req);
-  }
-  cleanup(req) {
-    return this.#input.cleanup(req);
+  filter(node, cleanup) {
+    let result = false;
+    for (const output of this.#outputs) {
+      result = output.filter(node, cleanup) || result;
+      if (!cleanup && result) {
+        return true;
+      }
+    }
+    return result;
   }
   push(change) {
     for (const out of this.#outputs) {
@@ -1400,13 +1391,16 @@ function filterPush(change, output, predicate) {
 var Filter = class {
   #input;
   #predicate;
-  #output = throwOutput;
+  #output = throwFilterOutput;
   constructor(input, predicate) {
     this.#input = input;
     this.#predicate = predicate;
-    input.setOutput(this);
+    input.setFilterOutput(this);
   }
-  setOutput(output) {
+  filter(node, cleanup) {
+    return this.#predicate(node.row) && this.#output.filter(node, cleanup);
+  }
+  setFilterOutput(output) {
     this.#output = output;
   }
   destroy() {
@@ -1415,22 +1409,6 @@ var Filter = class {
   getSchema() {
     return this.#input.getSchema();
   }
-  *fetch(req) {
-    for (const node of this.#input.fetch(req)) {
-      if (this.#predicate(node.row)) {
-        yield node;
-      }
-    }
-  }
-  *cleanup(req) {
-    for (const node of this.#input.cleanup(req)) {
-      if (this.#predicate(node.row)) {
-        yield node;
-      } else {
-        drainStreams(node);
-      }
-    }
-  }
   push(change) {
     filterPush(change, this.#output, this.#predicate);
   }
@@ -2658,6 +2636,12 @@ function buildPipelineInternal(ast, delegate, name, partitionKey) {
   return end;
 }
 function applyWhere(input, condition, delegate, name) {
+  return buildFilterPipeline(
+    input,
+    (filterInput) => applyFilter(filterInput, condition, delegate, name)
+  );
+}
+function applyFilter(input, condition, delegate, name) {
   switch (condition.type) {
     case "and":
       return applyAnd(input, condition, delegate, name);
@@ -2671,7 +2655,7 @@ function applyWhere(input, condition, delegate, name) {
 }
 function applyAnd(input, condition, delegate, name) {
   for (const subCondition of condition.conditions) {
-    input = applyWhere(input, subCondition, delegate, name);
+    input = applyFilter(input, subCondition, delegate, name);
   }
   return input;
 }
@@ -2688,7 +2672,7 @@ function applyOr(input, condition, delegate, name) {
   }
   const fanOut = new FanOut(input);
   const branches = subqueryConditions.map(
-    (subCondition) => applyWhere(fanOut, subCondition, delegate, name)
+    (subCondition) => applyFilter(fanOut, subCondition, delegate, name)
   );
   if (otherConditions.length > 0) {
     branches.push(
@@ -2753,7 +2737,7 @@ function applyCorrelatedSubQuery(sq, delegate, end, name) {
 function applyCorrelatedSubqueryCondition(input, condition, delegate, name) {
   assert(condition.op === "EXISTS" || condition.op === "NOT EXISTS");
   const existsName = `${name}:exists(${condition.related.subquery.alias})`;
-  return delegate.decorateInput(
+  return delegate.decorateFilterInput(
     new Exists(
       input,
       delegate.createStorage(existsName),
@@ -3217,24 +3201,20 @@ var AbstractQuery = class {
     }
     return this.#hash;
   }
-  one() {
-    return this[newQuerySymbol](
-      this.#schema,
-      this.#tableName,
-      {
-        ...this.#ast,
-        limit: 1
-      },
-      {
-        ...this.format,
-        singular: true
-      }
-    );
-  }
-  whereExists(relationship, cb) {
-    return this.where(({ exists }) => exists(relationship, cb));
-  }
-  related(relationship, cb) {
+  one = () => this[newQuerySymbol](
+    this.#schema,
+    this.#tableName,
+    {
+      ...this.#ast,
+      limit: 1
+    },
+    {
+      ...this.format,
+      singular: true
+    }
+  );
+  whereExists = (relationship, cb) => this.where(({ exists }) => exists(relationship, cb));
+  related = (relationship, cb) => {
     if (relationship.startsWith(SUBQ_PREFIX)) {
       throw new Error(
         `Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`
@@ -3372,8 +3352,8 @@ var AbstractQuery = class {
       );
     }
     throw new Error(`Invalid relationship ${relationship}`);
-  }
-  where(fieldOrExpressionFactory, opOrValue, value) {
+  };
+  where = (fieldOrExpressionFactory, opOrValue, value) => {
     let cond;
     if (typeof fieldOrExpressionFactory === "function") {
       cond = fieldOrExpressionFactory(
@@ -3400,22 +3380,20 @@ var AbstractQuery = class {
       },
       this.format
     );
-  }
-  start(row, opts) {
-    return this[newQuerySymbol](
-      this.#schema,
-      this.#tableName,
-      {
-        ...this.#ast,
-        start: {
-          row,
-          exclusive: !opts?.inclusive
-        }
-      },
-      this.format
-    );
-  }
-  limit(limit) {
+  };
+  start = (row, opts) => this[newQuerySymbol](
+    this.#schema,
+    this.#tableName,
+    {
+      ...this.#ast,
+      start: {
+        row,
+        exclusive: !opts?.inclusive
+      }
+    },
+    this.format
+  );
+  limit = (limit) => {
     if (limit < 0) {
       throw new Error("Limit must be non-negative");
     }
@@ -3431,18 +3409,16 @@ var AbstractQuery = class {
       },
       this.format
     );
-  }
-  orderBy(field, direction) {
-    return this[newQuerySymbol](
-      this.#schema,
-      this.#tableName,
-      {
-        ...this.#ast,
-        orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
-      },
-      this.format
-    );
-  }
+  };
+  orderBy = (field, direction) => this[newQuerySymbol](
+    this.#schema,
+    this.#tableName,
+    {
+      ...this.#ast,
+      orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
+    },
+    this.format
+  );
   _exists = (relationship, cb = (q) => q) => {
     const related = this.#schema.relationships[this.#tableName][relationship];
     assert(related, "Invalid relationship");
@@ -3723,9 +3699,8 @@ export {
   readonlyObject,
   readonlyArray,
   readonlyRecord,
+  literalUnion,
   valita_exports,
-  joinIterables,
-  wrapIterable,
   jsonSchema,
   jsonObjectSchema,
   h64,
@@ -3753,4 +3728,4 @@ export {
   newQuerySymbol,
   AbstractQuery
 };
-//# sourceMappingURL=chunk-EBZYAQDK.js.map
+//# sourceMappingURL=chunk-ZKX3QQMT.js.map