@rocicorp/zero 0.14.2025021001 → 0.14.2025021100

package/out/{chunk-MVLDKRBK.js → chunk-OPWNICE2.js}

@@ -8937,157 +8937,12 @@ function compareUTF8MaybeNull(a, b) {
   return 0;
 }
 
-// ../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) {
-    return 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 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(array12) {
-  return array12.filter((e) => e !== void 0);
-}
-function filterTrue(conditions) {
-  return conditions.filter((c) => !isAlwaysTrue(c));
-}
-function filterFalse(conditions) {
-  return conditions.filter((c) => !isAlwaysFalse(c));
-}
+// ../zero-protocol/src/protocol-version.ts
+var PROTOCOL_VERSION = 5;
+var MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 2;
+assert(MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION);
+var MIN_SERVER_SUPPORTED_PERMISSIONS_PROTOCOL = 4;
+assert(MIN_SERVER_SUPPORTED_PERMISSIONS_PROTOCOL < PROTOCOL_VERSION);
 
 // ../zql/src/query/query-impl.ts
 import { resolver as resolver7 } from "@rocicorp/resolver";
@@ -10538,11 +10393,11 @@ function createPredicateImpl(rhs, operator) {
     case "LIKE":
       return getLikePredicate(rhs, "");
     case "NOT LIKE":
-      return not2(getLikePredicate(rhs, ""));
+      return not(getLikePredicate(rhs, ""));
     case "ILIKE":
       return getLikePredicate(rhs, "i");
     case "NOT ILIKE":
-      return not2(getLikePredicate(rhs, "i"));
+      return not(getLikePredicate(rhs, "i"));
     case "IN": {
       assert(Array.isArray(rhs));
       const set = new Set(rhs);
@@ -10558,7 +10413,7 @@ function createPredicateImpl(rhs, operator) {
       throw new Error(`Unexpected operator: ${operator}`);
   }
 }
-function not2(f) {
+function not(f) {
   return (lhs) => !f(lhs);
 }
 function transformFilters(filters) {
@@ -10929,6 +10784,158 @@ var ArrayView = class {
   }
 };
 
+// ../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) {
+    return 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(array12) {
+  return array12.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));
@@ -11596,10 +11603,13 @@ function compilePermissions(schema, authz, expressionBuilders) {
     return void 0;
   }
   const nameMapper = clientToServer(schema.tables);
-  const ret = {};
+  const ret = {
+    protocolVersion: PROTOCOL_VERSION,
+    tables: {}
+  };
   for (const [tableName, tableConfig] of Object.entries(authz)) {
     const serverName = schema.tables[tableName].serverName ?? tableName;
-    ret[serverName] = {
+    ret.tables[serverName] = {
       row: compileRowConfig(
         nameMapper,
         tableName,
@@ -12032,11 +12042,6 @@ var downstreamSchema = valita_exports.union(
 var CRUD = "crud";
 var Custom = "custom";
 
-// ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 5;
-var MIN_SERVER_SUPPORTED_PROTOCOL_VERSION = 2;
-assert(MIN_SERVER_SUPPORTED_PROTOCOL_VERSION < PROTOCOL_VERSION);
-
 // ../zero-protocol/src/push.ts
 var CRUD_MUTATION_NAME = "_zero_crud";
 var insertOpSchema = valita_exports.object({
@@ -13379,48 +13384,28 @@ var ZeroContext = class {
 // ../zero-client/src/client/crud.ts
 function makeCRUDMutate(schema, repMutate) {
   const { [CRUD_MUTATION_NAME]: zeroCRUD } = repMutate;
-  let inBatch = false;
   const mutateBatch = async (body) => {
-    if (inBatch) {
-      throw new Error("Cannot call mutate inside a batch");
-    }
-    inBatch = true;
-    try {
-      const ops = [];
-      const m = {};
-      for (const name of Object.keys(schema.tables)) {
-        m[name] = makeBatchCRUDMutate(name, schema, ops);
-      }
-      const rv = await body(m);
-      await zeroCRUD({ ops });
-      return rv;
-    } finally {
-      inBatch = false;
-    }
-  };
-  const assertNotInBatch = (tableName, op) => {
-    if (inBatch) {
-      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
+    const ops = [];
+    const m = {};
+    for (const name of Object.keys(schema.tables)) {
+      m[name] = makeBatchCRUDMutate(name, schema, ops);
     }
+    const rv = await body(m);
+    await zeroCRUD({ ops });
+    return rv;
   };
   const mutate = {};
   for (const [name, tableSchema] of Object.entries(schema.tables)) {
-    mutate[name] = makeEntityCRUDMutate(
-      name,
-      tableSchema.primaryKey,
-      zeroCRUD,
-      assertNotInBatch
-    );
+    mutate[name] = makeEntityCRUDMutate(name, tableSchema.primaryKey, zeroCRUD);
   }
   return {
     mutate,
     mutateBatch
   };
 }
-function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
+function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD) {
   return {
     insert: (value) => {
-      assertNotInBatch(tableName, "insert");
       const op = {
         op: "insert",
         tableName,
@@ -13430,7 +13415,6 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
       return zeroCRUD({ ops: [op] });
     },
     upsert: (value) => {
-      assertNotInBatch(tableName, "upsert");
       const op = {
         op: "upsert",
         tableName,
@@ -13440,7 +13424,6 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
       return zeroCRUD({ ops: [op] });
     },
     update: (value) => {
-      assertNotInBatch(tableName, "update");
       const op = {
         op: "update",
         tableName,
@@ -13450,7 +13433,6 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
       return zeroCRUD({ ops: [op] });
     },
     delete: (id) => {
-      assertNotInBatch(tableName, "delete");
       const op = {
         op: "delete",
         tableName,
@@ -13996,7 +13978,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.14.2025021001";
+var version2 = "0.14.2025021100";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -16152,4 +16134,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-MVLDKRBK.js.map
+//# sourceMappingURL=chunk-OPWNICE2.js.map