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

package/dist/index.cjs

@@ -42,7 +42,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers16 = require("@zenstackhq/common-helpers");
+var import_common_helpers15 = require("@zenstackhq/common-helpers");
 var import_kysely17 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
@@ -117,6 +117,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"),
@@ -177,22 +180,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) {
@@ -200,12 +207,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];
+    }
+  }
+  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];
+    }
   }
-  return modelDef.fields[field];
+  throw new QueryError(`Model or type "${modelOrType}" not found in schema`);
 }
 __name(requireField, "requireField");
 function getIdFields(schema, model) {
@@ -533,7 +552,7 @@ var AGGREGATE_OPERATORS = [
   "_max"
 ];
 
-// src/client/crud/dialects/base.ts
+// src/client/crud/dialects/base-dialect.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_kysely = require("kysely");
 var import_ts_pattern2 = require("ts-pattern");
@@ -552,7 +571,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");
@@ -1926,6 +1945,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);
   }
@@ -1933,10 +1958,16 @@ function conjunction(dialect, nodes) {
   if (items.length === 0) {
     return trueNode(dialect);
   }
-  return items.reduce((acc, node) => import_kysely5.OrNode.is(node) ? import_kysely5.AndNode.create(acc, import_kysely5.ParensNode.create(node)) : import_kysely5.AndNode.create(acc, node));
+  return items.reduce((acc, node) => import_kysely5.AndNode.create(wrapParensIf(acc, import_kysely5.OrNode.is), wrapParensIf(node, import_kysely5.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);
   }
@@ -1944,13 +1975,23 @@ function disjunction(dialect, nodes) {
   if (items.length === 0) {
     return falseNode(dialect);
   }
-  return items.reduce((acc, node) => import_kysely5.AndNode.is(node) ? import_kysely5.OrNode.create(acc, import_kysely5.ParensNode.create(node)) : import_kysely5.OrNode.create(acc, node));
+  return items.reduce((acc, node) => import_kysely5.OrNode.create(wrapParensIf(acc, import_kysely5.AndNode.is), wrapParensIf(node, import_kysely5.AndNode.is)));
 }
 __name(disjunction, "disjunction");
-function logicalNot(node) {
-  return import_kysely5.UnaryOperationNode.create(import_kysely5.OperatorNode.create("not"), import_kysely5.AndNode.is(node) || import_kysely5.OrNode.is(node) ? import_kysely5.ParensNode.create(node) : node);
+function logicalNot(dialect, node) {
+  if (isTrueNode(node)) {
+    return falseNode(dialect);
+  }
+  if (isFalseNode(node)) {
+    return trueNode(dialect);
+  }
+  return import_kysely5.UnaryOperationNode.create(import_kysely5.OperatorNode.create("not"), wrapParensIf(node, (n) => import_kysely5.AndNode.is(n) || import_kysely5.OrNode.is(n)));
 }
 __name(logicalNot, "logicalNot");
+function wrapParensIf(node, predicate) {
+  return predicate(node) ? import_kysely5.ParensNode.create(node) : node;
+}
+__name(wrapParensIf, "wrapParensIf");
 function buildIsFalse(node, dialect) {
   if (isFalseNode(node)) {
     return trueNode(dialect);
@@ -2041,11 +2082,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);
@@ -2086,7 +2123,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 === "^") {
@@ -2139,11 +2176,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 = import_kysely6.FunctionNode.create("count", [
       import_kysely6.ValueNode.createImmediate(1)
@@ -2155,20 +2191,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);
+      (0, import_common_helpers5.invariant)(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) {
@@ -2176,7 +2230,7 @@ var ExpressionTransformer = class {
   }
   _unary(expr2, context) {
     (0, import_common_helpers5.invariant)(expr2.op === "!", 'only "!" operator is supported');
-    return import_kysely6.BinaryOperationNode.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
+    return logicalNot(this.dialect, this.transform(expr2.operand, context));
   }
   transformOperator(op) {
     const mappedOp = (0, import_ts_pattern7.match)(op).with("==", () => "=").otherwise(() => op);
@@ -2203,7 +2257,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);
@@ -2218,14 +2272,33 @@ var ExpressionTransformer = class {
     if (this.isAuthCall(expr2.receiver)) {
       return this.valueMemberAccess(this.auth, expr2, this.authType);
     }
-    (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.receiver), "expect receiver to be field expression");
+    (0, import_common_helpers5.invariant)(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]);
+        (0, import_common_helpers5.invariant)(!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);
+    }
     (0, import_common_helpers5.invariant)(import_kysely6.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,
@@ -2234,22 +2307,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) {
           (0, import_common_helpers5.invariant)(import_kysely6.SelectQueryNode.is(currNode), "expected select query node");
           currNode = {
             ...relation,
             selections: [
-              import_kysely6.SelectionNode.create(import_kysely6.AliasNode.create(currNode, import_kysely6.IdentifierNode.create(expr2.members[i + 1])))
+              import_kysely6.SelectionNode.create(import_kysely6.AliasNode.create(currNode, import_kysely6.IdentifierNode.create(members[i + 1])))
             ]
           };
         } else {
@@ -2262,7 +2334,7 @@ var ExpressionTransformer = class {
           };
         }
       } else {
-        (0, import_common_helpers5.invariant)(i === expr2.members.length - 1, "plain field access must be the last segment");
+        (0, import_common_helpers5.invariant)(i === members.length - 1, "plain field access must be the last segment");
         (0, import_common_helpers5.invariant)(!currNode, "plain field access must be the last segment");
         currNode = import_kysely6.ColumnNode.create(member);
       }
@@ -2289,35 +2361,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 }) => import_kysely6.BinaryOperationNode.create(import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(pk), import_kysely6.TableNode.create(relationModel)), import_kysely6.OperatorNode.create("="), context.thisEntity[fk])));
-      } else {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => import_kysely6.BinaryOperationNode.create(import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(fk), import_kysely6.TableNode.create(relationModel)), import_kysely6.OperatorNode.create("="), context.thisEntity[pk])));
-      }
-      return {
-        kind: "SelectQueryNode",
-        from: import_kysely6.FromNode.create([
-          import_kysely6.TableNode.create(relationModel)
-        ]),
-        where: import_kysely6.WhereNode.create(condition)
-      };
+    let condition;
+    if (ownedByModel) {
+      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => import_kysely6.BinaryOperationNode.create(import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(fk), import_kysely6.TableNode.create(context.alias ?? fromModel)), import_kysely6.OperatorNode.create("="), import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(pk), import_kysely6.TableNode.create(relationModel)))));
     } else {
-      let condition;
-      if (ownedByModel) {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => import_kysely6.BinaryOperationNode.create(import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(fk), import_kysely6.TableNode.create(context.alias ?? fromModel)), import_kysely6.OperatorNode.create("="), import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(pk), import_kysely6.TableNode.create(relationModel)))));
-      } else {
-        condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => import_kysely6.BinaryOperationNode.create(import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(pk), import_kysely6.TableNode.create(context.alias ?? fromModel)), import_kysely6.OperatorNode.create("="), import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(fk), import_kysely6.TableNode.create(relationModel)))));
-      }
-      return {
-        kind: "SelectQueryNode",
-        from: import_kysely6.FromNode.create([
-          import_kysely6.TableNode.create(relationModel)
-        ]),
-        where: import_kysely6.WhereNode.create(condition)
-      };
+      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => import_kysely6.BinaryOperationNode.create(import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(pk), import_kysely6.TableNode.create(context.alias ?? fromModel)), import_kysely6.OperatorNode.create("="), import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(fk), import_kysely6.TableNode.create(relationModel)))));
     }
+    return {
+      kind: "SelectQueryNode",
+      from: import_kysely6.FromNode.create([
+        import_kysely6.TableNode.create(relationModel)
+      ]),
+      where: import_kysely6.WhereNode.create(condition)
+    };
   }
   createColumnRef(column, context) {
     return import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(column), import_kysely6.TableNode.create(context.alias ?? context.model));
@@ -2331,6 +2387,18 @@ var ExpressionTransformer = class {
   isNullNode(node) {
     return import_kysely6.ValueNode.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"),
@@ -2460,29 +2528,47 @@ var PolicyHandler = class extends import_kysely7.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(import_kysely7.ValueNode.createImmediate(null));
+      }
     }
-    const filter = this.buildPolicyFilter(model, void 0, "create", thisEntity, thisEntityRaw);
+    const constTable = {
+      kind: "SelectQueryNode",
+      from: import_kysely7.FromNode.create([
+        import_kysely7.AliasNode.create(import_kysely7.ParensNode.create(import_kysely7.ValuesNode.create([
+          import_kysely7.ValueListNode.create(allValues)
+        ])), import_kysely7.IdentifierNode.create("$t"))
+      ]),
+      selections: allFields.map((field, index) => import_kysely7.SelectionNode.create(import_kysely7.AliasNode.create(import_kysely7.ColumnNode.create(`column${index + 1}`), import_kysely7.IdentifierNode.create(field))))
+    };
+    const filter = this.buildPolicyFilter(model, void 0, "create");
     const preCreateCheck = {
       kind: "SelectQueryNode",
+      from: import_kysely7.FromNode.create([
+        import_kysely7.AliasNode.create(constTable, import_kysely7.IdentifierNode.create(model))
+      ]),
       selections: [
-        import_kysely7.SelectionNode.create(import_kysely7.AliasNode.create(filter, import_kysely7.IdentifierNode.create("$condition")))
-      ]
+        import_kysely7.SelectionNode.create(import_kysely7.AliasNode.create(import_kysely7.BinaryOperationNode.create(import_kysely7.FunctionNode.create("COUNT", [
+          import_kysely7.ValueNode.createImmediate(1)
+        ]), import_kysely7.OperatorNode.create(">"), import_kysely7.ValueNode.createImmediate(0)), import_kysely7.IdentifierNode.create("$condition")))
+      ],
+      where: import_kysely7.WhereNode.create(filter)
     };
     const result = await proceed(preCreateCheck);
     if (!result.rows[0]?.$condition) {
@@ -2599,13 +2685,13 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
   isMutationQueryNode(node) {
     return import_kysely7.InsertQueryNode.is(node) || import_kysely7.UpdateQueryNode.is(node) || import_kysely7.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);
@@ -2701,13 +2787,11 @@ var PolicyHandler = class extends import_kysely7.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
     });
   }
@@ -2914,7 +2998,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);
@@ -2924,16 +3008,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");
         }
       }
     }
@@ -2965,7 +3044,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,
@@ -2981,8 +3060,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;
   }
@@ -3096,7 +3175,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;
           }
@@ -3125,7 +3204,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) {
@@ -3142,23 +3222,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:
@@ -3194,7 +3262,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) => {
@@ -3274,7 +3342,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)) {
@@ -3289,6 +3357,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);
         }
       }
     }
@@ -3401,7 +3479,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) {
@@ -3589,7 +3670,8 @@ var BaseOperationHandler = class {
     const fromRelationContext = {
       model,
       field,
-      ids: parentIds
+      ids: parentIds,
+      parentUpdates: {}
     };
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
@@ -3664,6 +3746,7 @@ var BaseOperationHandler = class {
       }
     }
     await Promise.all(tasks);
+    return fromRelationContext.parentUpdates;
   }
   // #region relation manipulation
   async connectRelation(kysely, model, data, fromRelation) {
@@ -3683,7 +3766,6 @@ var BaseOperationHandler = class {
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
-      let updateResult;
       if (ownedByModel) {
         (0, import_common_helpers8.invariant)(_data.length === 1, "only one entity can be connected");
         const target = await this.readUnique(kysely, model, {
@@ -3692,14 +3774,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) {
@@ -3719,10 +3796,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);
+        }
       }
     }
   }
@@ -3777,19 +3854,38 @@ var BaseOperationHandler = class {
       if (ownedByModel) {
         (0, import_common_helpers8.invariant)(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
@@ -3854,7 +3950,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);
         }
       }
@@ -3880,8 +3976,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);
       (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
@@ -3899,11 +3997,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);
         (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
@@ -3920,6 +4019,7 @@ var BaseOperationHandler = class {
           ]
         });
       } else {
+        deleteFromModel = model;
         deleteResult = await this.delete(kysely, model, {
           AND: [
             Object.fromEntries(keyPairs.map(({ fk, pk }) => [
@@ -3934,7 +4034,7 @@ var BaseOperationHandler = class {
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
-      throw new NotFoundError(model);
+      throw new NotFoundError(deleteFromModel);
     }
   }
   normalizeRelationManipulationInput(model, data) {
@@ -4676,10 +4776,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);
@@ -5725,18 +5822,16 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely14 = require("kysely");
 var import_ts_pattern16 = require("ts-pattern");
 
 // src/client/executor/kysely-utils.ts
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely12 = require("kysely");
 function stripAlias(node) {
   if (import_kysely12.AliasNode.is(node)) {
-    (0, import_common_helpers10.invariant)(import_kysely12.IdentifierNode.is(node.alias), "Expected identifier as alias");
     return {
-      alias: node.alias.name,
+      alias: node.alias,
       node: node.node
     };
   } else {
@@ -5749,7 +5844,7 @@ function stripAlias(node) {
 __name(stripAlias, "stripAlias");
 
 // src/client/executor/name-mapper.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely13 = require("kysely");
 var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
   static {
@@ -5827,7 +5922,7 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
       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 && import_kysely13.IdentifierNode.is(scope.alias) && scope.alias.name === mappedTableName) {
         } else if (scope.model === mappedTableName) {
           mappedTableName = this.mapTableName(scope.model);
         }
@@ -5908,7 +6003,7 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
           const origFieldName = this.extractFieldName(selection.selection);
           const fieldName = this.extractFieldName(transformed);
           if (fieldName !== origFieldName) {
-            selections.push(import_kysely13.SelectionNode.create(this.wrapAlias(transformed, origFieldName)));
+            selections.push(import_kysely13.SelectionNode.create(this.wrapAlias(transformed, origFieldName ? import_kysely13.IdentifierNode.create(origFieldName) : void 0)));
           } else {
             selections.push(import_kysely13.SelectionNode.create(transformed));
           }
@@ -5924,7 +6019,7 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
       const scope = this.scopes[i];
       if (qualifier) {
         if (scope.alias) {
-          if (scope.alias === qualifier) {
+          if (scope.alias && import_kysely13.IdentifierNode.is(scope.alias) && scope.alias.name === qualifier) {
             return scope;
           } else {
             continue;
@@ -5970,7 +6065,7 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
     }
   }
   wrapAlias(node, alias) {
-    return alias ? import_kysely13.AliasNode.create(node, import_kysely13.IdentifierNode.create(alias)) : node;
+    return alias ? import_kysely13.AliasNode.create(node, alias) : node;
   }
   processTableRef(node) {
     if (!node) {
@@ -6018,11 +6113,11 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
     if (innerNode && import_kysely13.TableNode.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 ? import_kysely13.IdentifierNode.create(modelName) : void 0);
       return {
         node: this.wrapAlias(import_kysely13.TableNode.create(mappedName), finalAlias),
         scope: {
-          alias: alias ?? modelName,
+          alias: alias ?? import_kysely13.IdentifierNode.create(modelName),
           model: modelName,
           namesMapped: !this.hasMappedColumns(modelName)
         }
@@ -6042,7 +6137,7 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
     const modelDef = requireModel(this.schema, model);
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(model, fieldDef.name);
-      const columnRef = import_kysely13.ReferenceNode.create(import_kysely13.ColumnNode.create(columnName), alias ? import_kysely13.TableNode.create(alias) : void 0);
+      const columnRef = import_kysely13.ReferenceNode.create(import_kysely13.ColumnNode.create(columnName), alias && import_kysely13.IdentifierNode.is(alias) ? import_kysely13.TableNode.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
         const aliased = import_kysely13.AliasNode.create(columnRef, import_kysely13.IdentifierNode.create(fieldDef.name));
         return import_kysely13.SelectionNode.create(aliased);
@@ -6076,11 +6171,11 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
       alias = this.extractFieldName(node);
     }
     const result = super.transformNode(node);
-    return this.wrapAlias(result, alias);
+    return this.wrapAlias(result, alias ? import_kysely13.IdentifierNode.create(alias) : void 0);
   }
   processSelectAll(node) {
     const scope = this.scopes[this.scopes.length - 1];
-    (0, import_common_helpers11.invariant)(scope);
+    (0, import_common_helpers10.invariant)(scope);
     if (!scope.model || !this.hasMappedColumns(scope.model)) {
       return super.transformSelectAll(node);
     }
@@ -6088,7 +6183,7 @@ var QueryNameMapper = class extends import_kysely13.OperationNodeTransformer {
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
       const columnRef = import_kysely13.ReferenceNode.create(import_kysely13.ColumnNode.create(columnName));
-      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, fieldDef.name) : columnRef;
+      return columnName !== fieldDef.name ? this.wrapAlias(columnRef, import_kysely13.IdentifierNode.create(fieldDef.name)) : columnRef;
     });
   }
   extractModelName(node) {
@@ -6150,7 +6245,6 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely14
         const hookResult = await hook({
           client: this.client,
           schema: this.client.$schema,
-          kysely: this.kysely,
           query,
           proceed: _p
         });
@@ -6309,17 +6403,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely14
   }
   getMutationModel(queryNode) {
     return (0, import_ts_pattern16.match)(queryNode).when(import_kysely14.InsertQueryNode.is, (node) => {
-      (0, import_common_helpers12.invariant)(node.into, "InsertQueryNode must have an into clause");
+      (0, import_common_helpers11.invariant)(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(import_kysely14.UpdateQueryNode.is, (node) => {
-      (0, import_common_helpers12.invariant)(node.table, "UpdateQueryNode must have a table");
+      (0, import_common_helpers11.invariant)(node.table, "UpdateQueryNode must have a table");
       const { node: tableNode } = stripAlias(node.table);
-      (0, import_common_helpers12.invariant)(import_kysely14.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
+      (0, import_common_helpers11.invariant)(import_kysely14.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).when(import_kysely14.DeleteQueryNode.is, (node) => {
-      (0, import_common_helpers12.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      (0, import_common_helpers11.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
       const { node: tableNode } = stripAlias(node.from.froms[0]);
-      (0, import_common_helpers12.invariant)(import_kysely14.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
+      (0, import_common_helpers11.invariant)(import_kysely14.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw new InternalError(`Invalid query node: ${node}`);
@@ -6417,7 +6511,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
 var import_ts_pattern17 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
@@ -6524,8 +6618,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers13.invariant)(import_kysely15.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers13.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers13.lowerCaseFirst)(result)).otherwise(() => {
+  (0, import_common_helpers12.invariant)(import_kysely15.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = (0, import_ts_pattern17.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers12.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers12.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -6533,7 +6627,7 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers14 = require("@zenstackhq/common-helpers");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely16 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern18 = require("ts-pattern");
@@ -6649,7 +6743,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers14.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers13.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -6717,7 +6811,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers14.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers13.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -6774,7 +6868,7 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
-var import_common_helpers15 = require("@zenstackhq/common-helpers");
+var import_common_helpers14 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern19 = require("ts-pattern");
 var ResultProcessor = class {
@@ -6874,14 +6968,14 @@ var ResultProcessor = class {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_common_helpers15.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers14.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers15.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers14.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -6925,7 +7019,7 @@ var ResultProcessor = class {
   }
   transformJson(value) {
     return (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => {
-      (0, import_common_helpers15.invariant)(typeof value === "string", "Expected string, got " + typeof value);
+      (0, import_common_helpers14.invariant)(typeof value === "string", "Expected string, got " + typeof value);
       return JSON.parse(value);
     }).otherwise(() => value);
   }
@@ -7002,7 +7096,7 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    (0, import_common_helpers16.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    (0, import_common_helpers15.invariant)(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 {