@rocicorp/zero 0.6.2024111800 → 0.6.2024112000

package/out/{chunk-N4TOAWSH.js → chunk-W4HNSZIF.js}

@@ -1535,7 +1535,7 @@ function displayList(word, expected, toDisplay2 = (x) => String(x)) {
   }
   return `${expected.slice(0, -2).map(toDisplay2).join(", ")}, ${suffix}`;
 }
-function getMessage(err2, v2) {
+function getMessage(err2, v2, schema, mode) {
   const firstIssue = err2.issues[0];
   const { path: path2 } = firstIssue;
   const atPath = path2?.length ? ` at ${path2.join(".")}` : "";
@@ -1570,7 +1570,7 @@ function getMessage(err2, v2) {
         firstIssue.keys
       )}${atPath}`;
     case "invalid_union":
-      return `Invalid union value${atPath}`;
+      return schema.name === "union" ? getDeepestUnionParseError(v2, schema, mode ?? "strict") : `Invalid union value${atPath}`;
     case "custom_error": {
       const { error } = firstIssue;
       const message = !error ? "unknown" : typeof error === "string" ? error : error.message ?? "unknown";
@@ -1578,6 +1578,43 @@ function getMessage(err2, v2) {
     }
   }
 }
+function getDeepestUnionParseError(value, schema, mode) {
+  const failures = [];
+  for (const type of schema.options) {
+    const r = type.try(value, { mode });
+    if (!r.ok) {
+      failures.push({ type, err: r });
+    }
+  }
+  if (failures.length) {
+    failures.sort(pathCmp);
+    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {
+      return getMessage(failures[0].err, value, failures[0].type, mode);
+    }
+  }
+  try {
+    const str = JSON.stringify(value);
+    return `Invalid union value: ${str}`;
+  } catch (e) {
+    return `Invalid union value`;
+  }
+}
+function pathCmp(a, b) {
+  const aPath = a.err.issues[0].path;
+  const bPath = b.err.issues[0].path;
+  if (aPath.length !== bPath.length) {
+    return bPath.length - aPath.length;
+  }
+  for (let i = 0; i < aPath.length; i++) {
+    if (bPath[i] > aPath[i]) {
+      return -1;
+    }
+    if (bPath[i] < aPath[i]) {
+      return 1;
+    }
+  }
+  return 0;
+}
 function parse(value, schema, mode) {
   const res = test(value, schema, mode);
   if (!res.ok) {
@@ -1594,7 +1631,10 @@ function assert2(value, schema, mode) {
 function test(value, schema, mode) {
   const res = schema.try(value, mode ? { mode } : void 0);
   if (!res.ok) {
-    return { ok: false, error: getMessage(res, value) };
+    return {
+      ok: false,
+      error: getMessage(res, value, schema, mode)
+    };
   }
   return res;
 }
@@ -1612,7 +1652,7 @@ function testOptional(value, schema, mode) {
     return res;
   }
   const err2 = new v.ValitaError(res);
-  return { ok: false, error: getMessage(err2, value) };
+  return { ok: false, error: getMessage(err2, value, schema, mode) };
 }
 function readonly(t2) {
   return t2;
@@ -9488,23 +9528,36 @@ var simpleOperatorSchema = valita_exports.union(
   likeOpsSchema,
   inOpsSchema
 );
-var simpleConditionSchema = valita_exports.object({
-  type: valita_exports.literal("simple"),
-  op: simpleOperatorSchema,
-  field: selectorSchema,
+var literalReferenceSchema = valita_exports.object({
+  type: valita_exports.literal("literal"),
   value: valita_exports.union(
     valita_exports.string(),
     valita_exports.number(),
     valita_exports.boolean(),
     valita_exports.null(),
-    readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean())),
-    valita_exports.object({
-      type: valita_exports.literal("static"),
-      anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
-      field: valita_exports.string()
-    })
+    readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean()))
   )
 });
+var columnReferenceSchema = valita_exports.object({
+  type: valita_exports.literal("column"),
+  name: valita_exports.string()
+});
+var parameterReferenceSchema = valita_exports.object({
+  type: valita_exports.literal("static"),
+  anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
+  field: valita_exports.string()
+});
+var conditionValueSchema = valita_exports.union(
+  literalReferenceSchema,
+  columnReferenceSchema,
+  parameterReferenceSchema
+);
+var simpleConditionSchema = valita_exports.object({
+  type: valita_exports.literal("simple"),
+  op: simpleOperatorSchema,
+  left: conditionValueSchema,
+  right: valita_exports.union(parameterReferenceSchema, literalReferenceSchema)
+});
 var correlatedSubqueryConditionOperatorSchema = valita_exports.union(
   valita_exports.literal("EXISTS"),
   valita_exports.literal("NOT EXISTS")
@@ -9601,10 +9654,7 @@ function cmpCondition(a, b) {
     if (b.type !== "simple") {
       return -1;
     }
-    return compareUTF8MaybeNull(a.field, b.field) || compareUTF8MaybeNull(a.op, b.op) || // Comparing the same field with the same op more than once doesn't make logical
-    // sense, but is technically possible. Assume the values are of the same type and
-    // sort by their String forms.
-    compareUTF8MaybeNull(String(a.value), String(b.value));
+    return compareValuePosition(a.left, b.left) || compareUTF8MaybeNull(a.op, b.op) || compareValuePosition(a.right, b.right);
   }
   if (b.type === "simple") {
     return 1;
@@ -9630,6 +9680,23 @@ function cmpCondition(a, b) {
   }
   return a.conditions.length - b.conditions.length;
 }
+function compareValuePosition(a, b) {
+  if (a.type !== b.type) {
+    return compareUTF83(a.type, b.type);
+  }
+  switch (a.type) {
+    case "literal":
+      assert(b.type === "literal");
+      return compareUTF8MaybeNull(String(a.value), String(b.value));
+    case "column":
+      assert(b.type === "column");
+      return compareUTF83(a.name, b.name);
+    case "static":
+      throw new Error(
+        "Static parameters should be resolved before normalization"
+      );
+  }
+}
 function cmpRelated(a, b) {
   return compareUTF83(must(a.subquery.alias), must(b.subquery.alias));
 }
@@ -10933,10 +11000,6 @@ function getTakeStateKey(partitionValue) {
   return JSON.stringify(["take", normalizeUndefined(partitionValue)]);
 }
 
-// ../zql/src/builder/error.ts
-var MissingParameterError = class extends Error {
-};
-
 // ../zql/src/builder/like.ts
 function getLikePredicate(pattern, flags) {
   const op = getLikeOp(String(pattern), flags);
@@ -10987,19 +11050,40 @@ function patternToRegExp(source, flags = "") {
 
 // ../zql/src/builder/filter.ts
 function createPredicate(condition) {
+  const { left } = condition;
+  const { right } = condition;
+  assert(
+    right.type !== "static",
+    "static values should be resolved before creating predicates"
+  );
+  assert(
+    left.type !== "static",
+    "static values should be resolved before creating predicates"
+  );
   switch (condition.op) {
     case "IS":
     case "IS NOT": {
-      const impl2 = createIsPredicate(condition.value, condition.op);
-      return (row) => impl2(row[condition.field]);
+      const impl2 = createIsPredicate(right.value, condition.op);
+      if (left.type === "literal") {
+        const result = impl2(left.value);
+        return () => result;
+      }
+      return (row) => impl2(row[left.name]);
     }
   }
-  if (condition.value === null || condition.value === void 0) {
+  if (right.value === null || right.value === void 0) {
     return (_row) => false;
   }
-  const impl = createPredicateImpl(condition.value, condition.op);
+  const impl = createPredicateImpl(right.value, condition.op);
+  if (left.type === "literal") {
+    if (left.value === null || left.value === void 0) {
+      return (_row) => false;
+    }
+    const result = impl(left.value);
+    return () => result;
+  }
   return (row) => {
-    const lhs = row[condition.field];
+    const lhs = row[left.name];
     if (lhs === null || lhs === void 0) {
       return false;
     }
@@ -11081,7 +11165,8 @@ function bindStaticParameters(ast, staticQueryParameters) {
     if (condition.type === "simple") {
       return {
         ...condition,
-        value: bindValue(condition.value)
+        left: bindValue(condition.left),
+        right: bindValue(condition.right)
       };
     }
     if (condition.type === "correlatedSubquery") {
@@ -11104,19 +11189,18 @@ function bindStaticParameters(ast, staticQueryParameters) {
         staticQueryParameters,
         "Static query params do not exist"
       )[value.anchor];
-      assert(anchor !== void 0, `Missing parameter: ${value.anchor}`);
-      const resolvedValue = anchor[value.field];
-      if (resolvedValue == null) {
-        throw new MissingParameterError();
-      }
-      return resolvedValue;
+      const resolvedValue = anchor?.[value.field] ?? null;
+      return {
+        type: "literal",
+        value: resolvedValue
+      };
     }
     return value;
   };
   return visit(ast);
 }
 function isParameter(value) {
-  return typeof value === "object" && value !== null && "type" in value;
+  return value.type === "static";
 }
 function buildPipelineInternal(ast, delegate, staticQueryParameters, partitionKey) {
   const source = delegate.getSource(ast.table);
@@ -11154,7 +11238,7 @@ function applyWhere(input, condition, appliedFilters, delegate) {
       return applyOr(input, condition, appliedFilters, delegate);
     case "correlatedSubquery":
       return applyCorrelatedSubqueryCondition(input, condition, delegate);
-    default:
+    case "simple":
       return applySimpleCondition(input, condition, appliedFilters);
   }
 }
@@ -11229,7 +11313,7 @@ function gatherCorrelatedSubqueryQueriesFromCondition(condition) {
   }
   return csqs;
 }
-var EXISTS_LIMIT = 5;
+var EXISTS_LIMIT = 3;
 function assertOrderingIncludesPK(ordering, pk) {
   const orderingFields = ordering.map(([field]) => field);
   const missingFields = pk.filter((pkField) => !orderingFields.includes(pkField));
@@ -11380,6 +11464,14 @@ var ExpressionBuilder = class {
   cmp(field, opOrValue, value) {
     return cmp(field, opOrValue, value);
   }
+  cmpLit(left, op, right) {
+    return {
+      type: "simple",
+      left: isParameter2(left) ? left : { type: "literal", value: left },
+      right: isParameter2(right) ? right : { type: "literal", value: right },
+      op
+    };
+  }
   and = and;
   or = or;
   not = not2;
@@ -11425,12 +11517,12 @@ function not2(expression) {
         related: expression.related,
         op: negateOperator(expression.op)
       };
-    default:
+    case "simple":
       return {
         type: "simple",
         op: negateOperator(expression.op),
-        field: expression.field,
-        value: expression.value
+        left: expression.left,
+        right: expression.right
       };
   }
 }
@@ -11444,11 +11536,14 @@ function cmp(field, opOrValue, value) {
   }
   return {
     type: "simple",
-    field,
-    op,
-    value
+    left: { type: "column", name: field },
+    right: isParameter2(value) ? value : { type: "literal", value },
+    op
   };
 }
+function isParameter2(value) {
+  return typeof value === "object" && value?.type === "static";
+}
 var TRUE = {
   type: "and",
   conditions: []
@@ -12010,13 +12105,13 @@ function compileRowConfig(rowRules) {
     return void 0;
   }
   return {
-    select: compileInstanceRules(rowRules.select),
-    insert: compileInstanceRules(rowRules.insert),
-    update: compileInstanceRules(rowRules.update),
-    delete: compileInstanceRules(rowRules.delete)
+    select: compileRules(rowRules.select),
+    insert: compileRules(rowRules.insert),
+    update: compileRules(rowRules.update),
+    delete: compileRules(rowRules.delete)
   };
 }
-function compileInstanceRules(rules) {
+function compileRules(rules) {
   if (!rules) {
     return void 0;
   }
@@ -12037,10 +12132,10 @@ function compileCellConfig(cellRules) {
   const ret = {};
   for (const [columnName, rules] of Object.entries(cellRules)) {
     ret[columnName] = {
-      select: compileInstanceRules(rules.select),
-      insert: compileInstanceRules(rules.insert),
-      update: compileInstanceRules(rules.update),
-      delete: compileInstanceRules(rules.delete)
+      select: compileRules(rules.select),
+      insert: compileRules(rules.insert),
+      update: compileRules(rules.update),
+      delete: compileRules(rules.delete)
     };
   }
   return ret;
@@ -15141,7 +15236,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.6.2024111800+725d79";
+var version2 = "0.6.2024112000+47c38e";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -17115,4 +17210,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-N4TOAWSH.js.map
+//# sourceMappingURL=chunk-W4HNSZIF.js.map