@zenstackhq/runtime 3.0.0-alpha.12 → 3.0.0-alpha.14

package/dist/index.js

@@ -14,6 +14,85 @@ import { match as match19 } from "ts-pattern";
 import { sql as sql5 } from "kysely";
 import { match as match9 } from "ts-pattern";
 
+// src/schema/expression.ts
+var ExpressionUtils = {
+  literal: /* @__PURE__ */ __name((value) => {
+    return {
+      kind: "literal",
+      value
+    };
+  }, "literal"),
+  array: /* @__PURE__ */ __name((items) => {
+    return {
+      kind: "array",
+      items
+    };
+  }, "array"),
+  call: /* @__PURE__ */ __name((functionName, args) => {
+    return {
+      kind: "call",
+      function: functionName,
+      args
+    };
+  }, "call"),
+  binary: /* @__PURE__ */ __name((left, op, right) => {
+    return {
+      kind: "binary",
+      op,
+      left,
+      right
+    };
+  }, "binary"),
+  unary: /* @__PURE__ */ __name((op, operand) => {
+    return {
+      kind: "unary",
+      op,
+      operand
+    };
+  }, "unary"),
+  field: /* @__PURE__ */ __name((field) => {
+    return {
+      kind: "field",
+      field
+    };
+  }, "field"),
+  member: /* @__PURE__ */ __name((receiver, members) => {
+    return {
+      kind: "member",
+      receiver,
+      members
+    };
+  }, "member"),
+  _this: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "this"
+    };
+  }, "_this"),
+  _null: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "null"
+    };
+  }, "_null"),
+  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
+  }, "and"),
+  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
+  }, "or"),
+  is: /* @__PURE__ */ __name((value, kind) => {
+    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
+  }, "is"),
+  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
+  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
+  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
+  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
+  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
+  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
+  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
+  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
+  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
+};
+
 // src/client/errors.ts
 var InputValidationError = class extends Error {
   static {
@@ -135,6 +214,11 @@ function isRelationField(schema, model, field) {
   return !!fieldDef.relation;
 }
 __name(isRelationField, "isRelationField");
+function isInheritedField(schema, model, field) {
+  const fieldDef = requireField(schema, model, field);
+  return !!fieldDef.originModel;
+}
+__name(isInheritedField, "isInheritedField");
 function getUniqueFields(schema, model) {
   const modelDef = requireModel(schema, model);
   const result = [];
@@ -287,6 +371,46 @@ function safeJSONStringify(value) {
   });
 }
 __name(safeJSONStringify, "safeJSONStringify");
+function extractFields(object, fields) {
+  return fields.reduce((acc, field) => {
+    if (field in object) {
+      acc[field] = object[field];
+    }
+    return acc;
+  }, {});
+}
+__name(extractFields, "extractFields");
+function extractIdFields(entity, schema, model) {
+  const idFields = getIdFields(schema, model);
+  return extractFields(entity, idFields);
+}
+__name(extractIdFields, "extractIdFields");
+function getDiscriminatorField(schema, model) {
+  const modelDef = requireModel(schema, model);
+  const delegateAttr = modelDef.attributes?.find((attr) => attr.name === "@@delegate");
+  if (!delegateAttr) {
+    return void 0;
+  }
+  const discriminator = delegateAttr.args?.find((arg) => arg.name === "discriminator");
+  if (!discriminator || !ExpressionUtils.isField(discriminator.value)) {
+    throw new InternalError(`Discriminator field not defined for model "${model}"`);
+  }
+  return discriminator.value.field;
+}
+__name(getDiscriminatorField, "getDiscriminatorField");
+function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */ new Set()) {
+  const subModels = Object.values(schema.models).filter((m) => m.baseModel === model);
+  subModels.forEach((def) => {
+    if (!collected.has(def)) {
+      collected.add(def);
+      getDelegateDescendantModels(schema, def.name, collected);
+    }
+  });
+  return [
+    ...collected
+  ];
+}
+__name(getDelegateDescendantModels, "getDelegateDescendantModels");
 
 // src/client/crud/operations/base.ts
 import { createId } from "@paralleldrive/cuid2";
@@ -323,6 +447,16 @@ import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { sql as sql2 } from "kysely";
 import { match as match2 } from "ts-pattern";
 
+// src/client/constants.ts
+var CONTEXT_COMMENT_PREFIX = "-- $$context:";
+var NUMERIC_FIELD_TYPES = [
+  "Int",
+  "Float",
+  "BigInt",
+  "Decimal"
+];
+var DELEGATE_JOINED_FIELD_PREFIX = "$delegate$";
+
 // src/client/crud/dialects/base.ts
 import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
 import { sql } from "kysely";
@@ -356,6 +490,17 @@ var BaseCrudDialect = class {
   transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
+  // #region common query builders
+  buildSelectModel(eb, model) {
+    const modelDef = requireModel(this.schema, model);
+    let result = eb.selectFrom(model);
+    let joinBase = modelDef.baseModel;
+    while (joinBase) {
+      result = this.buildDelegateJoin(model, joinBase, result);
+      joinBase = requireModel(this.schema, joinBase).baseModel;
+    }
+    return result;
+  }
   buildFilter(eb, model, modelAlias, where) {
     if (where === true || where === void 0) {
       return this.true(eb);
@@ -379,10 +524,13 @@ var BaseCrudDialect = class {
       const fieldDef = requireField(this.schema, model, key);
       if (fieldDef.relation) {
         result = this.and(eb, result, this.buildRelationFilter(eb, model, modelAlias, key, fieldDef, payload));
-      } else if (fieldDef.array) {
-        result = this.and(eb, result, this.buildArrayFilter(eb, model, modelAlias, key, fieldDef, payload));
       } else {
-        result = this.and(eb, result, this.buildPrimitiveFilter(eb, model, modelAlias, key, fieldDef, payload));
+        const fieldRef = buildFieldRef(this.schema, fieldDef.originModel ?? model, key, this.options, eb, fieldDef.originModel ?? modelAlias);
+        if (fieldDef.array) {
+          result = this.and(eb, result, this.buildArrayFilter(eb, fieldRef, fieldDef, payload));
+        } else {
+          result = this.and(eb, result, this.buildPrimitiveFilter(eb, fieldRef, fieldDef, payload));
+        }
       }
     }
     if ("$expr" in _where && typeof _where["$expr"] === "function") {
@@ -400,19 +548,26 @@ var BaseCrudDialect = class {
       return this.buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload);
     }
   }
-  buildToOneRelationFilter(eb, model, table, field, fieldDef, payload) {
+  buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (payload === null) {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, field);
-      if (ownedByModel) {
-        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${table}.${fk}`), "is", null)));
+      if (ownedByModel && !fieldDef.originModel) {
+        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${modelAlias}.${fk}`), "is", null)));
       } else {
-        return this.buildToOneRelationFilter(eb, model, table, field, fieldDef, {
+        return this.buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, {
           is: null
         });
       }
     }
-    const joinAlias = `${table}$${field}`;
-    const joinPairs = buildJoinPairs(this.schema, model, table, field, joinAlias);
+    const joinAlias = `${modelAlias}$${field}`;
+    const joinPairs = buildJoinPairs(
+      this.schema,
+      model,
+      // if field is from a base, use the base model to join
+      fieldDef.originModel ?? modelAlias,
+      field,
+      joinAlias
+    );
     const filterResultField = `${field}$filter`;
     const joinSelect = eb.selectFrom(`${fieldDef.type} as ${joinAlias}`).where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right))))).select(() => eb.fn.count(eb.lit(1)).as(filterResultField));
     const conditions = [];
@@ -473,25 +628,24 @@ var BaseCrudDialect = class {
       }
       switch (key) {
         case "some": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
           break;
         }
         case "every": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
           break;
         }
         case "none": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
           break;
         }
       }
     }
     return result;
   }
-  buildArrayFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildArrayFilter(eb, fieldRef, fieldDef, payload) {
     const clauses = [];
     const fieldType = fieldDef.type;
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
     for (const [key, _value] of Object.entries(payload)) {
       if (_value === void 0) {
         continue;
@@ -527,14 +681,14 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...clauses);
   }
-  buildPrimitiveFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildPrimitiveFilter(eb, fieldRef, fieldDef, payload) {
     if (payload === null) {
-      return eb(sql.ref(`${modelAlias}.${field}`), "is", null);
+      return eb(fieldRef, "is", null);
     }
     if (isEnum(this.schema, fieldDef.type)) {
-      return this.buildEnumFilter(eb, modelAlias, field, fieldDef, payload);
+      return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, model, modelAlias, field, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, modelAlias, field, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, modelAlias, field, payload)).with("Bytes", () => this.buildBytesFilter(eb, modelAlias, field, payload)).with("Json", () => {
+    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
       throw new InternalError("JSON filters are not supported yet");
     }).with("Unsupported", () => {
       throw new QueryError(`Unsupported field cannot be used in filters`);
@@ -590,9 +744,7 @@ var BaseCrudDialect = class {
       consumedKeys
     };
   }
-  buildStringFilter(eb, table, field, payload) {
-    const fieldDef = getField(this.schema, table, field);
-    let fieldRef = fieldDef?.computed ? sql.ref(field) : sql.ref(`${table}.${field}`);
+  buildStringFilter(eb, fieldRef, payload) {
     let insensitive = false;
     if (payload && typeof payload === "object" && "mode" in payload && payload.mode === "insensitive") {
       insensitive = true;
@@ -600,7 +752,7 @@ var BaseCrudDialect = class {
         fieldRef
       ]);
     }
-    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (value) => this.buildStringFilter(eb, table, field, value));
+    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (value) => this.buildStringFilter(eb, fieldRef, value));
     if (payload && typeof payload === "object") {
       for (const [key, value] of Object.entries(payload)) {
         if (key === "mode" || consumedKeys.includes(key)) {
@@ -627,23 +779,23 @@ var BaseCrudDialect = class {
       return value === null ? null : sql.lit(value);
     }
   }
-  buildNumberFilter(eb, model, table, field, type, payload) {
-    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, model, table, field, type, value));
+  buildNumberFilter(eb, fieldRef, type, payload) {
+    const { conditions } = this.buildStandardFilter(eb, type, payload, fieldRef, (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, fieldRef, type, value));
     return this.and(eb, ...conditions);
   }
-  buildBooleanFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
+  buildBooleanFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, fieldRef, (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, fieldRef, value), true, [
       "equals",
       "not"
     ]);
     return this.and(eb, ...conditions);
   }
-  buildDateTimeFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
+  buildDateTimeFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, fieldRef, (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, fieldRef, value), true);
     return this.and(eb, ...conditions);
   }
-  buildBytesFilter(eb, table, field, payload) {
-    const conditions = this.buildStandardFilter(eb, "Bytes", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, table, field, value), true, [
+  buildBytesFilter(eb, fieldRef, payload) {
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, fieldRef, (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, fieldRef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -651,8 +803,8 @@ var BaseCrudDialect = class {
     ]);
     return this.and(eb, ...conditions.conditions);
   }
-  buildEnumFilter(eb, table, field, fieldDef, payload) {
-    const conditions = this.buildStandardFilter(eb, "String", payload, sql.ref(`${table}.${field}`), (value) => value, (value) => this.buildEnumFilter(eb, table, field, fieldDef, value), true, [
+  buildEnumFilter(eb, fieldRef, fieldDef, payload) {
+    const conditions = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => value, (value) => this.buildEnumFilter(eb, fieldRef, fieldDef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -719,7 +871,7 @@ var BaseCrudDialect = class {
               invariant(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
               const sort = this.negateSort(value._count, negated);
               result = result.orderBy((eb) => {
-                let subQuery = eb.selectFrom(relationModel);
+                let subQuery = this.buildSelectModel(eb, relationModel);
                 const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
                 subQuery = subQuery.where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
@@ -738,6 +890,56 @@ var BaseCrudDialect = class {
     });
     return result;
   }
+  buildSelectAllFields(model, query, omit) {
+    const modelDef = requireModel(this.schema, model);
+    let result = query;
+    for (const field of Object.keys(modelDef.fields)) {
+      if (isRelationField(this.schema, model, field)) {
+        continue;
+      }
+      if (omit?.[field] === true) {
+        continue;
+      }
+      result = this.buildSelectField(result, model, model, field);
+    }
+    const descendants = getDelegateDescendantModels(this.schema, model);
+    for (const subModel of descendants) {
+      result = this.buildDelegateJoin(model, subModel.name, result);
+      result = result.select((eb) => {
+        const jsonObject = {};
+        for (const field of Object.keys(subModel.fields)) {
+          if (isRelationField(this.schema, subModel.name, field) || isInheritedField(this.schema, subModel.name, field)) {
+            continue;
+          }
+          jsonObject[field] = eb.ref(`${subModel.name}.${field}`);
+        }
+        return this.buildJsonObject(eb, jsonObject).as(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`);
+      });
+    }
+    return result;
+  }
+  buildSelectField(query, model, modelAlias, field) {
+    const fieldDef = requireField(this.schema, model, field);
+    if (fieldDef.computed) {
+      return query.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(field));
+    } else if (!fieldDef.originModel) {
+      return query.select(sql.ref(`${modelAlias}.${field}`).as(field));
+    } else {
+      return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
+    }
+  }
+  buildDelegateJoin(thisModel, otherModel, query) {
+    const idFields = getIdFields(this.schema, thisModel);
+    query = query.leftJoin(otherModel, (qb) => {
+      for (const idField of idFields) {
+        qb = qb.onRef(`${thisModel}.${idField}`, "=", `${otherModel}.${idField}`);
+      }
+      return qb;
+    });
+    return query;
+  }
+  // #endregion
+  // #region utils
   negateSort(sort, negated) {
     return negated ? sort === "asc" ? "desc" : "asc" : sort;
   }
@@ -819,7 +1021,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       const joinTableName = `${parentName}$${relationField}`;
       let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
       result = eb.selectFrom(() => {
-        let subQuery = eb.selectFrom(`${relationModel}`).selectAll();
+        let subQuery = this.buildSelectModel(eb, relationModel);
+        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
         if (payload && typeof payload === "object") {
           if (payload.where) {
             subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -866,6 +1069,13 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   buildRelationObjectArgs(relationModel, relationField, eb, payload, parentName) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
+    const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+    if (descendantModels.length > 0) {
+      objArgs.push(...descendantModels.map((subModel) => [
+        sql2.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+        eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+      ]).flatMap((v) => v));
+    }
     if (payload === true || !payload.select) {
       objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
         sql2.lit(field),
@@ -958,7 +1168,11 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (Array.isArray(value)) {
       return value.map((v) => this.transformPrimitive(v, type, false));
     } else {
-      return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+      if (this.schema.typeDefs && type in this.schema.typeDefs) {
+        return JSON.stringify(value);
+      } else {
+        return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+      }
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -970,7 +1184,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     const relationModelDef = requireModel(this.schema, relationModel);
     const subQueryName = `${parentName}$${relationField}`;
     let tbl = eb.selectFrom(() => {
-      let subQuery = eb.selectFrom(relationModel).selectAll();
+      let subQuery = this.buildSelectModel(eb, relationModel);
+      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
       if (payload && typeof payload === "object") {
         if (payload.where) {
           subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -1006,6 +1221,13 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     });
     tbl = tbl.select(() => {
       const objArgs = [];
+      const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+      if (descendantModels.length > 0) {
+        objArgs.push(...descendantModels.map((subModel) => [
+          sql3.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+          eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+        ]).flatMap((v) => v));
+      }
       if (payload === true || !payload.select) {
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
           sql3.lit(field),
@@ -1088,85 +1310,6 @@ function getCrudDialect(schema, options) {
 }
 __name(getCrudDialect, "getCrudDialect");
 
-// src/schema/expression.ts
-var ExpressionUtils = {
-  literal: /* @__PURE__ */ __name((value) => {
-    return {
-      kind: "literal",
-      value
-    };
-  }, "literal"),
-  array: /* @__PURE__ */ __name((items) => {
-    return {
-      kind: "array",
-      items
-    };
-  }, "array"),
-  call: /* @__PURE__ */ __name((functionName, args) => {
-    return {
-      kind: "call",
-      function: functionName,
-      args
-    };
-  }, "call"),
-  binary: /* @__PURE__ */ __name((left, op, right) => {
-    return {
-      kind: "binary",
-      op,
-      left,
-      right
-    };
-  }, "binary"),
-  unary: /* @__PURE__ */ __name((op, operand) => {
-    return {
-      kind: "unary",
-      op,
-      operand
-    };
-  }, "unary"),
-  field: /* @__PURE__ */ __name((field) => {
-    return {
-      kind: "field",
-      field
-    };
-  }, "field"),
-  member: /* @__PURE__ */ __name((receiver, members) => {
-    return {
-      kind: "member",
-      receiver,
-      members
-    };
-  }, "member"),
-  _this: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "this"
-    };
-  }, "_this"),
-  _null: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "null"
-    };
-  }, "_null"),
-  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
-  }, "and"),
-  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
-  }, "or"),
-  is: /* @__PURE__ */ __name((value, kind) => {
-    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
-  }, "is"),
-  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
-  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
-  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
-  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
-  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
-  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
-  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
-  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
-  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
-};
-
 // src/utils/default-operation-node-visitor.ts
 import { OperationNodeVisitor } from "kysely";
 var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
@@ -2433,10 +2576,10 @@ function clone(value) {
 __name(clone, "clone");
 
 // src/utils/object-utils.ts
-function extractFields(obj, fields) {
+function extractFields2(obj, fields) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => fields.includes(key)));
 }
-__name(extractFields, "extractFields");
+__name(extractFields2, "extractFields");
 function fieldsToSelectObject(fields) {
   return Object.fromEntries(fields.map((f) => [
     f,
@@ -2445,15 +2588,6 @@ function fieldsToSelectObject(fields) {
 }
 __name(fieldsToSelectObject, "fieldsToSelectObject");
 
-// src/client/constants.ts
-var CONTEXT_COMMENT_PREFIX = "-- $$context:";
-var NUMERIC_FIELD_TYPES = [
-  "Int",
-  "Float",
-  "BigInt",
-  "Decimal"
-];
-
 // src/client/crud/operations/base.ts
 var BaseOperationHandler = class {
   static {
@@ -2497,17 +2631,17 @@ var BaseOperationHandler = class {
   getField(model, field) {
     return getField(this.schema, model, field);
   }
-  exists(kysely, model, filter) {
+  async exists(kysely, model, filter) {
     const idFields = getIdFields(this.schema, model);
     const _filter = flattenCompoundUniqueFilters(this.schema, model, filter);
     const query = kysely.selectFrom(model).where((eb) => eb.and(_filter)).select(idFields.map((f) => kysely.dynamic.ref(f))).limit(1).modifyEnd(this.makeContextComment({
       model,
       operation: "read"
     }));
-    return query.executeTakeFirst();
+    return this.executeQueryTakeFirst(kysely, query, "exists");
   }
   async read(kysely, model, args) {
-    let query = kysely.selectFrom(model);
+    let query = this.dialect.buildSelectModel(expressionBuilder2(), model);
     if (args?.where) {
       query = query.where((eb) => this.dialect.buildFilter(eb, model, model, args?.where));
     }
@@ -2532,7 +2666,7 @@ var BaseOperationHandler = class {
     if (args && "select" in args && args.select) {
       query = this.buildFieldSelection(model, query, args.select, model);
     } else {
-      query = this.buildSelectAllScalarFields(model, query, args?.omit);
+      query = this.dialect.buildSelectAllFields(model, query, args?.omit);
     }
     if (args && "include" in args && args.include) {
       query = this.buildFieldSelection(model, query, args.include, model);
@@ -2545,14 +2679,18 @@ var BaseOperationHandler = class {
       operation: "read"
     }));
     let result = [];
+    const queryId = {
+      queryId: `zenstack-${createId()}`
+    };
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), queryId);
     try {
-      result = await query.execute();
+      const r = await kysely.getExecutor().executeQuery(compiled, queryId);
+      result = r.rows;
     } catch (err) {
-      const { sql: sql11, parameters } = query.compile();
-      let message = `Failed to execute query: ${err}, sql: ${sql11}`;
+      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       if (this.options.debug) {
         message += `, parameters: 
-${parameters.map((p) => inspect(p)).join("\n")}`;
+${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
       }
       throw new QueryError(message, err);
     }
@@ -2589,12 +2727,16 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       }
       const fieldDef = this.requireField(model, field);
       if (!fieldDef.relation) {
-        result = this.selectField(result, model, parentAlias, field);
+        result = this.dialect.buildSelectField(result, model, parentAlias, field);
       } else {
         if (!fieldDef.array && !fieldDef.optional && payload.where) {
           throw new QueryError(`Field "${field}" doesn't support filtering`);
         }
-        result = this.dialect.buildRelationSelection(result, model, field, parentAlias, payload);
+        if (fieldDef.originModel) {
+          result = this.dialect.buildRelationSelection(result, fieldDef.originModel, field, fieldDef.originModel, payload);
+        } else {
+          result = this.dialect.buildRelationSelection(result, model, field, parentAlias, payload);
+        }
       }
     }
     return result;
@@ -2627,18 +2769,6 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
     query = query.select((eb2) => this.dialect.buildJsonObject(eb2, jsonObject).as("_count"));
     return query;
   }
-  buildSelectAllScalarFields(model, query, omit) {
-    const modelDef = this.requireModel(model);
-    return Object.keys(modelDef.fields).filter((f) => !isRelationField(this.schema, model, f)).filter((f) => omit?.[f] !== true).reduce((acc, f) => this.selectField(acc, model, model, f), query);
-  }
-  selectField(query, model, modelAlias, field) {
-    const fieldDef = this.requireField(model, field);
-    if (!fieldDef.computed) {
-      return query.select(sql4.ref(`${modelAlias}.${field}`).as(field));
-    } else {
-      return query.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(field));
-    }
-  }
   buildCursorFilter(model, query, cursor, orderBy, negateOrderBy) {
     if (!orderBy) {
       orderBy = makeDefaultOrderBy(this.schema, model);
@@ -2661,9 +2791,12 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
     result = result.where((eb2) => eb2.or(filters));
     return result;
   }
-  async create(kysely, model, data, fromRelation) {
+  async create(kysely, model, data, fromRelation, creatingForDelegate = false) {
     const modelDef = this.requireModel(model);
-    const createFields = {};
+    if (modelDef.isDelegate && !creatingForDelegate) {
+      throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
+    }
+    let createFields = {};
     let parentUpdateTask = void 0;
     let m2m = void 0;
     if (fromRelation) {
@@ -2682,7 +2815,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
               model: fromRelation.model,
               operation: "update"
             }));
-            return query2.execute();
+            return this.executeQuery(kysely, query2, "update");
           }, "parentUpdateTask");
         }
       }
@@ -2711,13 +2844,17 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
         }
       }
     }
+    if (modelDef.baseModel) {
+      const baseCreateResult = await this.processBaseModelCreate(kysely, modelDef.baseModel, createFields, model);
+      createFields = baseCreateResult.remainingFields;
+    }
     const updatedData = this.fillGeneratedValues(modelDef, createFields);
     const idFields = getIdFields(this.schema, model);
-    const query = kysely.insertInto(model).values(updatedData).returning(idFields).modifyEnd(this.makeContextComment({
+    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,
       operation: "create"
     }));
-    const createdEntity = await query.executeTakeFirst();
+    const createdEntity = await this.executeQueryTakeFirst(kysely, query, "create");
     if (Object.keys(postCreateRelations).length > 0) {
       const relationPromises = Object.entries(postCreateRelations).map(([field, subPayload]) => {
         return this.processNoneOwnedRelationForCreate(kysely, model, field, subPayload, createdEntity);
@@ -2732,6 +2869,28 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
     }
     return createdEntity;
   }
+  async processBaseModelCreate(kysely, model, createFields, forModel) {
+    const thisCreateFields = {};
+    const remainingFields = {};
+    Object.entries(createFields).forEach(([field, value]) => {
+      const fieldDef = this.getField(model, field);
+      if (fieldDef) {
+        thisCreateFields[field] = value;
+      } else {
+        remainingFields[field] = value;
+      }
+    });
+    const discriminatorField = getDiscriminatorField(this.schema, model);
+    invariant7(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    thisCreateFields[discriminatorField] = forModel;
+    const baseEntity = await this.create(kysely, model, thisCreateFields, void 0, true);
+    const idValues = extractIdFields(baseEntity, this.schema, model);
+    Object.assign(remainingFields, idValues);
+    return {
+      baseEntity,
+      remainingFields
+    };
+  }
   buildFkAssignments(model, relationField, entity) {
     const parentFkFields = {};
     invariant7(relationField, "parentField must be defined if parentModel is defined");
@@ -2806,7 +2965,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
         case "connect": {
           const referencedPkFields = relationField.relation.references;
           invariant7(referencedPkFields, "relation must have fields info");
-          const extractedFks = extractFields(subPayload, referencedPkFields);
+          const extractedFks = extractFields2(subPayload, referencedPkFields);
           if (Object.keys(extractedFks).length === referencedPkFields.length) {
             result = extractedFks;
           } else {
@@ -2901,7 +3060,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       }
       relationKeyPairs = keyPairs;
     }
-    const createData = enumerate(input.data).map((item) => {
+    let createData = enumerate(input.data).map((item) => {
       const newItem = {};
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
@@ -2915,14 +3074,21 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       }
       return this.fillGeneratedValues(modelDef, newItem);
     });
+    if (modelDef.baseModel) {
+      if (input.skipDuplicates) {
+        throw new QueryError('"skipDuplicates" options is not supported for polymorphic models');
+      }
+      const baseCreateResult = await this.processBaseModelCreateMany(kysely, modelDef.baseModel, createData, !!input.skipDuplicates, model);
+      createData = baseCreateResult.remainingFieldRows;
+    }
     const query = kysely.insertInto(model).values(createData).$if(!!input.skipDuplicates, (qb) => qb.onConflict((oc) => oc.doNothing())).modifyEnd(this.makeContextComment({
       model,
       operation: "create"
     }));
     if (!returnData) {
-      const result = await query.executeTakeFirstOrThrow();
+      const result = await this.executeQuery(kysely, query, "createMany");
       return {
-        count: Number(result.numInsertedOrUpdatedRows)
+        count: Number(result.numAffectedRows)
       };
     } else {
       const idFields = getIdFields(this.schema, model);
@@ -2930,10 +3096,46 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       return result;
     }
   }
+  async processBaseModelCreateMany(kysely, model, createRows, skipDuplicates, forModel) {
+    const thisCreateRows = [];
+    const remainingFieldRows = [];
+    const discriminatorField = getDiscriminatorField(this.schema, model);
+    invariant7(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    for (const createFields of createRows) {
+      const thisCreateFields = {};
+      const remainingFields = {};
+      Object.entries(createFields).forEach(([field, value]) => {
+        const fieldDef = this.getField(model, field);
+        if (fieldDef) {
+          thisCreateFields[field] = value;
+        } else {
+          remainingFields[field] = value;
+        }
+      });
+      thisCreateFields[discriminatorField] = forModel;
+      thisCreateRows.push(thisCreateFields);
+      remainingFieldRows.push(remainingFields);
+    }
+    const baseEntities = await this.createMany(kysely, model, {
+      data: thisCreateRows,
+      skipDuplicates
+    }, true);
+    for (let i = 0; i < baseEntities.length; i++) {
+      const idValues = extractIdFields(baseEntities[i], this.schema, model);
+      Object.assign(remainingFieldRows[i], idValues);
+    }
+    return {
+      baseEntities,
+      remainingFieldRows
+    };
+  }
   fillGeneratedValues(modelDef, data) {
     const fields = modelDef.fields;
     const values = clone(data);
-    for (const field in fields) {
+    for (const [field, fieldDef] of Object.entries(fields)) {
+      if (fieldDef.originModel) {
+        continue;
+      }
       if (!(field in data)) {
         if (typeof fields[field]?.default === "object" && "kind" in fields[field].default) {
           const generated = this.evalGenerator(fields[field].default);
@@ -3010,28 +3212,33 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       }
     }
     if (Object.keys(finalData).length === 0) {
-      const r = await this.readUnique(kysely, model, {
-        where: combinedWhere
+      return combinedWhere;
+    }
+    let needIdRead = false;
+    if (modelDef.baseModel && !this.isIdFilter(model, combinedWhere)) {
+      needIdRead = true;
+    }
+    if (needIdRead) {
+      const readResult = await this.readUnique(kysely, model, {
+        where: combinedWhere,
+        select: this.makeIdSelect(model)
       });
-      if (!r && throwIfNotFound) {
+      if (!readResult && throwIfNotFound) {
         throw new NotFoundError(model);
       }
-      return r;
+      combinedWhere = readResult;
+    }
+    if (modelDef.baseModel) {
+      const baseUpdateResult = await this.processBaseModelUpdate(kysely, modelDef.baseModel, combinedWhere, finalData, throwIfNotFound);
+      finalData = baseUpdateResult.remainingFields;
+      combinedWhere = baseUpdateResult.baseEntity;
     }
     const updateFields = {};
     let thisEntity = void 0;
     for (const field in finalData) {
       const fieldDef = this.requireField(model, field);
       if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) {
-        if (this.isNumericField(fieldDef) && typeof finalData[field] === "object" && finalData[field]) {
-          updateFields[field] = this.transformIncrementalUpdate(model, field, fieldDef, finalData[field]);
-          continue;
-        }
-        if (fieldDef.array && typeof finalData[field] === "object" && !Array.isArray(finalData[field]) && finalData[field]) {
-          updateFields[field] = this.transformScalarListUpdate(model, field, fieldDef, finalData[field]);
-          continue;
-        }
-        updateFields[field] = this.dialect.transformPrimitive(finalData[field], fieldDef.type, !!fieldDef.array);
+        updateFields[field] = this.processScalarFieldUpdateData(model, field, finalData);
       } else {
         if (!allowRelationUpdate) {
           throw new QueryError(`Relation update not allowed for field "${field}"`);
@@ -3053,16 +3260,14 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       }
     }
     if (Object.keys(updateFields).length === 0) {
-      return thisEntity ?? await this.readUnique(kysely, model, {
-        where: combinedWhere
-      });
+      return combinedWhere;
     } else {
       const idFields = getIdFields(this.schema, model);
       const query = kysely.updateTable(model).where((eb) => this.dialect.buildFilter(eb, model, model, combinedWhere)).set(updateFields).returning(idFields).modifyEnd(this.makeContextComment({
         model,
         operation: "update"
       }));
-      const updatedEntity = await query.executeTakeFirst();
+      const updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
       if (!updatedEntity) {
         if (throwIfNotFound) {
           throw new NotFoundError(model);
@@ -3073,6 +3278,55 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       return updatedEntity;
     }
   }
+  processScalarFieldUpdateData(model, field, data) {
+    const fieldDef = this.requireField(model, field);
+    if (this.isNumericIncrementalUpdate(fieldDef, data[field])) {
+      return this.transformIncrementalUpdate(model, field, fieldDef, data[field]);
+    }
+    if (fieldDef.array && typeof data[field] === "object" && !Array.isArray(data[field]) && data[field]) {
+      return this.transformScalarListUpdate(model, field, fieldDef, data[field]);
+    }
+    return this.dialect.transformPrimitive(data[field], fieldDef.type, !!fieldDef.array);
+  }
+  isNumericIncrementalUpdate(fieldDef, value) {
+    if (!this.isNumericField(fieldDef)) {
+      return false;
+    }
+    if (typeof value !== "object" || !value) {
+      return false;
+    }
+    return [
+      "increment",
+      "decrement",
+      "multiply",
+      "divide",
+      "set"
+    ].some((key) => key in value);
+  }
+  isIdFilter(model, filter) {
+    if (!filter || typeof filter !== "object") {
+      return false;
+    }
+    const idFields = getIdFields(this.schema, model);
+    return idFields.length === Object.keys(filter).length && idFields.every((field) => field in filter);
+  }
+  async processBaseModelUpdate(kysely, model, where, updateFields, throwIfNotFound) {
+    const thisUpdateFields = {};
+    const remainingFields = {};
+    Object.entries(updateFields).forEach(([field, value]) => {
+      const fieldDef = this.getField(model, field);
+      if (fieldDef) {
+        thisUpdateFields[field] = value;
+      } else {
+        remainingFields[field] = value;
+      }
+    });
+    const baseEntity = await this.update(kysely, model, where, thisUpdateFields, void 0, void 0, throwIfNotFound);
+    return {
+      baseEntity,
+      remainingFields
+    };
+  }
   transformIncrementalUpdate(model, field, fieldDef, payload) {
     invariant7(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
     const key = Object.keys(payload)[0];
@@ -3101,7 +3355,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
   makeContextComment(context) {
     return sql4.raw(`${CONTEXT_COMMENT_PREFIX}${JSON.stringify(context)}`);
   }
-  async updateMany(kysely, model, where, data, limit, returnData) {
+  async updateMany(kysely, model, where, data, limit, returnData, filterModel) {
     if (typeof data !== "object") {
       throw new InternalError("data must be an object");
     }
@@ -3110,34 +3364,52 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
         count: 0
       };
     }
-    const updateFields = {};
+    const modelDef = this.requireModel(model);
+    if (modelDef.baseModel && limit !== void 0) {
+      throw new QueryError("Updating with a limit is not supported for polymorphic models");
+    }
+    filterModel ??= model;
+    let updateFields = {};
     for (const field in data) {
-      const fieldDef = this.requireField(model, field);
       if (isRelationField(this.schema, model, field)) {
         continue;
       }
-      updateFields[field] = this.dialect.transformPrimitive(data[field], fieldDef.type, !!fieldDef.array);
+      updateFields[field] = this.processScalarFieldUpdateData(model, field, data);
+    }
+    let shouldFallbackToIdFilter = false;
+    if (limit !== void 0 && !this.dialect.supportsUpdateWithLimit) {
+      shouldFallbackToIdFilter = true;
+    }
+    if (modelDef.isDelegate || modelDef.baseModel) {
+      shouldFallbackToIdFilter = true;
+    }
+    let resultFromBaseModel = void 0;
+    if (modelDef.baseModel) {
+      const baseResult = await this.processBaseModelUpdateMany(kysely, modelDef.baseModel, where, updateFields, filterModel);
+      updateFields = baseResult.remainingFields;
+      resultFromBaseModel = baseResult.baseResult;
+    }
+    if (Object.keys(updateFields).length === 0) {
+      return resultFromBaseModel ?? (returnData ? [] : {
+        count: 0
+      });
     }
     let query = kysely.updateTable(model).set(updateFields);
-    if (limit === void 0) {
-      query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where));
+    if (!shouldFallbackToIdFilter) {
+      query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where)).$if(limit !== void 0, (qb) => qb.limit(limit));
     } else {
-      if (this.dialect.supportsUpdateWithLimit) {
-        query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where)).limit(limit);
-      } else {
-        query = query.where((eb) => eb(eb.refTuple(
-          ...this.buildIdFieldRefs(kysely, model)
-        ), "in", kysely.selectFrom(model).where((eb2) => this.dialect.buildFilter(eb2, model, model, where)).select(this.buildIdFieldRefs(kysely, model)).limit(limit)));
-      }
+      query = query.where((eb) => eb(eb.refTuple(
+        ...this.buildIdFieldRefs(kysely, model)
+      ), "in", this.dialect.buildSelectModel(eb, filterModel).where(this.dialect.buildFilter(eb, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
     }
     query = query.modifyEnd(this.makeContextComment({
       model,
       operation: "update"
     }));
     if (!returnData) {
-      const result = await query.executeTakeFirstOrThrow();
+      const result = await this.executeQuery(kysely, query, "update");
       return {
-        count: Number(result.numUpdatedRows)
+        count: Number(result.numAffectedRows)
       };
     } else {
       const idFields = getIdFields(this.schema, model);
@@ -3145,9 +3417,26 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       return result;
     }
   }
+  async processBaseModelUpdateMany(kysely, model, where, updateFields, filterModel) {
+    const thisUpdateFields = {};
+    const remainingFields = {};
+    Object.entries(updateFields).forEach(([field, value]) => {
+      const fieldDef = this.getField(model, field);
+      if (fieldDef) {
+        thisUpdateFields[field] = value;
+      } else {
+        remainingFields[field] = value;
+      }
+    });
+    const baseResult = await this.updateMany(kysely, model, where, thisUpdateFields, void 0, false, filterModel);
+    return {
+      baseResult,
+      remainingFields
+    };
+  }
   buildIdFieldRefs(kysely, model) {
     const idFields = getIdFields(this.schema, model);
-    return idFields.map((f) => kysely.dynamic.ref(f));
+    return idFields.map((f) => kysely.dynamic.ref(`${model}.${f}`));
   }
   async processRelationUpdates(kysely, model, field, fieldDef, parentIds, args, throwIfNotFound) {
     const tasks = [];
@@ -3265,7 +3554,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
           model: fromRelation.model,
           operation: "update"
         }));
-        updateResult = await query.executeTakeFirstOrThrow();
+        updateResult = await this.executeQuery(kysely, query, "connect");
       } else {
         const relationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
         if (!relationFieldDef.array) {
@@ -3276,7 +3565,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
             model: fromRelation.model,
             operation: "update"
           }));
-          await query2.execute();
+          await this.executeQuery(kysely, query2, "disconnect");
         }
         const query = kysely.updateTable(model).where((eb) => eb.or(_data.map((d) => eb.and(d)))).set(keyPairs.reduce((acc, { fk, pk }) => ({
           ...acc,
@@ -3285,9 +3574,9 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
           model,
           operation: "update"
         }));
-        updateResult = await query.executeTakeFirstOrThrow();
+        updateResult = await this.executeQuery(kysely, query, "connect");
       }
-      if (_data.length > updateResult.numUpdatedRows) {
+      if (_data.length > updateResult.numAffectedRows) {
         throw new NotFoundError(model);
       }
     }
@@ -3355,7 +3644,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
           model: fromRelation.model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       } else {
         const query = kysely.updateTable(model).where(eb.and([
           // fk filter
@@ -3372,7 +3661,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
           model,
           operation: "update"
         }));
-        await query.executeTakeFirstOrThrow();
+        await this.executeQuery(kysely, query, "disconnect");
       }
     }
   }
@@ -3410,7 +3699,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
         model,
         operation: "update"
       }));
-      await query.execute();
+      await this.executeQuery(kysely, query, "disconnect");
       if (_data.length > 0) {
         const query2 = kysely.updateTable(model).where((eb) => eb.or(_data.map((d) => eb.and(d)))).set(keyPairs.reduce((acc, { fk, pk }) => ({
           ...acc,
@@ -3419,8 +3708,8 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
           model,
           operation: "update"
         }));
-        const r = await query2.executeTakeFirstOrThrow();
-        if (_data.length > r.numUpdatedRows) {
+        const r = await this.executeQuery(kysely, query2, "connect");
+        if (_data.length > r.numAffectedRows) {
           throw new NotFoundError(model);
         }
       }
@@ -3461,7 +3750,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
             OR: deleteConditions
           }
         ]
-      }, void 0, false);
+      });
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
@@ -3484,7 +3773,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
               OR: deleteConditions
             }
           ]
-        }, void 0, false);
+        });
       } else {
         deleteResult = await this.delete(kysely, model, {
           AND: [
@@ -3496,7 +3785,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
               OR: deleteConditions
             }
           ]
-        }, void 0, false);
+        });
       }
     }
     if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
@@ -3507,33 +3796,59 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
     return enumerate(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
   }
   // #endregion
-  async delete(kysely, model, where, limit, returnData) {
+  async delete(kysely, model, where, limit, filterModel) {
+    filterModel ??= model;
+    const modelDef = this.requireModel(model);
+    if (modelDef.baseModel) {
+      if (limit !== void 0) {
+        throw new QueryError("Deleting with a limit is not supported for polymorphic models");
+      }
+      return this.processBaseModelDelete(kysely, modelDef.baseModel, where, limit, filterModel);
+    }
     let query = kysely.deleteFrom(model);
-    if (limit === void 0) {
+    let needIdFilter = false;
+    if (limit !== void 0 && !this.dialect.supportsDeleteWithLimit) {
+      needIdFilter = true;
+    }
+    if (modelDef.isDelegate || modelDef.baseModel) {
+      needIdFilter = true;
+    }
+    if (!needIdFilter) {
       query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where));
     } else {
-      if (this.dialect.supportsDeleteWithLimit) {
-        query = query.where((eb) => this.dialect.buildFilter(eb, model, model, where)).limit(limit);
-      } else {
-        query = query.where((eb) => eb(eb.refTuple(
-          ...this.buildIdFieldRefs(kysely, model)
-        ), "in", kysely.selectFrom(model).where((eb2) => this.dialect.buildFilter(eb2, model, model, where)).select(this.buildIdFieldRefs(kysely, model)).limit(limit)));
-      }
+      query = query.where((eb) => eb(eb.refTuple(
+        ...this.buildIdFieldRefs(kysely, model)
+      ), "in", this.dialect.buildSelectModel(eb, filterModel).where((eb2) => this.dialect.buildFilter(eb2, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
     }
+    await this.processDelegateRelationDelete(kysely, modelDef, where, limit);
     query = query.modifyEnd(this.makeContextComment({
       model,
       operation: "delete"
     }));
-    if (returnData) {
-      const result = await query.execute();
-      return result;
-    } else {
-      const result = await query.executeTakeFirstOrThrow();
-      return {
-        count: Number(result.numDeletedRows)
-      };
+    const result = await this.executeQuery(kysely, query, "delete");
+    return {
+      count: Number(result.numAffectedRows)
+    };
+  }
+  async processDelegateRelationDelete(kysely, modelDef, where, limit) {
+    for (const fieldDef of Object.values(modelDef.fields)) {
+      if (fieldDef.relation && fieldDef.relation.opposite) {
+        const oppositeModelDef = this.requireModel(fieldDef.type);
+        const oppositeRelation = this.requireField(fieldDef.type, fieldDef.relation.opposite);
+        if (oppositeModelDef.baseModel && oppositeRelation.relation?.onDelete === "Cascade") {
+          if (limit !== void 0) {
+            throw new QueryError("Deleting with a limit is not supported for polymorphic models");
+          }
+          await this.delete(kysely, fieldDef.type, {
+            [fieldDef.relation.opposite]: where
+          }, void 0);
+        }
+      }
     }
   }
+  async processBaseModelDelete(kysely, model, where, limit, filterModel) {
+    return this.delete(kysely, model, where, limit, filterModel);
+  }
   makeIdSelect(model) {
     const modelDef = this.requireModel(model);
     return modelDef.idFields.reduce((acc, f) => {
@@ -3567,9 +3882,7 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       return callback(this.kysely);
     } else {
       let txBuilder = this.kysely.transaction();
-      if (isolationLevel) {
-        txBuilder = txBuilder.setIsolationLevel(isolationLevel);
-      }
+      txBuilder = txBuilder.setIsolationLevel(isolationLevel ?? "repeatable read");
       return txBuilder.execute(callback);
     }
   }
@@ -3611,6 +3924,25 @@ ${parameters.map((p) => inspect(p)).join("\n")}`;
       }
     }
   }
+  makeQueryId(operation) {
+    return {
+      queryId: `${operation}-${createId()}`
+    };
+  }
+  executeQuery(kysely, query, operation) {
+    return kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+  }
+  async executeQueryTakeFirst(kysely, query, operation) {
+    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+    return result.rows[0];
+  }
+  async executeQueryTakeFirstOrThrow(kysely, query, operation) {
+    const result = await kysely.executeQuery(query.compile(), this.makeQueryId(operation));
+    if (result.rows.length === 0) {
+      throw new QueryError("No rows found");
+    }
+    return result.rows[0];
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -3622,7 +3954,22 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
     const normalizedArgs = this.normalizeArgs(args);
     const parsedArgs = this.inputValidator.validateAggregateArgs(this.model, normalizedArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll(this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      let subQuery = this.dialect.buildSelectModel(eb, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      const selectedFields = [];
+      for (const [key, value] of Object.entries(parsedArgs)) {
+        if (key.startsWith("_") && value && typeof value === "object") {
+          Object.entries(value).filter(([field]) => field !== "_all").filter(([, val]) => val === true).forEach(([field]) => {
+            if (!selectedFields.includes(field)) selectedFields.push(field);
+          });
+        }
+      }
+      if (selectedFields.length > 0) {
+        for (const field of selectedFields) {
+          subQuery = this.dialect.buildSelectField(subQuery, this.model, this.model, field);
+        }
+      } else {
+        subQuery = subQuery.select(() => eb.lit(1).as("_all"));
+      }
       const skip = parsedArgs?.skip;
       let take = parsedArgs?.take;
       let negateOrderBy = false;
@@ -3668,9 +4015,9 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
         }
       }
     }
-    const result = await query.executeTakeFirstOrThrow();
+    const result = await this.executeQuery(this.kysely, query, "aggregate");
     const ret = {};
-    for (const [key, value] of Object.entries(result)) {
+    for (const [key, value] of Object.entries(result.rows[0])) {
       if (key === "_count") {
         ret[key] = value;
         continue;
@@ -3715,18 +4062,29 @@ var CountOperationHandler = class extends BaseOperationHandler {
   async handle(_operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
     const parsedArgs = this.inputValidator.validateCountArgs(this.model, normalizedArgs);
+    const subQueryName = "$sub";
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      let subQuery = this.dialect.buildSelectModel(eb, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      if (parsedArgs?.select && typeof parsedArgs.select === "object") {
+        for (const [key, value] of Object.entries(parsedArgs.select)) {
+          if (key !== "_all" && value === true) {
+            subQuery = this.dialect.buildSelectField(subQuery, this.model, this.model, key);
+          }
+        }
+      } else {
+        subQuery = subQuery.select(() => eb.lit(1).as("_all"));
+      }
       subQuery = this.dialect.buildSkipTake(subQuery, parsedArgs?.skip, parsedArgs?.take);
-      return subQuery.as("$sub");
+      return subQuery.as(subQueryName);
     });
     if (parsedArgs?.select && typeof parsedArgs.select === "object") {
-      query = query.select((eb) => Object.keys(parsedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(sql6.ref(`$sub.${key}`)), "integer").as(key)));
-      return query.executeTakeFirstOrThrow();
+      query = query.select((eb) => Object.keys(parsedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(sql6.ref(`${subQueryName}.${key}`)), "integer").as(key)));
+      const result = await this.executeQuery(this.kysely, query, "count");
+      return result.rows[0];
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
-      const result = await query.executeTakeFirstOrThrow();
-      return result.count;
+      const result = await this.executeQuery(this.kysely, query, "count");
+      return result.rows[0].count;
     }
   }
 };
@@ -3805,15 +4163,19 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     if (!existing) {
       throw new NotFoundError(this.model);
     }
-    const result = await this.delete(this.kysely, this.model, args.where, void 0, false);
-    if (result.count === 0) {
-      throw new NotFoundError(this.model);
-    }
+    await this.safeTransaction(async (tx) => {
+      const result = await this.delete(tx, this.model, args.where);
+      if (result.count === 0) {
+        throw new NotFoundError(this.model);
+      }
+    });
     return existing;
   }
   async runDeleteMany(args) {
-    const result = await this.delete(this.kysely, this.model, args?.where, args?.limit, false);
-    return result;
+    return await this.safeTransaction(async (tx) => {
+      const result = await this.delete(tx, this.model, args?.where, args?.limit);
+      return result;
+    });
   }
 };
 
@@ -3901,8 +4263,8 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
         }
       }
     }
-    const result = await query.execute();
-    return result.map((row) => this.postProcessRow(row));
+    const result = await this.executeQuery(this.kysely, query, "groupBy");
+    return result.rows.map((row) => this.postProcessRow(row));
   }
   postProcessRow(row) {
     const ret = {};
@@ -3954,22 +4316,35 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     return match13(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runUpdate(args) {
-    const result = await this.safeTransaction(async (tx) => {
-      const updated = await this.update(tx, this.model, args.where, args.data);
-      return this.readUnique(tx, this.model, {
-        select: args.select,
-        include: args.include,
-        omit: args.omit,
-        where: getIdValues(this.schema, this.model, updated)
-      });
+    const readBackResult = await this.safeTransaction(async (tx) => {
+      const updateResult = await this.update(tx, this.model, args.where, args.data);
+      const readFilter = updateResult ?? args.where;
+      let readBackResult2 = void 0;
+      try {
+        readBackResult2 = await this.readUnique(tx, this.model, {
+          select: args.select,
+          include: args.include,
+          omit: args.omit,
+          where: readFilter
+        });
+      } catch {
+      }
+      return readBackResult2;
     });
-    if (!result && this.hasPolicyEnabled) {
-      throw new RejectedByPolicyError(this.model, "result is not allowed to be read back");
+    if (!readBackResult) {
+      if (this.hasPolicyEnabled) {
+        throw new RejectedByPolicyError(this.model, "result is not allowed to be read back");
+      } else {
+        return null;
+      }
+    } else {
+      return readBackResult;
     }
-    return result;
   }
   async runUpdateMany(args) {
-    return this.updateMany(this.kysely, this.model, args.where, args.data, args.limit, false);
+    return this.safeTransaction(async (tx) => {
+      return this.updateMany(tx, this.model, args.where, args.data, args.limit, false);
+    });
   }
   async runUpdateManyAndReturn(args) {
     if (!args) {
@@ -4108,17 +4483,45 @@ var InputValidator = class {
     return result;
   }
   makePrimitiveSchema(type) {
-    return match14(type).with("String", () => z.string()).with("Int", () => z.number()).with("Float", () => z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
-      z.number(),
-      z.bigint()
-    ])).with("Decimal", () => z.union([
-      z.number(),
-      z.instanceof(Decimal),
-      z.string()
-    ])).with("DateTime", () => z.union([
-      z.date(),
-      z.string().datetime()
-    ])).with("Bytes", () => z.instanceof(Uint8Array)).otherwise(() => z.unknown());
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefSchema(type);
+    } else {
+      return match14(type).with("String", () => z.string()).with("Int", () => z.number()).with("Float", () => z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
+        z.number(),
+        z.bigint()
+      ])).with("Decimal", () => z.union([
+        z.number(),
+        z.instanceof(Decimal),
+        z.string()
+      ])).with("DateTime", () => z.union([
+        z.date(),
+        z.string().datetime()
+      ])).with("Bytes", () => z.instanceof(Uint8Array)).otherwise(() => z.unknown());
+    }
+  }
+  makeTypeDefSchema(type) {
+    const key = `$typedef-${type}`;
+    let schema = this.schemaCache.get(key);
+    if (schema) {
+      return schema;
+    }
+    const typeDef = this.schema.typeDefs?.[type];
+    invariant8(typeDef, `Type definition "${type}" not found in schema`);
+    schema = z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+      let fieldSchema = this.makePrimitiveSchema(def.type);
+      if (def.array) {
+        fieldSchema = fieldSchema.array();
+      }
+      if (def.optional) {
+        fieldSchema = fieldSchema.optional();
+      }
+      return [
+        field,
+        fieldSchema
+      ];
+    })));
+    this.schemaCache.set(key, schema);
+    return schema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false) {
     const modelDef = getModel(this.schema, model);
@@ -4240,8 +4643,14 @@ var InputValidator = class {
     });
   }
   makePrimitiveFilterSchema(type, optional) {
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefFilterSchema(type, optional);
+    }
     return match14(type).with("String", () => this.makeStringFilterSchema(optional)).with(P2.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).with("Json", () => z.any()).with("Unsupported", () => z.never()).exhaustive();
   }
+  makeTypeDefFilterSchema(_type, _optional) {
+    return z.never();
+  }
   makeDateTimeFilterSchema(optional) {
     return this.makeCommonPrimitiveFilterSchema(z.union([
       z.string().datetime(),
@@ -4446,6 +4855,9 @@ var InputValidator = class {
       if (fieldDef.computed) {
         return;
       }
+      if (this.isDelegateDiscriminator(fieldDef)) {
+        return;
+      }
       if (fieldDef.relation) {
         if (withoutRelationFields) {
           return;
@@ -4518,6 +4930,13 @@ var InputValidator = class {
       ]);
     }
   }
+  isDelegateDiscriminator(fieldDef) {
+    if (!fieldDef.originModel) {
+      return false;
+    }
+    const discriminatorField = getDiscriminatorField(this.schema, fieldDef.originModel);
+    return discriminatorField === fieldDef.name;
+  }
   makeRelationManipulationSchema(fieldDef, withoutFields, mode) {
     const fieldType = fieldDef.type;
     const array = !!fieldDef.array;
@@ -4848,11 +5267,11 @@ var ZenStackDriver = class {
   }
   #driver;
   #log;
-  txConnection;
   #initPromise;
   #initDone;
   #destroyPromise;
   #connections = /* @__PURE__ */ new WeakSet();
+  #txConnections = /* @__PURE__ */ new WeakMap();
   constructor(driver, log) {
     this.#initDone = false;
     this.#driver = driver;
@@ -4893,21 +5312,30 @@ var ZenStackDriver = class {
   }
   async beginTransaction(connection, settings) {
     const result = await this.#driver.beginTransaction(connection, settings);
-    this.txConnection = connection;
+    this.#txConnections.set(connection, []);
     return result;
   }
-  commitTransaction(connection) {
+  async commitTransaction(connection) {
     try {
-      return this.#driver.commitTransaction(connection);
-    } finally {
-      this.txConnection = void 0;
+      const result = await this.#driver.commitTransaction(connection);
+      const callbacks = this.#txConnections.get(connection);
+      this.#txConnections.delete(connection);
+      if (callbacks) {
+        for (const callback of callbacks) {
+          await callback();
+        }
+      }
+      return result;
+    } catch (err) {
+      this.#txConnections.delete(connection);
+      throw err;
     }
   }
-  rollbackTransaction(connection) {
+  async rollbackTransaction(connection) {
     try {
-      return this.#driver.rollbackTransaction(connection);
+      return await this.#driver.rollbackTransaction(connection);
     } finally {
-      this.txConnection = void 0;
+      this.#txConnections.delete(connection);
     }
   }
   async destroy() {
@@ -4985,6 +5413,22 @@ var ZenStackDriver = class {
   #calculateDurationMillis(startTime) {
     return performanceNow() - startTime;
   }
+  isTransactionConnection(connection) {
+    return this.#txConnections.has(connection);
+  }
+  registerTransactionCommitCallback(connection, callback) {
+    if (!this.#txConnections.has(connection)) {
+      return;
+    }
+    const callbacks = this.#txConnections.get(connection);
+    if (callbacks) {
+      callbacks.push(callback);
+    } else {
+      this.#txConnections.set(connection, [
+        callback
+      ]);
+    }
+  }
 };
 function performanceNow() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
@@ -5201,7 +5645,7 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     this.requireCurrentModel(contextNode);
     model = model ?? this.currentModel;
     const modelDef = requireModel(this.schema, model);
-    const scalarFields = Object.entries(modelDef.fields).filter(([, fieldDef]) => !fieldDef.relation && !fieldDef.computed).map(([fieldName]) => fieldName);
+    const scalarFields = Object.entries(modelDef.fields).filter(([, fieldDef]) => !fieldDef.relation && !fieldDef.computed && !fieldDef.originModel).map(([fieldName]) => fieldName);
     return scalarFields;
   }
 };
@@ -5226,7 +5670,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   get options() {
     return this.client.$options;
   }
-  async executeQuery(compiledQuery, queryId) {
+  async executeQuery(compiledQuery, _queryId) {
     let queryNode = compiledQuery.query;
     let mutationInterceptionInfo;
     if (this.isMutationNode(queryNode) && this.hasMutationHooks) {
@@ -5237,7 +5681,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
         await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
       }
       const oldQueryNode = queryNode;
-      if ((InsertQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
+      if ((InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
         queryNode = {
           ...queryNode,
           returning: ReturningNode3.create([
@@ -5246,34 +5690,49 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
         };
       }
       const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
-      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams, queryId);
+      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams);
       if (this.isMutationNode(queryNode)) {
-        await this.callAfterQueryInterceptionFilters(result, queryNode, mutationInterceptionInfo);
+        await this.callAfterMutationHooks(result.result, queryNode, mutationInterceptionInfo, result.connection);
       }
       if (oldQueryNode !== queryNode) {
       }
-      return result;
+      return result.result;
     }, "task");
     return task();
   }
-  proceedQueryWithKyselyInterceptors(queryNode, parameters, queryId) {
-    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters, queryId), "proceed");
-    const hooks = this.options.plugins?.filter((plugin) => typeof plugin.onKyselyQuery === "function").map((plugin) => plugin.onKyselyQuery.bind(plugin)) ?? [];
+  proceedQueryWithKyselyInterceptors(queryNode, parameters) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters), "proceed");
+    const hooks = [];
+    for (const plugin of this.client.$options.plugins ?? []) {
+      if (plugin.onKyselyQuery) {
+        hooks.push(plugin.onKyselyQuery.bind(plugin));
+      }
+    }
     for (const hook of hooks) {
       const _proceed = proceed;
-      proceed = /* @__PURE__ */ __name((query) => {
-        return hook({
+      proceed = /* @__PURE__ */ __name(async (query) => {
+        let connection;
+        const _p = /* @__PURE__ */ __name(async (q) => {
+          const r = await _proceed(q);
+          connection = r.connection;
+          return r.result;
+        }, "_p");
+        const hookResult = await hook({
           client: this.client,
           schema: this.client.$schema,
           kysely: this.kysely,
           query,
-          proceed: _proceed
+          proceed: _p
         });
+        return {
+          result: hookResult,
+          connection
+        };
       }, "proceed");
     }
     return proceed(queryNode);
   }
-  async proceedQuery(query, parameters, queryId) {
+  async proceedQuery(query, parameters) {
     const finalQuery = this.nameMapper.transformNode(query);
     let compiled = this.compileQuery(finalQuery);
     if (parameters) {
@@ -5283,7 +5742,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       };
     }
     try {
-      return await super.executeQuery(compiled, queryId);
+      return await this.provideConnection(async (connection) => {
+        const result = await connection.executeQuery(compiled);
+        return {
+          result,
+          connection
+        };
+      });
     } catch (err) {
       let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       if (this.options.debug) {
@@ -5386,10 +5851,11 @@ ${compiled.parameters.map((p) => inspect2(p)).join("\n")}`;
       return;
     }
     if (this.options.plugins) {
+      const mutationModel = this.getMutationModel(queryNode);
       for (const plugin of this.options.plugins) {
         if (plugin.beforeEntityMutation) {
           await plugin.beforeEntityMutation({
-            model: this.getMutationModel(queryNode),
+            model: mutationModel,
             action: mutationInterceptionInfo.action,
             queryNode,
             entities: mutationInterceptionInfo.beforeMutationEntities
@@ -5398,30 +5864,45 @@ ${compiled.parameters.map((p) => inspect2(p)).join("\n")}`;
       }
     }
   }
-  async callAfterQueryInterceptionFilters(queryResult, queryNode, mutationInterceptionInfo) {
+  async callAfterMutationHooks(queryResult, queryNode, mutationInterceptionInfo, connection) {
     if (!mutationInterceptionInfo?.intercept) {
       return;
     }
-    if (this.options.plugins) {
-      const mutationModel = this.getMutationModel(queryNode);
-      for (const plugin of this.options.plugins) {
-        if (plugin.afterEntityMutation) {
-          let afterMutationEntities = void 0;
-          if (mutationInterceptionInfo.loadAfterMutationEntity) {
-            if (UpdateQueryNode2.is(queryNode)) {
-              afterMutationEntities = await this.loadEntities(mutationModel, mutationInterceptionInfo.where);
-            } else {
-              afterMutationEntities = queryResult.rows;
-            }
-          }
-          await plugin.afterEntityMutation({
-            model: this.getMutationModel(queryNode),
+    const hooks = [];
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.afterEntityMutation) {
+        hooks.push(plugin.afterEntityMutation.bind(plugin));
+      }
+    }
+    if (hooks.length === 0) {
+      return;
+    }
+    const mutationModel = this.getMutationModel(queryNode);
+    const inTransaction = this.driver.isTransactionConnection(connection);
+    for (const hook of hooks) {
+      let afterMutationEntities = void 0;
+      if (mutationInterceptionInfo.loadAfterMutationEntity) {
+        if (InsertQueryNode2.is(queryNode) || UpdateQueryNode2.is(queryNode)) {
+          afterMutationEntities = queryResult.rows;
+        }
+      }
+      const action = /* @__PURE__ */ __name(async () => {
+        try {
+          await hook({
+            model: mutationModel,
             action: mutationInterceptionInfo.action,
             queryNode,
             beforeMutationEntities: mutationInterceptionInfo.beforeMutationEntities,
             afterMutationEntities
           });
+        } catch (err) {
+          console.error(`Error in afterEntityMutation hook for model "${mutationModel}": ${err}`);
         }
+      }, "action");
+      if (inTransaction) {
+        this.driver.registerTransactionCommitCallback(connection, action);
+      } else {
+        await action();
       }
     }
   }
@@ -5618,7 +6099,7 @@ var SchemaDbPusher = class {
       }
     }
     table = this.addPrimaryKeyConstraint(table, model, modelDef);
-    table = this.addUniqueConstraint(table, modelDef);
+    table = this.addUniqueConstraint(table, model, modelDef);
     return table;
   }
   isComputedField(fieldDef) {
@@ -5635,7 +6116,7 @@ var SchemaDbPusher = class {
     }
     return table;
   }
-  addUniqueConstraint(table, modelDef) {
+  addUniqueConstraint(table, model, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
       invariant10(typeof value === "object", "expecting an object");
       if ("type" in value) {
@@ -5643,8 +6124,11 @@ var SchemaDbPusher = class {
         if (fieldDef.unique) {
           continue;
         }
+        table = table.addUniqueConstraint(`unique_${model}_${key}`, [
+          key
+        ]);
       } else {
-        table = table.addUniqueConstraint(`unique_${key}`, Object.keys(value));
+        table = table.addUniqueConstraint(`unique_${model}_${key}`, Object.keys(value));
       }
     }
     return table;
@@ -5787,6 +6271,21 @@ var ResultProcessor = class {
         data[key] = typeof value === "string" ? JSON.parse(value) : value;
         continue;
       }
+      if (key.startsWith(DELEGATE_JOINED_FIELD_PREFIX)) {
+        if (value) {
+          const subRow = this.transformJson(value);
+          const subModel = key.slice(DELEGATE_JOINED_FIELD_PREFIX.length);
+          const idValues = getIdValues(this.schema, subModel, subRow);
+          if (Object.values(idValues).some((v) => v === null || v === void 0)) {
+            delete data[key];
+            continue;
+          }
+          const processedSubRow = this.processRow(subRow, subModel);
+          Object.assign(data, processedSubRow);
+        }
+        delete data[key];
+        continue;
+      }
       const fieldDef = getField(this.schema, model, key);
       if (!fieldDef) {
         continue;
@@ -5826,7 +6325,11 @@ var ResultProcessor = class {
     return this.doProcessResult(relationData, fieldDef.type);
   }
   transformScalar(value, type) {
-    return match18(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.transformJson(value);
+    } else {
+      return match18(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
+    }
   }
   transformDecimal(value) {
     if (value instanceof Decimal2) {
@@ -6038,19 +6541,26 @@ var ClientImpl = class _ClientImpl {
     await new SchemaDbPusher(this.schema, this.kysely).push();
   }
   $use(plugin) {
+    const newPlugins = [
+      ...this.$options.plugins ?? [],
+      plugin
+    ];
     const newOptions = {
       ...this.options,
-      plugins: [
-        ...this.options.plugins ?? [],
-        plugin
-      ]
+      plugins: newPlugins
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }
   $unuse(pluginId) {
+    const newPlugins = [];
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.id !== pluginId) {
+        newPlugins.push(plugin);
+      }
+    }
     const newOptions = {
       ...this.options,
-      plugins: this.options.plugins?.filter((p) => p.id !== pluginId)
+      plugins: newPlugins
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }