@rocicorp/zero 0.20.2025051501 → 0.20.2025051502

package/out/{chunk-P3G5C3ZW.js → chunk-IKN2MNWU.js}

@@ -13,7 +13,7 @@ import {
   readonlyObject,
   readonlyRecord,
   valita_exports
-} from "./chunk-ILWAR46C.js";
+} from "./chunk-MIYN75UK.js";
 import {
   assert,
   assertArray,
@@ -2889,4 +2889,4 @@ export {
   toPrimaryKeyString,
   sourceNameFromKey
 };
-//# sourceMappingURL=chunk-P3G5C3ZW.js.map
+//# sourceMappingURL=chunk-IKN2MNWU.js.map

package/out/{chunk-ILWAR46C.js → chunk-MIYN75UK.js}

@@ -2368,6 +2368,175 @@ function makePartitionKeyComparator(partitionKey) {
   };
 }
 
+// ../zql/src/query/expression.ts
+var ExpressionBuilder = class {
+  #exists;
+  constructor(exists) {
+    this.#exists = exists;
+    this.exists = this.exists.bind(this);
+  }
+  get eb() {
+    return this;
+  }
+  cmp(field, opOrValue, value) {
+    return cmp(field, opOrValue, value);
+  }
+  cmpLit(left, op, right) {
+    return {
+      type: "simple",
+      left: isParameterReference(left) ? left[toStaticParam]() : { type: "literal", value: left },
+      right: isParameterReference(right) ? right[toStaticParam]() : { type: "literal", value: right },
+      op
+    };
+  }
+  and = and;
+  or = or;
+  not = not;
+  exists = (relationship, cb) => this.#exists(relationship, cb);
+};
+function and(...conditions) {
+  const expressions = filterTrue(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
+  }
+  if (expressions.some(isAlwaysFalse)) {
+    return FALSE;
+  }
+  return { type: "and", conditions: expressions };
+}
+function or(...conditions) {
+  const expressions = filterFalse(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
+  }
+  if (expressions.some(isAlwaysTrue)) {
+    return TRUE;
+  }
+  return { type: "or", conditions: expressions };
+}
+function not(expression) {
+  switch (expression.type) {
+    case "and":
+      return {
+        type: "or",
+        conditions: expression.conditions.map(not)
+      };
+    case "or":
+      return {
+        type: "and",
+        conditions: expression.conditions.map(not)
+      };
+    case "correlatedSubquery":
+      return {
+        type: "correlatedSubquery",
+        related: expression.related,
+        op: negateOperator(expression.op)
+      };
+    case "simple":
+      return {
+        type: "simple",
+        op: negateOperator(expression.op),
+        left: expression.left,
+        right: expression.right
+      };
+  }
+}
+function cmp(field, opOrValue, value) {
+  let op;
+  if (value === void 0) {
+    value = opOrValue;
+    op = "=";
+  } else {
+    op = opOrValue;
+  }
+  return {
+    type: "simple",
+    left: { type: "column", name: field },
+    right: isParameterReference(value) ? value[toStaticParam]() : { type: "literal", value },
+    op
+  };
+}
+function isParameterReference(value) {
+  return value !== null && typeof value === "object" && value[toStaticParam];
+}
+var TRUE = {
+  type: "and",
+  conditions: []
+};
+var FALSE = {
+  type: "or",
+  conditions: []
+};
+function isAlwaysTrue(condition) {
+  return condition.type === "and" && condition.conditions.length === 0;
+}
+function isAlwaysFalse(condition) {
+  return condition.type === "or" && condition.conditions.length === 0;
+}
+function simplifyCondition(c) {
+  if (c.type === "simple" || c.type === "correlatedSubquery") {
+    return c;
+  }
+  if (c.conditions.length === 1) {
+    return simplifyCondition(c.conditions[0]);
+  }
+  const conditions = flatten(c.type, c.conditions.map(simplifyCondition));
+  if (c.type === "and" && conditions.some(isAlwaysFalse)) {
+    return FALSE;
+  }
+  if (c.type === "or" && conditions.some(isAlwaysTrue)) {
+    return TRUE;
+  }
+  return {
+    type: c.type,
+    conditions
+  };
+}
+function flatten(type, conditions) {
+  const flattened2 = [];
+  for (const c of conditions) {
+    if (c.type === type) {
+      flattened2.push(...c.conditions);
+    } else {
+      flattened2.push(c);
+    }
+  }
+  return flattened2;
+}
+var negateSimpleOperatorMap = {
+  ["="]: "!=",
+  ["!="]: "=",
+  ["<"]: ">=",
+  [">"]: "<=",
+  [">="]: "<",
+  ["<="]: ">",
+  ["IN"]: "NOT IN",
+  ["NOT IN"]: "IN",
+  ["LIKE"]: "NOT LIKE",
+  ["NOT LIKE"]: "LIKE",
+  ["ILIKE"]: "NOT ILIKE",
+  ["NOT ILIKE"]: "ILIKE",
+  ["IS"]: "IS NOT",
+  ["IS NOT"]: "IS"
+};
+var negateOperatorMap = {
+  ...negateSimpleOperatorMap,
+  ["EXISTS"]: "NOT EXISTS",
+  ["NOT EXISTS"]: "EXISTS"
+};
+function negateOperator(op) {
+  return must(negateOperatorMap[op]);
+}
+function filterUndefined(array3) {
+  return array3.filter((e) => e !== void 0);
+}
+function filterTrue(conditions) {
+  return conditions.filter((c) => !isAlwaysTrue(c));
+}
+function filterFalse(conditions) {
+  return conditions.filter((c) => !isAlwaysFalse(c));
+}
+
 // ../zql/src/builder/like.ts
 function getLikePredicate(pattern, flags) {
   const op = getLikeOp(String(pattern), flags);
@@ -2503,11 +2672,11 @@ function createPredicateImpl(rhs, operator) {
     case "LIKE":
       return getLikePredicate(rhs, "");
     case "NOT LIKE":
-      return not(getLikePredicate(rhs, ""));
+      return not2(getLikePredicate(rhs, ""));
     case "ILIKE":
       return getLikePredicate(rhs, "i");
     case "NOT ILIKE":
-      return not(getLikePredicate(rhs, "i"));
+      return not2(getLikePredicate(rhs, "i"));
     case "IN": {
       assert(Array.isArray(rhs));
       const set = new Set(rhs);
@@ -2523,7 +2692,7 @@ function createPredicateImpl(rhs, operator) {
       throw new Error(`Unexpected operator: ${operator}`);
   }
 }
-function not(f) {
+function not2(f) {
   return (lhs) => !f(lhs);
 }
 function transformFilters(filters) {
@@ -2535,46 +2704,25 @@ function transformFilters(filters) {
       return { filters, conditionsRemoved: false };
     case "correlatedSubquery":
       return { filters: void 0, conditionsRemoved: true };
-    case "and": {
-      const transformedConditions = [];
-      for (const cond of filters.conditions) {
-        assert(cond.type === "simple" || cond.type === "correlatedSubquery");
-        if (cond.type === "simple") {
-          transformedConditions.push(cond);
-        }
-      }
-      const conditionsRemoved = transformedConditions.length !== filters.conditions.length;
-      if (transformedConditions.length === 0) {
-        return { filters: void 0, conditionsRemoved };
-      }
-      if (transformedConditions.length === 1) {
-        return {
-          filters: transformedConditions[0],
-          conditionsRemoved
-        };
-      }
-      return {
-        filters: {
-          type: "and",
-          conditions: transformedConditions
-        },
-        conditionsRemoved
-      };
-    }
+    case "and":
     case "or": {
       const transformedConditions = [];
       let conditionsRemoved = false;
       for (const cond of filters.conditions) {
-        assert(cond.type !== "or");
         const transformed = transformFilters(cond);
-        if (transformed.filters === void 0) {
+        if (transformed.filters === void 0 && filters.type === "or") {
           return { filters: void 0, conditionsRemoved: true };
         }
         conditionsRemoved = conditionsRemoved || transformed.conditionsRemoved;
-        transformedConditions.push(transformed.filters);
+        if (transformed.filters) {
+          transformedConditions.push(transformed.filters);
+        }
       }
       return {
-        filters: { type: "or", conditions: transformedConditions },
+        filters: simplifyCondition({
+          type: filters.type,
+          conditions: transformedConditions
+        }),
         conditionsRemoved
       };
     }
@@ -2601,7 +2749,9 @@ function buildPipelineInternal(ast, delegate, name, partitionKey) {
     ast.where
   );
   const splitEditKeys = partitionKey ? new Set(partitionKey) : /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Set();
   for (const csq of csqsFromCondition) {
+    aliases.add(csq.subquery.alias || "");
     for (const key of csq.correlation.parentField) {
       splitEditKeys.add(key);
     }
@@ -2708,11 +2858,10 @@ function isNotAndDoesNotContainSubquery(condition) {
   if (condition.type === "correlatedSubquery") {
     return false;
   }
-  if (condition.type === "and") {
-    return condition.conditions.every(isNotAndDoesNotContainSubquery);
+  if (condition.type === "simple") {
+    return true;
   }
-  assert(condition.type !== "or", "where conditions are expected to be in DNF");
-  return true;
+  return condition.conditions.every(isNotAndDoesNotContainSubquery);
 }
 function applySimpleCondition(input, condition) {
   return new Filter(input, createPredicate(condition));
@@ -2814,43 +2963,26 @@ function uniquifyCorrelatedSubqueryConditionAliases(ast) {
       }
     }
   });
-  const uniquifyAnd = (and2) => {
-    const conds2 = [];
-    for (const cond of and2.conditions) {
-      if (cond.type === "correlatedSubquery") {
-        conds2.push(uniquifyCorrelatedSubquery(cond));
-      } else {
-        conds2.push(cond);
-      }
+  const uniquify = (cond) => {
+    if (cond.type === "simple") {
+      return cond;
+    } else if (cond.type === "correlatedSubquery") {
+      return uniquifyCorrelatedSubquery(cond);
+    }
+    const conditions = [];
+    for (const c of cond.conditions) {
+      conditions.push(uniquify(c));
     }
     return {
-      ...and2,
-      conditions: conds2
+      type: cond.type,
+      conditions
     };
   };
-  if (where.type === "and") {
-    return {
-      ...ast,
-      where: uniquifyAnd(where)
-    };
-  }
-  const conds = [];
-  for (const cond of where.conditions) {
-    if (cond.type === "simple") {
-      conds.push(cond);
-    } else if (cond.type === "correlatedSubquery") {
-      conds.push(uniquifyCorrelatedSubquery(cond));
-    } else if (cond.type === "and") {
-      conds.push(uniquifyAnd(cond));
-    }
-  }
-  return {
+  const result = {
     ...ast,
-    where: {
-      ...where,
-      conditions: conds
-    }
+    where: uniquify(where)
   };
+  return result;
 }
 
 // ../zql/src/ivm/array-view.ts
@@ -2963,209 +3095,6 @@ function assertNoNotExists(condition) {
   }
 }
 
-// ../zql/src/query/expression.ts
-var ExpressionBuilder = class {
-  #exists;
-  constructor(exists) {
-    this.#exists = exists;
-    this.exists = this.exists.bind(this);
-  }
-  get eb() {
-    return this;
-  }
-  cmp(field, opOrValue, value) {
-    return cmp(field, opOrValue, value);
-  }
-  cmpLit(left, op, right) {
-    return {
-      type: "simple",
-      left: isParameterReference(left) ? left[toStaticParam]() : { type: "literal", value: left },
-      right: isParameterReference(right) ? right[toStaticParam]() : { type: "literal", value: right },
-      op
-    };
-  }
-  and = and;
-  or = or;
-  not = not2;
-  exists = (relationship, cb) => this.#exists(relationship, cb);
-};
-function and(...conditions) {
-  const expressions = filterTrue(filterUndefined(conditions));
-  if (expressions.length === 1) {
-    return expressions[0];
-  }
-  if (expressions.some(isAlwaysFalse)) {
-    return FALSE;
-  }
-  return { type: "and", conditions: expressions };
-}
-function or(...conditions) {
-  const expressions = filterFalse(filterUndefined(conditions));
-  if (expressions.length === 1) {
-    return expressions[0];
-  }
-  if (expressions.some(isAlwaysTrue)) {
-    return TRUE;
-  }
-  return { type: "or", conditions: expressions };
-}
-function not2(expression) {
-  switch (expression.type) {
-    case "and":
-      return {
-        type: "or",
-        conditions: expression.conditions.map(not2)
-      };
-    case "or":
-      return {
-        type: "and",
-        conditions: expression.conditions.map(not2)
-      };
-    case "correlatedSubquery":
-      return {
-        type: "correlatedSubquery",
-        related: expression.related,
-        op: negateOperator(expression.op)
-      };
-    case "simple":
-      return {
-        type: "simple",
-        op: negateOperator(expression.op),
-        left: expression.left,
-        right: expression.right
-      };
-  }
-}
-function cmp(field, opOrValue, value) {
-  let op;
-  if (value === void 0) {
-    value = opOrValue;
-    op = "=";
-  } else {
-    op = opOrValue;
-  }
-  return {
-    type: "simple",
-    left: { type: "column", name: field },
-    right: isParameterReference(value) ? value[toStaticParam]() : { type: "literal", value },
-    op
-  };
-}
-function isParameterReference(value) {
-  return value !== null && typeof value === "object" && value[toStaticParam];
-}
-var TRUE = {
-  type: "and",
-  conditions: []
-};
-var FALSE = {
-  type: "or",
-  conditions: []
-};
-function isAlwaysTrue(condition) {
-  return condition.type === "and" && condition.conditions.length === 0;
-}
-function isAlwaysFalse(condition) {
-  return condition.type === "or" && condition.conditions.length === 0;
-}
-function flatten(type, conditions) {
-  const flattened2 = [];
-  for (const c of conditions) {
-    if (c.type === type) {
-      flattened2.push(...c.conditions);
-    } else {
-      flattened2.push(c);
-    }
-  }
-  return flattened2;
-}
-var negateSimpleOperatorMap = {
-  ["="]: "!=",
-  ["!="]: "=",
-  ["<"]: ">=",
-  [">"]: "<=",
-  [">="]: "<",
-  ["<="]: ">",
-  ["IN"]: "NOT IN",
-  ["NOT IN"]: "IN",
-  ["LIKE"]: "NOT LIKE",
-  ["NOT LIKE"]: "LIKE",
-  ["ILIKE"]: "NOT ILIKE",
-  ["NOT ILIKE"]: "ILIKE",
-  ["IS"]: "IS NOT",
-  ["IS NOT"]: "IS"
-};
-var negateOperatorMap = {
-  ...negateSimpleOperatorMap,
-  ["EXISTS"]: "NOT EXISTS",
-  ["NOT EXISTS"]: "EXISTS"
-};
-function negateOperator(op) {
-  return must(negateOperatorMap[op]);
-}
-function filterUndefined(array3) {
-  return array3.filter((e) => e !== void 0);
-}
-function filterTrue(conditions) {
-  return conditions.filter((c) => !isAlwaysTrue(c));
-}
-function filterFalse(conditions) {
-  return conditions.filter((c) => !isAlwaysFalse(c));
-}
-
-// ../zql/src/query/dnf.ts
-function dnf(condition) {
-  return unwrap(dnfInner(condition));
-}
-function dnfInner(condition) {
-  switch (condition.type) {
-    case "simple":
-    case "correlatedSubquery":
-      return { type: "or", conditions: [condition] };
-    case "and":
-      return distributeAnd(condition.conditions.map(dnfInner));
-    case "or":
-      return {
-        type: "or",
-        conditions: flatten(
-          "or",
-          condition.conditions.map(dnfInner).flatMap((c) => c.conditions)
-        )
-      };
-    default:
-      unreachable(condition);
-  }
-}
-function distributeAnd(conditions) {
-  if (conditions.length === 0) {
-    return { type: "or", conditions: [TRUE] };
-  }
-  return conditions.reduce((acc, orCondition) => {
-    const newConditions = [];
-    for (const accCondition of acc.conditions) {
-      for (const orSubCondition of orCondition.conditions) {
-        newConditions.push({
-          type: "and",
-          conditions: [accCondition, orSubCondition]
-        });
-      }
-    }
-    return {
-      type: "or",
-      conditions: flatten("or", newConditions)
-    };
-  });
-}
-function unwrap(c) {
-  if (c.type === "simple" || c.type === "correlatedSubquery") {
-    return c;
-  }
-  if (c.conditions.length === 1) {
-    return unwrap(c.conditions[0]);
-  }
-  return { type: c.type, conditions: flatten(c.type, c.conditions.map(unwrap)) };
-}
-
 // ../zql/src/query/query-impl.ts
 var astSymbol = Symbol();
 function newQuery(delegate, schema, table) {
@@ -3371,7 +3300,7 @@ var AbstractQuery = class {
     if (existingWhere) {
       cond = and(existingWhere, cond);
     }
-    const where = dnf(cond);
+    const where = simplifyCondition(cond);
     if (this.#system === "client") {
       assertNoNotExists(where);
     }
@@ -3717,10 +3646,10 @@ export {
   mapCondition,
   hashOfAST,
   filterPush,
+  ExpressionBuilder,
   createPredicate,
   transformFilters,
   assertOrderingIncludesPK,
-  ExpressionBuilder,
   DEFAULT_TTL,
   parseTTL,
   compareTTL,
@@ -3732,4 +3661,4 @@ export {
   newQuerySymbol,
   AbstractQuery
 };
-//# sourceMappingURL=chunk-ILWAR46C.js.map
+//# sourceMappingURL=chunk-MIYN75UK.js.map