@zenstackhq/runtime 3.0.0-alpha.11 → 3.0.0-alpha.13

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 {
@@ -2507,7 +2641,7 @@ var BaseOperationHandler = class {
     return query.executeTakeFirst();
   }
   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) {
@@ -2711,9 +2844,13 @@ ${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"
     }));
@@ -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,6 +3074,13 @@ ${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"
@@ -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,9 +3260,7 @@ ${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({
@@ -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,25 +3364,43 @@ ${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,
@@ -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 = [];
@@ -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 query.executeTakeFirstOrThrow();
+    return {
+      count: Number(result.numDeletedRows)
+    };
+  }
+  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);
     }
   }
@@ -3622,7 +3935,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;
@@ -3715,13 +4043,23 @@ 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)));
+      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)));
       return query.executeTakeFirstOrThrow();
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
@@ -3805,15 +4143,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, void 0);
+      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;
+    });
   }
 };
 
@@ -3954,22 +4296,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 +4463,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 +4623,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 +4835,9 @@ var InputValidator = class {
       if (fieldDef.computed) {
         return;
       }
+      if (this.isDelegateDiscriminator(fieldDef)) {
+        return;
+      }
       if (fieldDef.relation) {
         if (withoutRelationFields) {
           return;
@@ -4518,6 +4910,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;
@@ -5201,7 +5600,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;
   }
 };
@@ -5618,7 +6017,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 +6034,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 +6042,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 +6189,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 +6243,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) {