@zenstackhq/runtime 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/client/client-impl.ts
-import { invariant as invariant15 } from "@zenstackhq/common-helpers";
+import { invariant as invariant14 } from "@zenstackhq/common-helpers";
 import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql9, Transaction } from "kysely";
 
 // src/client/crud/operations/aggregate.ts
@@ -81,6 +81,9 @@ var ExpressionUtils = {
   or: /* @__PURE__ */ __name((expr2, ...expressions) => {
     return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
   }, "or"),
+  not: /* @__PURE__ */ __name((expr2) => {
+    return ExpressionUtils.unary("!", expr2);
+  }, "not"),
   is: /* @__PURE__ */ __name((value, kind) => {
     return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
   }, "is"),
@@ -141,22 +144,26 @@ var NotFoundError = class extends Error {
   static {
     __name(this, "NotFoundError");
   }
-  constructor(model) {
-    super(`Entity not found for model "${model}"`);
+  constructor(model, details) {
+    super(`Entity not found for model "${model}"${details ? `: ${details}` : ""}`);
   }
 };
 
 // src/client/query-utils.ts
 function getModel(schema, model) {
-  return schema.models[model];
+  return Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
 }
 __name(getModel, "getModel");
+function getTypeDef(schema, type) {
+  return schema.typeDefs?.[type];
+}
+__name(getTypeDef, "getTypeDef");
 function requireModel(schema, model) {
-  const matchedName = Object.keys(schema.models).find((k) => k.toLowerCase() === model.toLowerCase());
-  if (!matchedName) {
+  const modelDef = getModel(schema, model);
+  if (!modelDef) {
     throw new QueryError(`Model "${model}" not found in schema`);
   }
-  return schema.models[matchedName];
+  return modelDef;
 }
 __name(requireModel, "requireModel");
 function getField(schema, model, field) {
@@ -164,12 +171,24 @@ function getField(schema, model, field) {
   return modelDef?.fields[field];
 }
 __name(getField, "getField");
-function requireField(schema, model, field) {
-  const modelDef = requireModel(schema, model);
-  if (!modelDef.fields[field]) {
-    throw new QueryError(`Field "${field}" not found in model "${model}"`);
+function requireField(schema, modelOrType, field) {
+  const modelDef = getModel(schema, modelOrType);
+  if (modelDef) {
+    if (!modelDef.fields[field]) {
+      throw new QueryError(`Field "${field}" not found in model "${modelOrType}"`);
+    } else {
+      return modelDef.fields[field];
+    }
   }
-  return modelDef.fields[field];
+  const typeDef = getTypeDef(schema, modelOrType);
+  if (typeDef) {
+    if (!typeDef.fields[field]) {
+      throw new QueryError(`Field "${field}" not found in type "${modelOrType}"`);
+    } else {
+      return typeDef.fields[field];
+    }
+  }
+  throw new QueryError(`Model or type "${modelOrType}" not found in schema`);
 }
 __name(requireField, "requireField");
 function getIdFields(schema, model) {
@@ -465,7 +484,7 @@ var RejectedByPolicyError = class extends Error {
 
 // src/plugins/policy/policy-handler.ts
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode3, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode2, DeleteQueryNode, FromNode as FromNode2, IdentifierNode as IdentifierNode2, InsertQueryNode, OperationNodeTransformer, OperatorNode as OperatorNode3, PrimitiveValueListNode, RawNode, ReturningNode, SelectionNode as SelectionNode2, SelectQueryNode as SelectQueryNode2, TableNode as TableNode3, UpdateQueryNode, ValueNode as ValueNode3, ValuesNode, WhereNode as WhereNode2 } from "kysely";
+import { AliasNode as AliasNode3, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode2, DeleteQueryNode, FromNode as FromNode2, FunctionNode as FunctionNode3, IdentifierNode as IdentifierNode2, InsertQueryNode, OperationNodeTransformer, OperatorNode as OperatorNode3, ParensNode as ParensNode2, PrimitiveValueListNode, RawNode, ReturningNode, SelectionNode as SelectionNode2, SelectQueryNode as SelectQueryNode2, TableNode as TableNode3, UpdateQueryNode, ValueListNode as ValueListNode2, ValueNode as ValueNode3, ValuesNode, WhereNode as WhereNode2 } from "kysely";
 import { match as match8 } from "ts-pattern";
 
 // src/client/crud/dialects/index.ts
@@ -497,7 +516,7 @@ var AGGREGATE_OPERATORS = [
   "_max"
 ];
 
-// src/client/crud/dialects/base.ts
+// src/client/crud/dialects/base-dialect.ts
 import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
 import { expressionBuilder, sql } from "kysely";
 import { match as match2, P } from "ts-pattern";
@@ -516,7 +535,7 @@ function enumerate(x) {
 }
 __name(enumerate, "enumerate");
 
-// src/client/crud/dialects/base.ts
+// src/client/crud/dialects/base-dialect.ts
 var BaseCrudDialect = class {
   static {
     __name(this, "BaseCrudDialect");
@@ -1890,6 +1909,12 @@ function isFalseNode(node) {
 }
 __name(isFalseNode, "isFalseNode");
 function conjunction(dialect, nodes) {
+  if (nodes.length === 0) {
+    return trueNode(dialect);
+  }
+  if (nodes.length === 1) {
+    return nodes[0];
+  }
   if (nodes.some(isFalseNode)) {
     return falseNode(dialect);
   }
@@ -1897,10 +1922,16 @@ function conjunction(dialect, nodes) {
   if (items.length === 0) {
     return trueNode(dialect);
   }
-  return items.reduce((acc, node) => OrNode.is(node) ? AndNode.create(acc, ParensNode.create(node)) : AndNode.create(acc, node));
+  return items.reduce((acc, node) => AndNode.create(wrapParensIf(acc, OrNode.is), wrapParensIf(node, OrNode.is)));
 }
 __name(conjunction, "conjunction");
 function disjunction(dialect, nodes) {
+  if (nodes.length === 0) {
+    return falseNode(dialect);
+  }
+  if (nodes.length === 1) {
+    return nodes[0];
+  }
   if (nodes.some(isTrueNode)) {
     return trueNode(dialect);
   }
@@ -1908,13 +1939,23 @@ function disjunction(dialect, nodes) {
   if (items.length === 0) {
     return falseNode(dialect);
   }
-  return items.reduce((acc, node) => AndNode.is(node) ? OrNode.create(acc, ParensNode.create(node)) : OrNode.create(acc, node));
+  return items.reduce((acc, node) => OrNode.create(wrapParensIf(acc, AndNode.is), wrapParensIf(node, AndNode.is)));
 }
 __name(disjunction, "disjunction");
-function logicalNot(node) {
-  return UnaryOperationNode.create(OperatorNode.create("not"), AndNode.is(node) || OrNode.is(node) ? ParensNode.create(node) : node);
+function logicalNot(dialect, node) {
+  if (isTrueNode(node)) {
+    return falseNode(dialect);
+  }
+  if (isFalseNode(node)) {
+    return trueNode(dialect);
+  }
+  return UnaryOperationNode.create(OperatorNode.create("not"), wrapParensIf(node, (n) => AndNode.is(n) || OrNode.is(n)));
 }
 __name(logicalNot, "logicalNot");
+function wrapParensIf(node, predicate) {
+  return predicate(node) ? ParensNode.create(node) : node;
+}
+__name(wrapParensIf, "wrapParensIf");
 function buildIsFalse(node, dialect) {
   if (isFalseNode(node)) {
     return trueNode(dialect);
@@ -2005,11 +2046,7 @@ var ExpressionTransformer = class {
   _field(expr2, context) {
     const fieldDef = requireField(this.schema, context.model, expr2.field);
     if (!fieldDef.relation) {
-      if (context.thisEntity) {
-        return context.thisEntity[expr2.field];
-      } else {
-        return this.createColumnRef(expr2.field, context);
-      }
+      return this.createColumnRef(expr2.field, context);
     } else {
       const { memberFilter, memberSelect, ...restContext } = context;
       const relation = this.transformRelationAccess(expr2.field, fieldDef.type, restContext);
@@ -2050,7 +2087,7 @@ var ExpressionTransformer = class {
       ]);
     }
     if (this.isAuthCall(expr2.left) || this.isAuthCall(expr2.right)) {
-      return this.transformAuthBinary(expr2);
+      return this.transformAuthBinary(expr2, context);
     }
     const op = expr2.op;
     if (op === "?" || op === "!" || op === "^") {
@@ -2103,11 +2140,10 @@ var ExpressionTransformer = class {
     let predicateFilter = this.transform(expr2.right, {
       ...context,
       model: newContextModel,
-      alias: void 0,
-      thisEntity: void 0
+      alias: void 0
     });
     if (expr2.op === "!") {
-      predicateFilter = logicalNot(predicateFilter);
+      predicateFilter = logicalNot(this.dialect, predicateFilter);
     }
     const count = FunctionNode2.create("count", [
       ValueNode2.createImmediate(1)
@@ -2119,20 +2155,38 @@ var ExpressionTransformer = class {
       memberFilter: predicateFilter
     });
   }
-  transformAuthBinary(expr2) {
+  transformAuthBinary(expr2, context) {
     if (expr2.op !== "==" && expr2.op !== "!=") {
-      throw new Error(`Unsupported operator for auth call: ${expr2.op}`);
+      throw new QueryError(`Unsupported operator for \`auth()\` in policy of model "${context.model}": ${expr2.op}`);
     }
+    let authExpr;
     let other;
     if (this.isAuthCall(expr2.left)) {
+      authExpr = expr2.left;
       other = expr2.right;
     } else {
+      authExpr = expr2.right;
       other = expr2.left;
     }
     if (ExpressionUtils.isNull(other)) {
       return this.transformValue(expr2.op === "==" ? !this.auth : !!this.auth, "Boolean");
     } else {
-      throw new Error("Unsupported binary expression with `auth()`");
+      const authModel = getModel(this.schema, this.authType);
+      if (!authModel) {
+        throw new QueryError(`Unsupported use of \`auth()\` in policy of model "${context.model}", comparing with \`auth()\` is only possible when auth type is a model`);
+      }
+      const idFields = Object.values(authModel.fields).filter((f) => f.id).map((f) => f.name);
+      invariant5(idFields.length > 0, "auth type model must have at least one id field");
+      const conditions = idFields.map((fieldName) => ExpressionUtils.binary(ExpressionUtils.member(authExpr, [
+        fieldName
+      ]), "==", ExpressionUtils.member(other, [
+        fieldName
+      ])));
+      let result = this.buildAnd(conditions);
+      if (expr2.op === "!=") {
+        result = this.buildLogicalNot(result);
+      }
+      return this.transform(result, context);
     }
   }
   transformValue(value, type) {
@@ -2140,7 +2194,7 @@ var ExpressionTransformer = class {
   }
   _unary(expr2, context) {
     invariant5(expr2.op === "!", 'only "!" operator is supported');
-    return BinaryOperationNode2.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
+    return logicalNot(this.dialect, this.transform(expr2.operand, context));
   }
   transformOperator(op) {
     const mappedOp = match7(op).with("==", () => "=").otherwise(() => op);
@@ -2167,7 +2221,7 @@ var ExpressionTransformer = class {
       return eb.val(arg.value);
     }
     if (ExpressionUtils.isField(arg)) {
-      return context.thisEntityRaw ? eb.val(context.thisEntityRaw[arg.field]) : eb.ref(arg.field);
+      return eb.ref(arg.field);
     }
     if (ExpressionUtils.isCall(arg)) {
       return this.transformCall(arg, context);
@@ -2182,14 +2236,33 @@ var ExpressionTransformer = class {
     if (this.isAuthCall(expr2.receiver)) {
       return this.valueMemberAccess(this.auth, expr2, this.authType);
     }
-    invariant5(ExpressionUtils.isField(expr2.receiver), "expect receiver to be field expression");
+    invariant5(ExpressionUtils.isField(expr2.receiver) || ExpressionUtils.isThis(expr2.receiver), 'expect receiver to be field expression or "this"');
+    let members = expr2.members;
+    let receiver;
     const { memberFilter, memberSelect, ...restContext } = context;
-    const receiver = this.transform(expr2.receiver, restContext);
+    if (ExpressionUtils.isThis(expr2.receiver)) {
+      if (expr2.members.length === 1) {
+        const fieldDef = requireField(this.schema, context.model, expr2.members[0]);
+        invariant5(!fieldDef.relation, "this.relation access should have been transformed into relation access");
+        return this.createColumnRef(expr2.members[0], restContext);
+      }
+      const firstMemberFieldDef = requireField(this.schema, context.model, expr2.members[0]);
+      receiver = this.transformRelationAccess(expr2.members[0], firstMemberFieldDef.type, restContext);
+      members = expr2.members.slice(1);
+    } else {
+      receiver = this.transform(expr2.receiver, restContext);
+    }
     invariant5(SelectQueryNode.is(receiver), "expected receiver to be select query");
-    const receiverField = requireField(this.schema, context.model, expr2.receiver.field);
+    let startType;
+    if (ExpressionUtils.isField(expr2.receiver)) {
+      const receiverField = requireField(this.schema, context.model, expr2.receiver.field);
+      startType = receiverField.type;
+    } else {
+      startType = context.model;
+    }
     const memberFields = [];
-    let currType = receiverField.type;
-    for (const member of expr2.members) {
+    let currType = startType;
+    for (const member of members) {
       const fieldDef = requireField(this.schema, currType, member);
       memberFields.push({
         fieldDef,
@@ -2198,22 +2271,21 @@ var ExpressionTransformer = class {
       currType = fieldDef.type;
     }
     let currNode = void 0;
-    for (let i = expr2.members.length - 1; i >= 0; i--) {
-      const member = expr2.members[i];
+    for (let i = members.length - 1; i >= 0; i--) {
+      const member = members[i];
       const { fieldDef, fromModel } = memberFields[i];
       if (fieldDef.relation) {
         const relation = this.transformRelationAccess(member, fieldDef.type, {
           ...restContext,
           model: fromModel,
-          alias: void 0,
-          thisEntity: void 0
+          alias: void 0
         });
         if (currNode) {
           invariant5(SelectQueryNode.is(currNode), "expected select query node");
           currNode = {
             ...relation,
             selections: [
-              SelectionNode.create(AliasNode2.create(currNode, IdentifierNode.create(expr2.members[i + 1])))
+              SelectionNode.create(AliasNode2.create(currNode, IdentifierNode.create(members[i + 1])))
             ]
           };
         } else {
@@ -2226,7 +2298,7 @@ var ExpressionTransformer = class {
           };
         }
       } else {
-        invariant5(i === expr2.members.length - 1, "plain field access must be the last segment");
+        invariant5(i === members.length - 1, "plain field access must be the last segment");
         invariant5(!currNode, "plain field access must be the last segment");
         currNode = ColumnNode.create(member);
       }
@@ -2253,35 +2325,19 @@ var ExpressionTransformer = class {
   transformRelationAccess(field, relationModel, context) {
     const fromModel = context.model;
     const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, fromModel, field);
-    if (context.thisEntity) {
-      let condition;
-      if (ownedByModel) {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode2.create(ColumnNode.create(pk), TableNode2.create(relationModel)), OperatorNode2.create("="), context.thisEntity[fk])));
-      } else {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode2.create(ColumnNode.create(fk), TableNode2.create(relationModel)), OperatorNode2.create("="), context.thisEntity[pk])));
-      }
-      return {
-        kind: "SelectQueryNode",
-        from: FromNode.create([
-          TableNode2.create(relationModel)
-        ]),
-        where: WhereNode.create(condition)
-      };
+    let condition;
+    if (ownedByModel) {
+      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode2.create(ColumnNode.create(fk), TableNode2.create(context.alias ?? fromModel)), OperatorNode2.create("="), ReferenceNode2.create(ColumnNode.create(pk), TableNode2.create(relationModel)))));
     } else {
-      let condition;
-      if (ownedByModel) {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode2.create(ColumnNode.create(fk), TableNode2.create(context.alias ?? fromModel)), OperatorNode2.create("="), ReferenceNode2.create(ColumnNode.create(pk), TableNode2.create(relationModel)))));
-      } else {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode2.create(ColumnNode.create(pk), TableNode2.create(context.alias ?? fromModel)), OperatorNode2.create("="), ReferenceNode2.create(ColumnNode.create(fk), TableNode2.create(relationModel)))));
-      }
-      return {
-        kind: "SelectQueryNode",
-        from: FromNode.create([
-          TableNode2.create(relationModel)
-        ]),
-        where: WhereNode.create(condition)
-      };
+      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode2.create(ColumnNode.create(pk), TableNode2.create(context.alias ?? fromModel)), OperatorNode2.create("="), ReferenceNode2.create(ColumnNode.create(fk), TableNode2.create(relationModel)))));
     }
+    return {
+      kind: "SelectQueryNode",
+      from: FromNode.create([
+        TableNode2.create(relationModel)
+      ]),
+      where: WhereNode.create(condition)
+    };
   }
   createColumnRef(column, context) {
     return ReferenceNode2.create(ColumnNode.create(column), TableNode2.create(context.alias ?? context.model));
@@ -2295,6 +2351,18 @@ var ExpressionTransformer = class {
   isNullNode(node) {
     return ValueNode2.is(node) && node.value === null;
   }
+  buildLogicalNot(result) {
+    return ExpressionUtils.unary("!", result);
+  }
+  buildAnd(conditions) {
+    if (conditions.length === 0) {
+      return ExpressionUtils.literal(true);
+    } else if (conditions.length === 1) {
+      return conditions[0];
+    } else {
+      return conditions.reduce((acc, condition) => ExpressionUtils.binary(acc, "&&", condition));
+    }
+  }
 };
 _ts_decorate([
   expr("literal"),
@@ -2424,29 +2492,47 @@ var PolicyHandler = class extends OperationNodeTransformer {
     return selectedColumns.every((c) => idFields.includes(c));
   }
   async enforcePreCreatePolicy(node, proceed) {
-    if (!node.columns || !node.values) {
-      return;
-    }
     const model = this.getMutationModel(node);
-    const fields = node.columns.map((c) => c.column.name);
-    const valueRows = this.unwrapCreateValueRows(node.values, model, fields);
+    const fields = node.columns?.map((c) => c.column.name) ?? [];
+    const valueRows = node.values ? this.unwrapCreateValueRows(node.values, model, fields) : [
+      []
+    ];
     for (const values of valueRows) {
-      await this.enforcePreCreatePolicyForOne(model, fields, values.map((v) => v.node), values.map((v) => v.raw), proceed);
+      await this.enforcePreCreatePolicyForOne(model, fields, values.map((v) => v.node), proceed);
     }
   }
-  async enforcePreCreatePolicyForOne(model, fields, values, valuesRaw, proceed) {
-    const thisEntity = {};
-    const thisEntityRaw = {};
-    for (let i = 0; i < fields.length; i++) {
-      thisEntity[fields[i]] = values[i];
-      thisEntityRaw[fields[i]] = valuesRaw[i];
+  async enforcePreCreatePolicyForOne(model, fields, values, proceed) {
+    const allFields = Object.keys(requireModel(this.client.$schema, model).fields);
+    const allValues = [];
+    for (const fieldName of allFields) {
+      const index = fields.indexOf(fieldName);
+      if (index >= 0) {
+        allValues.push(values[index]);
+      } else {
+        allValues.push(ValueNode3.createImmediate(null));
+      }
     }
-    const filter = this.buildPolicyFilter(model, void 0, "create", thisEntity, thisEntityRaw);
+    const constTable = {
+      kind: "SelectQueryNode",
+      from: FromNode2.create([
+        AliasNode3.create(ParensNode2.create(ValuesNode.create([
+          ValueListNode2.create(allValues)
+        ])), IdentifierNode2.create("$t"))
+      ]),
+      selections: allFields.map((field, index) => SelectionNode2.create(AliasNode3.create(ColumnNode2.create(`column${index + 1}`), IdentifierNode2.create(field))))
+    };
+    const filter = this.buildPolicyFilter(model, void 0, "create");
     const preCreateCheck = {
       kind: "SelectQueryNode",
+      from: FromNode2.create([
+        AliasNode3.create(constTable, IdentifierNode2.create(model))
+      ]),
       selections: [
-        SelectionNode2.create(AliasNode3.create(filter, IdentifierNode2.create("$condition")))
-      ]
+        SelectionNode2.create(AliasNode3.create(BinaryOperationNode3.create(FunctionNode3.create("COUNT", [
+          ValueNode3.createImmediate(1)
+        ]), OperatorNode3.create(">"), ValueNode3.createImmediate(0)), IdentifierNode2.create("$condition")))
+      ],
+      where: WhereNode2.create(filter)
     };
     const result = await proceed(preCreateCheck);
     if (!result.rows[0]?.$condition) {
@@ -2563,13 +2649,13 @@ var PolicyHandler = class extends OperationNodeTransformer {
   isMutationQueryNode(node) {
     return InsertQueryNode.is(node) || UpdateQueryNode.is(node) || DeleteQueryNode.is(node);
   }
-  buildPolicyFilter(model, alias, operation, thisEntity, thisEntityRaw) {
+  buildPolicyFilter(model, alias, operation) {
     const policies = this.getModelPolicies(model, operation);
     if (policies.length === 0) {
       return falseNode(this.dialect);
     }
-    const allows = policies.filter((policy) => policy.kind === "allow").map((policy) => this.transformPolicyCondition(model, alias, operation, policy, thisEntity, thisEntityRaw));
-    const denies = policies.filter((policy) => policy.kind === "deny").map((policy) => this.transformPolicyCondition(model, alias, operation, policy, thisEntity, thisEntityRaw));
+    const allows = policies.filter((policy) => policy.kind === "allow").map((policy) => this.transformPolicyCondition(model, alias, operation, policy));
+    const denies = policies.filter((policy) => policy.kind === "deny").map((policy) => this.transformPolicyCondition(model, alias, operation, policy));
     let combinedPolicy;
     if (allows.length === 0) {
       combinedPolicy = falseNode(this.dialect);
@@ -2665,13 +2751,11 @@ var PolicyHandler = class extends OperationNodeTransformer {
       return void 0;
     }
   }
-  transformPolicyCondition(model, alias, operation, policy, thisEntity, thisEntityRaw) {
+  transformPolicyCondition(model, alias, operation, policy) {
     return new ExpressionTransformer(this.client.$schema, this.client.$options, this.client.$auth).transform(policy.condition, {
       model,
       alias,
       operation,
-      thisEntity,
-      thisEntityRaw,
       auth: this.client.$auth
     });
   }
@@ -2878,7 +2962,7 @@ var BaseOperationHandler = class {
       throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
     }
     let createFields = {};
-    let parentUpdateTask = void 0;
+    let updateParent = void 0;
     let m2m = void 0;
     if (fromRelation) {
       m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
@@ -2888,16 +2972,11 @@ var BaseOperationHandler = class {
           const parentFkFields = this.buildFkAssignments(fromRelation.model, fromRelation.field, fromRelation.ids);
           Object.assign(createFields, parentFkFields);
         } else {
-          parentUpdateTask = /* @__PURE__ */ __name((entity) => {
-            const query2 = kysely.updateTable(fromRelation.model).set(keyPairs.reduce((acc, { fk, pk }) => ({
-              ...acc,
-              [fk]: entity[pk]
-            }), {})).where((eb) => eb.and(fromRelation.ids)).modifyEnd(this.makeContextComment({
-              model: fromRelation.model,
-              operation: "update"
-            }));
-            return this.executeQuery(kysely, query2, "update");
-          }, "parentUpdateTask");
+          updateParent = /* @__PURE__ */ __name((entity) => {
+            for (const { fk, pk } of keyPairs) {
+              fromRelation.parentUpdates[fk] = entity[pk];
+            }
+          }, "updateParent");
         }
       }
     }
@@ -2929,7 +3008,7 @@ var BaseOperationHandler = class {
       const baseCreateResult = await this.processBaseModelCreate(kysely, modelDef.baseModel, createFields, model);
       createFields = baseCreateResult.remainingFields;
     }
-    const updatedData = this.fillGeneratedValues(modelDef, createFields);
+    const updatedData = this.fillGeneratedAndDefaultValues(modelDef, createFields);
     const idFields = getIdFields(this.schema, model);
     const query = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.defaultValues()).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).returning(idFields).modifyEnd(this.makeContextComment({
       model,
@@ -2945,8 +3024,8 @@ var BaseOperationHandler = class {
     if (fromRelation && m2m) {
       await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, createdEntity, m2m.joinTable);
     }
-    if (parentUpdateTask) {
-      await parentUpdateTask(createdEntity);
+    if (updateParent) {
+      updateParent(createdEntity);
     }
     return createdEntity;
   }
@@ -3060,7 +3139,7 @@ var BaseOperationHandler = class {
               select: fieldsToSelectObject(referencedPkFields)
             });
             if (!relationEntity) {
-              throw new NotFoundError(`Could not find the entity for connect action`);
+              throw new NotFoundError(relationModel, `Could not find the entity to connect for the relation "${relationField.name}"`);
             }
             result = relationEntity;
           }
@@ -3089,7 +3168,8 @@ var BaseOperationHandler = class {
     const fromRelationContext = {
       model: contextModel,
       field: relationFieldName,
-      ids: parentEntity
+      ids: parentEntity,
+      parentUpdates: {}
     };
     for (const [action, subPayload] of Object.entries(payload)) {
       if (!subPayload) {
@@ -3106,23 +3186,11 @@ var BaseOperationHandler = class {
           break;
         }
         case "connect": {
-          tasks.push(this.connectRelation(kysely, relationModel, subPayload, {
-            model: contextModel,
-            field: relationFieldName,
-            ids: parentEntity
-          }));
+          tasks.push(this.connectRelation(kysely, relationModel, subPayload, fromRelationContext));
           break;
         }
         case "connectOrCreate": {
-          tasks.push(...enumerate(subPayload).map((item) => this.exists(kysely, relationModel, item.where).then((found) => !found ? this.create(kysely, relationModel, item.create, {
-            model: contextModel,
-            field: relationFieldName,
-            ids: parentEntity
-          }) : this.connectRelation(kysely, relationModel, found, {
-            model: contextModel,
-            field: relationFieldName,
-            ids: parentEntity
-          }))));
+          tasks.push(...enumerate(subPayload).map((item) => this.exists(kysely, relationModel, item.where).then((found) => !found ? this.create(kysely, relationModel, item.create, fromRelationContext) : this.connectRelation(kysely, relationModel, found, fromRelationContext))));
           break;
         }
         default:
@@ -3158,7 +3226,7 @@ var BaseOperationHandler = class {
           newItem[fk] = fromRelation.ids[pk];
         }
       }
-      return this.fillGeneratedValues(modelDef, newItem);
+      return this.fillGeneratedAndDefaultValues(modelDef, newItem);
     });
     if (!this.dialect.supportInsertWithDefault) {
       const allPassedFields = createData.reduce((acc, item) => {
@@ -3238,7 +3306,7 @@ var BaseOperationHandler = class {
       remainingFieldRows
     };
   }
-  fillGeneratedValues(modelDef, data) {
+  fillGeneratedAndDefaultValues(modelDef, data) {
     const fields = modelDef.fields;
     const values = clone(data);
     for (const [field, fieldDef] of Object.entries(fields)) {
@@ -3253,6 +3321,16 @@ var BaseOperationHandler = class {
           }
         } else if (fields[field]?.updatedAt) {
           values[field] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
+        } else if (fields[field]?.default !== void 0) {
+          let value = fields[field].default;
+          if (fieldDef.type === "Json") {
+            if (fieldDef.array && Array.isArray(value)) {
+              value = value.map((v) => typeof v === "string" ? JSON.parse(v) : v);
+            } else if (typeof value === "string") {
+              value = JSON.parse(value);
+            }
+          }
+          values[field] = this.dialect.transformPrimitive(value, fields[field].type, !!fields[field].array);
         }
       }
     }
@@ -3365,7 +3443,10 @@ var BaseOperationHandler = class {
             }
           }
         }
-        await this.processRelationUpdates(kysely, model, field, fieldDef, thisEntity, finalData[field], throwIfNotFound);
+        const parentUpdates = await this.processRelationUpdates(kysely, model, field, fieldDef, thisEntity, finalData[field], throwIfNotFound);
+        if (Object.keys(parentUpdates).length > 0) {
+          Object.assign(updateFields, parentUpdates);
+        }
       }
     }
     if (Object.keys(updateFields).length === 0) {
@@ -3553,7 +3634,8 @@ var BaseOperationHandler = class {
     const fromRelationContext = {
       model,
       field,
-      ids: parentIds
+      ids: parentIds,
+      parentUpdates: {}
     };
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
@@ -3628,6 +3710,7 @@ var BaseOperationHandler = class {
       }
     }
     await Promise.all(tasks);
+    return fromRelationContext.parentUpdates;
   }
   // #region relation manipulation
   async connectRelation(kysely, model, data, fromRelation) {
@@ -3647,7 +3730,6 @@ var BaseOperationHandler = class {
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
-      let updateResult;
       if (ownedByModel) {
         invariant7(_data.length === 1, "only one entity can be connected");
         const target = await this.readUnique(kysely, model, {
@@ -3656,14 +3738,9 @@ var BaseOperationHandler = class {
         if (!target) {
           throw new NotFoundError(model);
         }
-        const query = kysely.updateTable(fromRelation.model).where((eb) => eb.and(fromRelation.ids)).set(keyPairs.reduce((acc, { fk, pk }) => ({
-          ...acc,
-          [fk]: target[pk]
-        }), {})).modifyEnd(this.makeContextComment({
-          model: fromRelation.model,
-          operation: "update"
-        }));
-        updateResult = await this.executeQuery(kysely, query, "connect");
+        for (const { fk, pk } of keyPairs) {
+          fromRelation.parentUpdates[fk] = target[pk];
+        }
       } else {
         const relationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
         if (!relationFieldDef.array) {
@@ -3683,10 +3760,10 @@ var BaseOperationHandler = class {
           model,
           operation: "update"
         }));
-        updateResult = await this.executeQuery(kysely, query, "connect");
-      }
-      if (_data.length > updateResult.numAffectedRows) {
-        throw new NotFoundError(model);
+        const updateResult = await this.executeQuery(kysely, query, "connect");
+        if (!updateResult.numAffectedRows || _data.length > updateResult.numAffectedRows) {
+          throw new NotFoundError(model);
+        }
       }
     }
   }
@@ -3741,19 +3818,38 @@ var BaseOperationHandler = class {
       if (ownedByModel) {
         invariant7(disconnectConditions.length === 1, "only one entity can be disconnected");
         const condition = disconnectConditions[0];
-        const query = kysely.updateTable(fromRelation.model).where(eb.and(fromRelation.ids)).$if(condition !== true, (qb) => qb.where(eb(
-          // @ts-ignore
-          eb.refTuple(...keyPairs.map(({ fk }) => fk)),
-          "in",
-          eb.selectFrom(model).select(keyPairs.map(({ pk }) => pk)).where(this.dialect.buildFilter(eb, model, model, condition))
-        ))).set(keyPairs.reduce((acc, { fk }) => ({
-          ...acc,
-          [fk]: null
-        }), {})).modifyEnd(this.makeContextComment({
-          model: fromRelation.model,
-          operation: "update"
-        }));
-        await this.executeQuery(kysely, query, "disconnect");
+        if (condition === true) {
+          for (const { fk } of keyPairs) {
+            fromRelation.parentUpdates[fk] = null;
+          }
+        } else {
+          const fromEntity = await this.readUnique(kysely, fromRelation.model, {
+            where: fromRelation.ids,
+            select: fieldsToSelectObject(keyPairs.map(({ fk }) => fk))
+          });
+          if (!fromEntity || keyPairs.some(({ fk }) => fromEntity[fk] == null)) {
+            return;
+          }
+          const relationFilter = {
+            AND: [
+              condition,
+              Object.fromEntries(keyPairs.map(({ fk, pk }) => [
+                pk,
+                fromEntity[fk]
+              ]))
+            ]
+          };
+          const targetExists = await this.read(kysely, model, {
+            where: relationFilter,
+            take: 1,
+            select: this.makeIdSelect(model)
+          });
+          if (targetExists.length > 0) {
+            for (const { fk } of keyPairs) {
+              fromRelation.parentUpdates[fk] = null;
+            }
+          }
+        }
       } else {
         const query = kysely.updateTable(model).where(eb.and([
           // fk filter
@@ -3818,7 +3914,7 @@ var BaseOperationHandler = class {
           operation: "update"
         }));
         const r = await this.executeQuery(kysely, query2, "connect");
-        if (_data.length > r.numAffectedRows) {
+        if (!r.numAffectedRows || _data.length > r.numAffectedRows) {
           throw new NotFoundError(model);
         }
       }
@@ -3844,8 +3940,10 @@ var BaseOperationHandler = class {
       expectedDeleteCount = deleteConditions.length;
     }
     let deleteResult;
+    let deleteFromModel;
     const m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
     if (m2m) {
+      deleteFromModel = model;
       const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
       invariant7(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
@@ -3863,11 +3961,12 @@ var BaseOperationHandler = class {
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
+        deleteFromModel = fromRelation.model;
         const fromEntity = await this.readUnique(kysely, fromRelation.model, {
           where: fromRelation.ids
         });
         if (!fromEntity) {
-          throw new NotFoundError(model);
+          throw new NotFoundError(fromRelation.model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
         invariant7(fieldDef.relation?.opposite);
@@ -3884,6 +3983,7 @@ var BaseOperationHandler = class {
           ]
         });
       } else {
+        deleteFromModel = model;
         deleteResult = await this.delete(kysely, model, {
           AND: [
             Object.fromEntries(keyPairs.map(({ fk, pk }) => [
@@ -3898,7 +3998,7 @@ var BaseOperationHandler = class {
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
-      throw new NotFoundError(model);
+      throw new NotFoundError(deleteFromModel);
     }
   }
   normalizeRelationManipulationInput(model, data) {
@@ -4640,10 +4740,7 @@ var InputValidator = class {
     return schema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
-    const modelDef = getModel(this.schema, model);
-    if (!modelDef) {
-      throw new QueryError(`Model "${model}" not found in schema`);
-    }
+    const modelDef = requireModel(this.schema, model);
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
@@ -5689,18 +5786,16 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-import { invariant as invariant11 } from "@zenstackhq/common-helpers";
+import { invariant as invariant10 } from "@zenstackhq/common-helpers";
 import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode2, SelectionNode as SelectionNode4, SingleConnectionProvider, TableNode as TableNode5, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
 import { match as match16 } from "ts-pattern";
 
 // src/client/executor/kysely-utils.ts
-import { invariant as invariant9 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode4, IdentifierNode as IdentifierNode3 } from "kysely";
+import { AliasNode as AliasNode4 } from "kysely";
 function stripAlias(node) {
   if (AliasNode4.is(node)) {
-    invariant9(IdentifierNode3.is(node.alias), "Expected identifier as alias");
     return {
-      alias: node.alias.name,
+      alias: node.alias,
       node: node.node
     };
   } else {
@@ -5713,8 +5808,8 @@ function stripAlias(node) {
 __name(stripAlias, "stripAlias");
 
 // src/client/executor/name-mapper.ts
-import { invariant as invariant10 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode5, ColumnNode as ColumnNode3, FromNode as FromNode3, IdentifierNode as IdentifierNode4, OperationNodeTransformer as OperationNodeTransformer2, ReferenceNode as ReferenceNode3, SelectAllNode, SelectionNode as SelectionNode3, TableNode as TableNode4 } from "kysely";
+import { invariant as invariant9 } from "@zenstackhq/common-helpers";
+import { AliasNode as AliasNode5, ColumnNode as ColumnNode3, FromNode as FromNode3, IdentifierNode as IdentifierNode3, OperationNodeTransformer as OperationNodeTransformer2, ReferenceNode as ReferenceNode3, SelectAllNode, SelectionNode as SelectionNode3, TableNode as TableNode4 } from "kysely";
 var QueryNameMapper = class extends OperationNodeTransformer2 {
   static {
     __name(this, "QueryNameMapper");
@@ -5791,7 +5886,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
       const mappedFieldName = this.mapFieldName(scope.model, node.column.column.name);
       let mappedTableName = node.table?.table.identifier.name;
       if (mappedTableName) {
-        if (scope.alias === mappedTableName) {
+        if (scope.alias && IdentifierNode3.is(scope.alias) && scope.alias.name === mappedTableName) {
         } else if (scope.model === mappedTableName) {
           mappedTableName = this.mapTableName(scope.model);
         }
@@ -5872,7 +5967,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
           const origFieldName = this.extractFieldName(selection.selection);
           const fieldName = this.extractFieldName(transformed);
           if (fieldName !== origFieldName) {
-            selections.push(SelectionNode3.create(this.wrapAlias(transformed, origFieldName)));
+            selections.push(SelectionNode3.create(this.wrapAlias(transformed, origFieldName ? IdentifierNode3.create(origFieldName) : void 0)));
           } else {
             selections.push(SelectionNode3.create(transformed));
           }
@@ -5888,7 +5983,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
       const scope = this.scopes[i];
       if (qualifier) {
         if (scope.alias) {
-          if (scope.alias === qualifier) {
+          if (scope.alias && IdentifierNode3.is(scope.alias) && scope.alias.name === qualifier) {
             return scope;
           } else {
             continue;
@@ -5934,7 +6029,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     }
   }
   wrapAlias(node, alias) {
-    return alias ? AliasNode5.create(node, IdentifierNode4.create(alias)) : node;
+    return alias ? AliasNode5.create(node, alias) : node;
   }
   processTableRef(node) {
     if (!node) {
@@ -5982,11 +6077,11 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     if (innerNode && TableNode4.is(innerNode)) {
       const modelName = innerNode.table.identifier.name;
       const mappedName = this.mapTableName(modelName);
-      const finalAlias = alias ?? (mappedName !== modelName ? modelName : void 0);
+      const finalAlias = alias ?? (mappedName !== modelName ? IdentifierNode3.create(modelName) : void 0);
       return {
         node: this.wrapAlias(TableNode4.create(mappedName), finalAlias),
         scope: {
-          alias: alias ?? modelName,
+          alias: alias ?? IdentifierNode3.create(modelName),
           model: modelName,
           namesMapped: !this.hasMappedColumns(modelName)
         }
@@ -6006,9 +6101,9 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     const modelDef = requireModel(this.schema, model);
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(model, fieldDef.name);
-      const columnRef = ReferenceNode3.create(ColumnNode3.create(columnName), alias ? TableNode4.create(alias) : void 0);
+      const columnRef = ReferenceNode3.create(ColumnNode3.create(columnName), alias && IdentifierNode3.is(alias) ? TableNode4.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
-        const aliased = AliasNode5.create(columnRef, IdentifierNode4.create(fieldDef.name));
+        const aliased = AliasNode5.create(columnRef, IdentifierNode3.create(fieldDef.name));
         return SelectionNode3.create(aliased);
       } else {
         return SelectionNode3.create(columnRef);
@@ -6040,11 +6135,11 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
       alias = this.extractFieldName(node);
     }
     const result = super.transformNode(node);
-    return this.wrapAlias(result, alias);
+    return this.wrapAlias(result, alias ? IdentifierNode3.create(alias) : void 0);
   }
   processSelectAll(node) {
     const scope = this.scopes[this.scopes.length - 1];
-    invariant10(scope);
+    invariant9(scope);
     if (!scope.model || !this.hasMappedColumns(scope.model)) {
       return super.transformSelectAll(node);
     }
@@ -6052,7 +6147,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
       const columnRef = ReferenceNode3.create(ColumnNode3.create(columnName));
-      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, fieldDef.name) : columnRef;
+      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, IdentifierNode3.create(fieldDef.name)) : columnRef;
     });
   }
   extractModelName(node) {
@@ -6114,7 +6209,6 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
         const hookResult = await hook({
           client: this.client,
           schema: this.client.$schema,
-          kysely: this.kysely,
           query,
           proceed: _p
         });
@@ -6273,17 +6367,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   }
   getMutationModel(queryNode) {
     return match16(queryNode).when(InsertQueryNode2.is, (node) => {
-      invariant11(node.into, "InsertQueryNode must have an into clause");
+      invariant10(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(UpdateQueryNode2.is, (node) => {
-      invariant11(node.table, "UpdateQueryNode must have a table");
+      invariant10(node.table, "UpdateQueryNode must have a table");
       const { node: tableNode } = stripAlias(node.table);
-      invariant11(TableNode5.is(tableNode), "UpdateQueryNode must use a TableNode");
+      invariant10(TableNode5.is(tableNode), "UpdateQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).when(DeleteQueryNode2.is, (node) => {
-      invariant11(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      invariant10(node.from.froms.length === 1, "Delete query must have exactly one from table");
       const { node: tableNode } = stripAlias(node.from.froms[0]);
-      invariant11(TableNode5.is(tableNode), "DeleteQueryNode must use a TableNode");
+      invariant10(TableNode5.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw new InternalError(`Invalid query node: ${node}`);
@@ -6381,7 +6475,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-import { invariant as invariant12, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
+import { invariant as invariant11, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { sql as sql7, ValueNode as ValueNode4 } from "kysely";
 import { match as match17 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args) => {
@@ -6488,7 +6582,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  invariant12(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  invariant11(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
   result = match17(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
@@ -6497,7 +6591,7 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-import { invariant as invariant13 } from "@zenstackhq/common-helpers";
+import { invariant as invariant12 } from "@zenstackhq/common-helpers";
 import { sql as sql8 } from "kysely";
 import toposort from "toposort";
 import { match as match18 } from "ts-pattern";
@@ -6613,7 +6707,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      invariant13(typeof value === "object", "expecting an object");
+      invariant12(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -6681,7 +6775,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    invariant13(fieldDef.relation, "field must be a relation");
+    invariant12(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -6738,7 +6832,7 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
-import { invariant as invariant14 } from "@zenstackhq/common-helpers";
+import { invariant as invariant13 } from "@zenstackhq/common-helpers";
 import Decimal2 from "decimal.js";
 import { match as match19 } from "ts-pattern";
 var ResultProcessor = class {
@@ -6838,14 +6932,14 @@ var ResultProcessor = class {
     if (value instanceof Decimal2) {
       return value;
     }
-    invariant14(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
+    invariant13(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
     return new Decimal2(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    invariant14(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    invariant13(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -6889,7 +6983,7 @@ var ResultProcessor = class {
   }
   transformJson(value) {
     return match19(this.schema.provider.type).with("sqlite", () => {
-      invariant14(typeof value === "string", "Expected string, got " + typeof value);
+      invariant13(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
   }
@@ -6966,7 +7060,7 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    invariant15(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    invariant14(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
     if (typeof input === "function") {
       return this.interactiveTransaction(input, options);
     } else {