@zenstackhq/orm 3.5.0-beta.2 → 3.5.0-beta.4

package/dist/index.js

@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
 // src/client/client-impl.ts
-import { invariant as invariant14, lowerCaseFirst as lowerCaseFirst3 } from "@zenstackhq/common-helpers";
+import { invariant as invariant14, lowerCaseFirst as lowerCaseFirst4 } from "@zenstackhq/common-helpers";
 import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql8, Transaction } from "kysely";
 import z2 from "zod";
 
@@ -30,7 +30,7 @@ function formatError(error) {
 __name(formatError, "formatError");
 
 // src/client/crud/operations/aggregate.ts
-import { match as match8 } from "ts-pattern";
+import { match as match5 } from "ts-pattern";
 
 // src/client/query-utils.ts
 var query_utils_exports = {};
@@ -63,6 +63,7 @@ __export(query_utils_exports, {
   isRelationField: () => isRelationField,
   isScalarField: () => isScalarField,
   isTypeDef: () => isTypeDef,
+  isUnsupportedField: () => isUnsupportedField,
   makeDefaultOrderBy: () => makeDefaultOrderBy,
   requireField: () => requireField,
   requireIdFields: () => requireIdFields,
@@ -264,10 +265,17 @@ function getModelFields(schema, model, options) {
     if (f.originModel && !options?.inherited) {
       return false;
     }
+    if (f.type === "Unsupported" && !options?.unsupported) {
+      return false;
+    }
     return true;
   });
 }
 __name(getModelFields, "getModelFields");
+function isUnsupportedField(fieldDef) {
+  return fieldDef.type === "Unsupported";
+}
+__name(isUnsupportedField, "isUnsupportedField");
 function getIdFields(schema, model) {
   const modelDef = getModel(schema, model);
   return modelDef?.idFields;
@@ -601,7 +609,7 @@ import { clone, enumerate as enumerate2, invariant as invariant7, isPlainObject
 import { default as cuid1 } from "cuid";
 import { createQueryId, expressionBuilder as expressionBuilder5, sql as sql5 } from "kysely";
 import { nanoid } from "nanoid";
-import { match as match7 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 import { ulid } from "ulid";
 import * as uuid from "uuid";
 
@@ -684,13 +692,12 @@ var CRUD_EXT = [
 ];
 
 // src/client/crud/dialects/index.ts
-import { match as match6 } from "ts-pattern";
+import { match as match3 } from "ts-pattern";
 
 // src/client/crud/dialects/mysql.ts
 import { invariant as invariant4 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
 import { expressionBuilder as expressionBuilder2, ExpressionWrapper, sql as sql2, ValueListNode } from "kysely";
-import { match as match3 } from "ts-pattern";
 
 // src/common-types.ts
 var DbNullClass = class {
@@ -722,7 +729,7 @@ var AnyNull = new AnyNullClass();
 import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 
 // src/client/crud/dialects/base-dialect.ts
-import { enumerate, invariant as invariant2, isPlainObject } from "@zenstackhq/common-helpers";
+import { enumerate, invariant as invariant2, isPlainObject, lowerCaseFirst } from "@zenstackhq/common-helpers";
 import { expressionBuilder, sql } from "kysely";
 import { match as match2, P } from "ts-pattern";
 var BaseCrudDialect = class {
@@ -1405,27 +1412,28 @@ var BaseCrudDialect = class {
     return result;
   }
   buildSelectAllFields(model, query, omit, modelAlias) {
-    const modelDef = requireModel(this.schema, model);
     let result = query;
-    for (const field of Object.keys(modelDef.fields)) {
-      if (isRelationField(this.schema, model, field)) {
+    for (const fieldDef of getModelFields(this.schema, model, {
+      inherited: true,
+      computed: true
+    })) {
+      if (this.shouldOmitField(omit, model, fieldDef.name)) {
         continue;
       }
-      if (this.shouldOmitField(omit, model, field)) {
-        continue;
-      }
-      result = this.buildSelectField(result, model, modelAlias, field);
+      result = this.buildSelectField(result, model, modelAlias, fieldDef.name);
     }
     const descendants = getDelegateDescendantModels(this.schema, model);
     for (const subModel of descendants) {
       result = this.buildDelegateJoin(model, modelAlias, subModel.name, result);
-      result = result.select((eb) => {
+      result = result.select(() => {
         const jsonObject = {};
-        for (const field of Object.keys(subModel.fields)) {
-          if (isRelationField(this.schema, subModel.name, field) || isInheritedField(this.schema, subModel.name, field)) {
+        for (const fieldDef of getModelFields(this.schema, subModel.name, {
+          computed: true
+        })) {
+          if (this.shouldOmitField(omit, subModel.name, fieldDef.name)) {
             continue;
           }
-          jsonObject[field] = eb.ref(`${subModel.name}.${field}`);
+          jsonObject[fieldDef.name] = this.fieldRef(subModel.name, fieldDef.name, subModel.name);
         }
         return this.buildJsonObject(jsonObject).as(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`);
       });
@@ -1436,8 +1444,10 @@ var BaseCrudDialect = class {
     if (omit && typeof omit === "object" && typeof omit[field] === "boolean") {
       return omit[field];
     }
-    if (this.options.omit?.[model] && typeof this.options.omit[model] === "object" && typeof this.options.omit[model][field] === "boolean") {
-      return this.options.omit[model][field];
+    const uncapModel = lowerCaseFirst(model);
+    const omitConfig = this.options.omit?.[uncapModel] ?? this.options.omit?.[model];
+    if (omitConfig && typeof omitConfig === "object" && typeof omitConfig[field] === "boolean") {
+      return omitConfig[field];
     }
     const fieldDef = requireField(this.schema, model, field);
     return !!fieldDef.omit;
@@ -1555,7 +1565,8 @@ var BaseCrudDialect = class {
       let computer;
       if ("computedFields" in this.options) {
         const computedFields = this.options.computedFields;
-        computer = computedFields?.[fieldDef.originModel ?? model]?.[field];
+        const computedModel = fieldDef.originModel ?? model;
+        computer = computedFields?.[lowerCaseFirst(computedModel)]?.[field] ?? computedFields?.[computedModel]?.[field];
       }
       if (!computer) {
         throw createConfigError(`Computed field "${field}" implementation not provided for model "${model}"`);
@@ -1758,24 +1769,46 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
         throw createNotSupportedError(`MySQL does not support array literals`);
       }
     } else {
-      return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => {
-        if (value instanceof Date) {
-          return value.toISOString().replace("Z", "+00:00");
-        } else if (typeof value === "string") {
-          return new Date(value).toISOString().replace("Z", "+00:00");
-        } else {
+      switch (type) {
+        case "Boolean":
+          return value ? 1 : 0;
+        case "DateTime":
+          if (value instanceof Date) {
+            return value.toISOString().replace("Z", "+00:00");
+          } else if (typeof value === "string") {
+            return new Date(value).toISOString().replace("Z", "+00:00");
+          } else {
+            return value;
+          }
+        case "Decimal":
+          return value !== null ? value.toString() : value;
+        case "Json":
+          return this.eb.cast(this.eb.val(JSON.stringify(value)), "json");
+        case "Bytes":
+          return Buffer.isBuffer(value) ? value : value instanceof Uint8Array ? Buffer.from(value) : value;
+        default:
           return value;
-        }
-      }).with("Decimal", () => value !== null ? value.toString() : value).with("Json", () => {
-        return this.eb.cast(this.eb.val(JSON.stringify(value)), "json");
-      }).with("Bytes", () => Buffer.isBuffer(value) ? value : value instanceof Uint8Array ? Buffer.from(value) : value).otherwise(() => value);
+      }
     }
   }
   transformOutput(value, type, array) {
     if (value === null || value === void 0) {
       return value;
     }
-    return match3(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).otherwise(() => super.transformOutput(value, type, array));
+    switch (type) {
+      case "Boolean":
+        return this.transformOutputBoolean(value);
+      case "DateTime":
+        return this.transformOutputDate(value);
+      case "Bytes":
+        return this.transformOutputBytes(value);
+      case "BigInt":
+        return this.transformOutputBigInt(value);
+      case "Decimal":
+        return this.transformDecimal(value);
+      default:
+        return super.transformOutput(value, type, array);
+    }
   }
   transformOutputBoolean(value) {
     return !!value;
@@ -1881,15 +1914,25 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return match3(operation).with("array_contains", () => {
-      const v = Array.isArray(value) ? value : [
-        value
-      ];
-      return sql2`JSON_CONTAINS(${lhs}, ${sql2.val(JSON.stringify(v))})`;
-    }).with("array_starts_with", () => this.eb(this.eb.fn("JSON_EXTRACT", [
-      lhs,
-      this.eb.val("$[0]")
-    ]), "=", this.transformInput(value, "Json", false))).with("array_ends_with", () => this.eb(sql2`JSON_EXTRACT(${lhs}, CONCAT('$[', JSON_LENGTH(${lhs}) - 1, ']'))`, "=", this.transformInput(value, "Json", false))).exhaustive();
+    switch (operation) {
+      case "array_contains": {
+        const v = Array.isArray(value) ? value : [
+          value
+        ];
+        return sql2`JSON_CONTAINS(${lhs}, ${sql2.val(JSON.stringify(v))})`;
+      }
+      case "array_starts_with": {
+        return this.eb(this.eb.fn("JSON_EXTRACT", [
+          lhs,
+          this.eb.val("$[0]")
+        ]), "=", this.transformInput(value, "Json", false));
+      }
+      case "array_ends_with": {
+        return this.eb(sql2`JSON_EXTRACT(${lhs}, CONCAT('$[', JSON_LENGTH(${lhs}) - 1, ']'))`, "=", this.transformInput(value, "Json", false));
+      }
+      default:
+        throw createInvalidInputError(`Unsupported array filter operation: ${operation}`);
+    }
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(sql2`JSON_TABLE(${receiver}, '$[*]' COLUMNS(value JSON PATH '$'))`.as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
@@ -1932,12 +1975,22 @@ import { invariant as invariant5 } from "@zenstackhq/common-helpers";
 import Decimal2 from "decimal.js";
 import { expressionBuilder as expressionBuilder3, sql as sql3 } from "kysely";
 import { parse as parsePostgresArray } from "postgres-array";
-import { match as match4 } from "ts-pattern";
 var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectBase {
   static {
     __name(this, "PostgresCrudDialect");
   }
   static typeParserOverrideApplied = false;
+  zmodelToSqlTypeMap = {
+    String: "text",
+    Boolean: "boolean",
+    Int: "integer",
+    BigInt: "bigint",
+    Float: "double precision",
+    Decimal: "decimal",
+    DateTime: "timestamp",
+    Bytes: "bytea",
+    Json: "jsonb"
+  };
   constructor(schema, options) {
     super(schema, options);
     this.overrideTypeParsers();
@@ -1948,19 +2001,31 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
   overrideTypeParsers() {
     if (this.options.fixPostgresTimezone !== false && !_PostgresCrudDialect.typeParserOverrideApplied) {
       _PostgresCrudDialect.typeParserOverrideApplied = true;
+      const fixTimezone = /* @__PURE__ */ __name((value) => {
+        if (typeof value !== "string") {
+          return value;
+        }
+        if (!this.hasTimezoneOffset(value)) {
+          value += "Z";
+        }
+        const result = new Date(value);
+        return isNaN(result.getTime()) ? value : result;
+      }, "fixTimezone");
       import(
         /* webpackIgnore: true */
         "pg"
       ).then((pg) => {
-        pg.types.setTypeParser(pg.types.builtins.TIMESTAMP, (value) => {
+        pg.types.setTypeParser(pg.types.builtins.TIMESTAMP, fixTimezone);
+        pg.types.setTypeParser(1115, (value) => {
           if (typeof value !== "string") {
             return value;
           }
-          if (!this.hasTimezoneOffset(value)) {
-            value += "Z";
+          try {
+            const arr = parsePostgresArray(value);
+            return arr.map(fixTimezone);
+          } catch {
+            return value;
           }
-          const result = new Date(value);
-          return isNaN(result.getTime()) ? value : result;
         });
       }).catch(() => {
       });
@@ -2014,20 +2079,42 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
         return value.map((v) => this.transformInput(v, type, false));
       }
     } else {
-      return match4(type).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value !== null ? value.toString() : value).with("Json", () => {
-        if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-          return JSON.stringify(value);
-        } else {
+      switch (type) {
+        case "DateTime":
+          return value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value;
+        case "Decimal":
+          return value !== null ? value.toString() : value;
+        case "Json":
+          if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            return JSON.stringify(value);
+          } else {
+            return value;
+          }
+        default:
           return value;
-        }
-      }).otherwise(() => value);
+      }
     }
   }
   transformOutput(value, type, array) {
     if (value === null || value === void 0) {
       return value;
     }
-    return match4(type).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).when((type2) => isEnum(this.schema, type2), () => this.transformOutputEnum(value, array)).otherwise(() => super.transformOutput(value, type, array));
+    switch (type) {
+      case "DateTime":
+        return this.transformOutputDate(value);
+      case "Bytes":
+        return this.transformOutputBytes(value);
+      case "BigInt":
+        return this.transformOutputBigInt(value);
+      case "Decimal":
+        return this.transformDecimal(value);
+      default:
+        if (isEnum(this.schema, type)) {
+          return this.transformOutputEnum(value, array);
+        } else {
+          return super.transformOutput(value, type, array);
+        }
+    }
   }
   transformOutputBigInt(value) {
     if (typeof value === "bigint") {
@@ -2136,18 +2223,24 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return match4(operation).with("array_contains", () => {
-      const v = Array.isArray(value) ? value : [
-        value
-      ];
-      return sql3`${lhs} @> ${sql3.val(JSON.stringify(v))}::jsonb`;
-    }).with("array_starts_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
-      lhs,
-      this.eb.val("0")
-    ]), "=", this.transformInput(value, "Json", false))).with("array_ends_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
-      lhs,
-      sql3`(jsonb_array_length(${lhs}) - 1)::text`
-    ]), "=", this.transformInput(value, "Json", false))).exhaustive();
+    switch (operation) {
+      case "array_contains": {
+        const v = Array.isArray(value) ? value : [
+          value
+        ];
+        return sql3`${lhs} @> ${sql3.val(JSON.stringify(v))}::jsonb`;
+      }
+      case "array_starts_with":
+        return this.eb(this.eb.fn("jsonb_extract_path", [
+          lhs,
+          this.eb.val("0")
+        ]), "=", this.transformInput(value, "Json", false));
+      case "array_ends_with":
+        return this.eb(this.eb.fn("jsonb_extract_path", [
+          lhs,
+          sql3`(jsonb_array_length(${lhs}) - 1)::text`
+        ]), "=", this.transformInput(value, "Json", false));
+    }
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(this.eb.fn("jsonb_array_elements", [
@@ -2158,7 +2251,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     if (isEnum(this.schema, zmodelType)) {
       return "text";
     } else {
-      return match4(zmodelType).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
+      return this.zmodelToSqlTypeMap[zmodelType] ?? "text";
     }
   }
   getStringCasingBehavior() {
@@ -2200,7 +2293,6 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import Decimal3 from "decimal.js";
 import { expressionBuilder as expressionBuilder4, ExpressionWrapper as ExpressionWrapper2, sql as sql4, ValueListNode as ValueListNode2 } from "kysely";
-import { match as match5 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -2249,7 +2341,18 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (Array.isArray(value)) {
       return value.map((v) => this.transformInput(v, type, false));
     } else {
-      return match5(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
+      switch (type) {
+        case "Boolean":
+          return value ? 1 : 0;
+        case "DateTime":
+          return value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value;
+        case "Decimal":
+          return value.toString();
+        case "Bytes":
+          return Buffer.from(value);
+        default:
+          return value;
+      }
     }
   }
   transformOutput(value, type, array) {
@@ -2258,7 +2361,22 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     } else if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.transformOutputJson(value);
     } else {
-      return match5(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("Decimal", () => this.transformOutputDecimal(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Json", () => this.transformOutputJson(value)).otherwise(() => super.transformOutput(value, type, array));
+      switch (type) {
+        case "Boolean":
+          return this.transformOutputBoolean(value);
+        case "DateTime":
+          return this.transformOutputDate(value);
+        case "Bytes":
+          return this.transformOutputBytes(value);
+        case "Decimal":
+          return this.transformOutputDecimal(value);
+        case "BigInt":
+          return this.transformOutputBigInt(value);
+        case "Json":
+          return this.transformOutputJson(value);
+        default:
+          return super.transformOutput(value, type, array);
+      }
     }
   }
   transformOutputDecimal(value) {
@@ -2429,16 +2547,21 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return match5(operation).with("array_contains", () => {
-      if (Array.isArray(value)) {
-        throw createNotSupportedError('SQLite "array_contains" only supports checking for a single value, not an array of values');
-      } else {
-        return sql4`EXISTS (SELECT 1 FROM json_each(${lhs}) WHERE value = ${value})`;
-      }
-    }).with("array_starts_with", () => this.eb(this.eb.fn("json_extract", [
-      lhs,
-      this.eb.val("$[0]")
-    ]), "=", value)).with("array_ends_with", () => this.eb(sql4`json_extract(${lhs}, '$[' || (json_array_length(${lhs}) - 1) || ']')`, "=", value)).exhaustive();
+    switch (operation) {
+      case "array_contains":
+        if (Array.isArray(value)) {
+          throw createNotSupportedError('SQLite "array_contains" only supports checking for a single value, not an array of values');
+        } else {
+          return sql4`EXISTS (SELECT 1 FROM json_each(${lhs}) WHERE value = ${value})`;
+        }
+      case "array_starts_with":
+        return this.eb(this.eb.fn("json_extract", [
+          lhs,
+          this.eb.val("$[0]")
+        ]), "=", value);
+      case "array_ends_with":
+        return this.eb(sql4`json_extract(${lhs}, '$[' || (json_array_length(${lhs}) - 1) || ']')`, "=", value);
+    }
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(this.eb.fn("json_each", [
@@ -2507,7 +2630,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return match6(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).with("mysql", () => new MySqlCrudDialect(schema, options)).exhaustive();
+  return match3(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).with("mysql", () => new MySqlCrudDialect(schema, options)).exhaustive();
 }
 __name(getCrudDialect, "getCrudDialect");
 
@@ -2793,7 +2916,9 @@ var BaseOperationHandler = class {
       }
     }
     if (fromRelation && m2m) {
-      await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, createdEntity, m2m.joinTable);
+      await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, [
+        createdEntity
+      ], m2m.joinTable);
     }
     if (updateParent) {
       updateParent(createdEntity);
@@ -2850,41 +2975,36 @@ var BaseOperationHandler = class {
     }
     return parentFkFields;
   }
-  async handleManyToManyRelation(kysely, action, leftModel, leftField, leftEntity, rightModel, rightField, rightEntity, joinTable) {
-    const sortedRecords = [
-      {
-        model: leftModel,
-        field: leftField,
-        entity: leftEntity
-      },
-      {
-        model: rightModel,
-        field: rightField,
-        entity: rightEntity
-      }
-    ].sort((a, b) => (
-      // the implicit m2m join table's "A", "B" fk fields' order is determined
-      // by model name's sort order, and when identical (for self-relations),
-      // field name's sort order
-      a.model !== b.model ? a.model.localeCompare(b.model) : a.field.localeCompare(b.field)
-    ));
-    const firstIds = requireIdFields(this.schema, sortedRecords[0].model);
-    const secondIds = requireIdFields(this.schema, sortedRecords[1].model);
-    invariant7(firstIds.length === 1, "many-to-many relation must have exactly one id field");
-    invariant7(secondIds.length === 1, "many-to-many relation must have exactly one id field");
+  async handleManyToManyRelation(kysely, action, leftModel, leftField, leftEntity, rightModel, rightField, rightEntities, joinTable) {
+    if (rightEntities.length === 0) {
+      return;
+    }
+    const leftFirst = leftModel !== rightModel ? leftModel.localeCompare(rightModel) <= 0 : leftField.localeCompare(rightField) <= 0;
+    const leftIdField = requireIdFields(this.schema, leftModel);
+    const rightIdField = requireIdFields(this.schema, rightModel);
+    invariant7(leftIdField.length === 1, "many-to-many relation must have exactly one id field");
+    invariant7(rightIdField.length === 1, "many-to-many relation must have exactly one id field");
+    const leftIdValue = leftEntity[leftIdField[0]];
+    const rightIdValues = rightEntities.map((e) => e[rightIdField[0]]);
     if (action === "connect") {
-      const result = await kysely.insertInto(joinTable).values({
-        A: sortedRecords[0].entity[firstIds[0]],
-        B: sortedRecords[1].entity[secondIds[0]]
-      }).$if(this.dialect.insertIgnoreMethod === "onConflict", (qb) => qb.onConflict((oc) => oc.columns([
+      const values = rightIdValues.map((rightId) => ({
+        A: leftFirst ? leftIdValue : rightId,
+        B: leftFirst ? rightId : leftIdValue
+      }));
+      await kysely.insertInto(joinTable).values(values).$if(this.dialect.insertIgnoreMethod === "onConflict", (qb) => qb.onConflict((oc) => oc.columns([
         "A",
         "B"
       ]).doNothing())).$if(this.dialect.insertIgnoreMethod === "ignore", (qb) => qb.ignore()).execute();
-      return result[0];
     } else {
       const eb = expressionBuilder5();
-      const result = await kysely.deleteFrom(joinTable).where(eb(`${joinTable}.A`, "=", sortedRecords[0].entity[firstIds[0]])).where(eb(`${joinTable}.B`, "=", sortedRecords[1].entity[secondIds[0]])).execute();
-      return result[0];
+      const [leftCol, rightCol] = leftFirst ? [
+        "A",
+        "B"
+      ] : [
+        "B",
+        "A"
+      ];
+      await kysely.deleteFrom(joinTable).where(eb(`${joinTable}.${leftCol}`, "=", leftIdValue)).where(eb(`${joinTable}.${rightCol}`, "in", rightIdValues)).execute();
     }
   }
   resetManyToManyRelation(kysely, model, field, parentIds) {
@@ -3142,7 +3262,7 @@ var BaseOperationHandler = class {
   evalGenerator(defaultValue) {
     if (schema_exports.ExpressionUtils.isCall(defaultValue)) {
       const firstArgVal = defaultValue.args?.[0] && schema_exports.ExpressionUtils.isLiteral(defaultValue.args[0]) ? defaultValue.args[0].value : void 0;
-      return match7(defaultValue.function).with("cuid", () => {
+      return match4(defaultValue.function).with("cuid", () => {
         const version = firstArgVal;
         const generated = version === 2 ? cuid2() : cuid1();
         return this.formatGeneratedValue(generated, defaultValue.args?.[1]);
@@ -3171,6 +3291,13 @@ var BaseOperationHandler = class {
     }
     return formatExpr.value.replace(/(?<!\\)%s/g, generated).replace(/\\%s/g, "%s");
   }
+  /**
+   * @returns
+   * - throw if `throwIfNotFound` is true and the entity to update is not found
+   * - otherwise, null if the entity to update is not found
+   * - if found and `fieldsToReturn` is specified, return the post-update fields
+   * - if found and `fieldsToReturn` is not specified, return true (indicating success)
+   */
   async update(kysely, model, where, data, fromRelation, allowRelationUpdate = true, throwIfNotFound = true, fieldsToReturn) {
     if (!data || typeof data !== "object") {
       throw createInvalidInputError("data must be an object");
@@ -3185,6 +3312,7 @@ var BaseOperationHandler = class {
         ]
       } : parentWhere;
     }
+    const origWhere = combinedWhere;
     const modelDef = this.requireModel(model);
     let finalData = data;
     const autoUpdatedFields = [];
@@ -3201,46 +3329,51 @@ var BaseOperationHandler = class {
         }
       }
     }
-    const thisEntity = await this.getEntityIds(kysely, model, combinedWhere);
-    if (!thisEntity) {
-      if (throwIfNotFound) {
-        throw createNotFoundError(model);
-      } else {
-        return null;
+    let thisEntity;
+    const loadThisEntity = /* @__PURE__ */ __name(async () => {
+      if (thisEntity === void 0) {
+        thisEntity = await this.getEntityIds(kysely, model, origWhere) ?? null;
+        if (!thisEntity && throwIfNotFound) {
+          throw createNotFoundError(model);
+        }
       }
-    }
-    if (Object.keys(finalData).length === 0) {
       return thisEntity;
-    }
-    let needIdRead = false;
-    if (!this.isIdFilter(model, combinedWhere)) {
-      if (modelDef.baseModel) {
-        needIdRead = true;
-      }
-      if (!this.dialect.supportsReturning) {
-        needIdRead = true;
-      }
-    }
-    if (needIdRead) {
-      const readResult = await this.readUnique(kysely, model, {
-        where: combinedWhere,
-        select: this.makeIdSelect(model)
-      });
-      if (!readResult && throwIfNotFound) {
-        throw createNotFoundError(model);
+    }, "loadThisEntity");
+    if (Object.keys(finalData).length === 0) {
+      return loadThisEntity();
+    }
+    if (
+      // when updating a model with delegate base, base fields may be referenced in the filter,
+      // so we read the id out if the filter and and use it as the update filter instead
+      modelDef.baseModel || // for dialects that don't support RETURNING, we need to read the id fields
+      // to identify the updated entity for toplevel updates
+      !this.dialect.supportsReturning && !fromRelation
+    ) {
+      combinedWhere = await loadThisEntity();
+      if (!combinedWhere) {
+        return null;
       }
-      combinedWhere = readResult;
     }
     if (modelDef.baseModel) {
       const baseUpdateResult = await this.processBaseModelUpdate(kysely, modelDef.baseModel, combinedWhere, finalData, throwIfNotFound);
+      if (!baseUpdateResult.baseEntity) {
+        if (throwIfNotFound) {
+          throw createNotFoundError(model);
+        } else {
+          return null;
+        }
+      }
       finalData = baseUpdateResult.remainingFields;
-      combinedWhere = baseUpdateResult.baseEntity ? getIdValues(this.schema, modelDef.baseModel, baseUpdateResult.baseEntity) : baseUpdateResult.baseEntity;
-      if (baseUpdateResult.baseEntity) {
+      combinedWhere = getIdValues(this.schema, modelDef.baseModel, baseUpdateResult.baseEntity);
+      await loadThisEntity();
+      if (thisEntity) {
         for (const [key, value] of Object.entries(baseUpdateResult.baseEntity)) {
           if (key in thisEntity) {
             thisEntity[key] = value;
           }
         }
+      } else {
+        return null;
       }
     }
     const updateFields = {};
@@ -3252,7 +3385,11 @@ var BaseOperationHandler = class {
         if (!allowRelationUpdate) {
           throw createNotSupportedError(`Relation update not allowed for field "${field}"`);
         }
-        const parentUpdates = await this.processRelationUpdates(kysely, model, field, fieldDef, thisEntity, finalData[field]);
+        const relationParent = await loadThisEntity();
+        if (!relationParent) {
+          return null;
+        }
+        const parentUpdates = await this.processRelationUpdates(kysely, model, field, fieldDef, relationParent, finalData[field]);
         if (Object.keys(parentUpdates).length > 0) {
           Object.assign(updateFields, parentUpdates);
         }
@@ -3263,17 +3400,41 @@ var BaseOperationHandler = class {
       hasFieldUpdate = Object.keys(updateFields).some((f) => !autoUpdatedFields.includes(f));
     }
     if (!hasFieldUpdate) {
-      return thisEntity;
+      return loadThisEntity();
     } else {
-      fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
       let updatedEntity;
       if (this.dialect.supportsReturning) {
-        const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).returning(fieldsToReturn).modifyEnd(this.makeContextComment({
+        const returnFields = fieldsToReturn !== void 0 && fieldsToReturn.length > 0;
+        const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).$if(returnFields, (qb) => qb.returning(fieldsToReturn)).modifyEnd(this.makeContextComment({
           model,
           operation: "update"
         }));
-        updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
+        if (returnFields) {
+          updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
+        } else {
+          const r = await this.executeQuery(kysely, query, "update");
+          if (!r.numAffectedRows) {
+            updatedEntity = null;
+          } else {
+            updatedEntity = true;
+          }
+        }
       } else {
+        let readFilter = combinedWhere;
+        const idFields = requireIdFields(this.schema, model);
+        const updatingIdFields = idFields.some((idField) => idField in updateFields);
+        if (updatingIdFields) {
+          const origIdValues = await loadThisEntity();
+          invariant7(origIdValues, "Original entity should have been loaded for update without RETURNING");
+          readFilter = {
+            ...origIdValues
+          };
+          for (const idField of idFields) {
+            if (idField in updateFields && updateFields[idField] !== void 0) {
+              readFilter[idField] = updateFields[idField];
+            }
+          }
+        }
         const updateQuery = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).modifyEnd(this.makeContextComment({
           model,
           operation: "update"
@@ -3281,26 +3442,12 @@ var BaseOperationHandler = class {
         const updateResult = await this.executeQuery(kysely, updateQuery, "update");
         if (!updateResult.numAffectedRows) {
           updatedEntity = null;
+        } else if (fieldsToReturn === void 0 || fieldsToReturn.length === 0) {
+          updatedEntity = true;
         } else {
-          const idFields = requireIdFields(this.schema, model);
-          const filterIdValues = {};
-          for (const key of idFields) {
-            if (combinedWhere[key] !== void 0 && typeof combinedWhere[key] !== "object") {
-              filterIdValues[key] = combinedWhere[key];
-            }
-          }
-          const updatingIdFields = idFields.some((idField) => idField in updateFields);
-          if (Object.keys(filterIdValues).length === idFields.length && !updatingIdFields) {
-            updatedEntity = filterIdValues;
+          if (!updatingIdFields) {
+            updatedEntity = await loadThisEntity();
           } else {
-            const readFilter = {
-              ...combinedWhere
-            };
-            for (const idField of idFields) {
-              if (idField in updateFields && updateFields[idField] !== void 0) {
-                readFilter[idField] = updateFields[idField];
-              }
-            }
             const selectQuery = kysely.selectFrom(model).select(fieldsToReturn).where(() => this.dialect.buildFilter(model, model, readFilter));
             updatedEntity = await this.executeQueryTakeFirst(kysely, selectQuery, "update");
           }
@@ -3370,13 +3517,6 @@ var BaseOperationHandler = class {
       "set"
     ].some((key) => key in value);
   }
-  isIdFilter(model, filter) {
-    if (!filter || typeof filter !== "object") {
-      return false;
-    }
-    const idFields = requireIdFields(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 = {};
@@ -3388,7 +3528,7 @@ var BaseOperationHandler = class {
         remainingFields[field] = value;
       }
     });
-    const baseEntity = await this.update(kysely, model, where, thisUpdateFields, void 0, void 0, throwIfNotFound);
+    const baseEntity = await this.update(kysely, model, where, thisUpdateFields, void 0, void 0, throwIfNotFound, requireIdFields(this.schema, model));
     return {
       baseEntity,
       remainingFields
@@ -3400,7 +3540,7 @@ var BaseOperationHandler = class {
     const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
     const eb = expressionBuilder5();
     const fieldRef = this.dialect.fieldRef(model, field);
-    return match7(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
+    return match4(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
       throw createInvalidInputError(`Invalid incremental update operation: ${key}`);
     });
   }
@@ -3410,7 +3550,7 @@ var BaseOperationHandler = class {
     const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
     const eb = expressionBuilder5();
     const fieldRef = this.dialect.fieldRef(model, field);
-    return match7(key).with("set", () => value).with("push", () => {
+    return match4(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw createInvalidInputError(`Invalid array update operation: ${key}`);
@@ -3650,18 +3790,11 @@ var BaseOperationHandler = class {
     }
     const m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
     if (m2m) {
-      const results = [];
-      for (const d of _data) {
-        const ids = await this.getEntityIds(kysely, model, d);
-        if (!ids) {
-          throw createNotFoundError(model);
-        }
-        const r = await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, ids, m2m.joinTable);
-        results.push(r);
-      }
-      if (_data.length > results.filter((r) => !!r).length) {
+      const allIds = await this.getEntitiesIds(kysely, model, _data);
+      if (allIds.length !== _data.length) {
         throw createNotFoundError(model);
       }
+      await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, allIds, m2m.joinTable);
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
@@ -3738,12 +3871,9 @@ var BaseOperationHandler = class {
     }
     const m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
     if (m2m) {
-      for (const d of disconnectConditions) {
-        const ids = await this.getEntityIds(kysely, model, d);
-        if (!ids) {
-          return;
-        }
-        await this.handleManyToManyRelation(kysely, "disconnect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, ids, m2m.joinTable);
+      const allIds = await this.getEntitiesIds(kysely, model, disconnectConditions);
+      if (allIds.length > 0) {
+        await this.handleManyToManyRelation(kysely, "disconnect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, allIds, m2m.joinTable);
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
@@ -3808,16 +3938,12 @@ var BaseOperationHandler = class {
     const m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
     if (m2m) {
       await this.resetManyToManyRelation(kysely, fromRelation.model, fromRelation.field, fromRelation.ids);
-      const results = [];
-      for (const d of _data) {
-        const ids = await this.getEntityIds(kysely, model, d);
-        if (!ids) {
+      if (_data.length > 0) {
+        const allIds = await this.getEntitiesIds(kysely, model, _data);
+        if (allIds.length !== _data.length) {
           throw createNotFoundError(model);
         }
-        results.push(await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, ids, m2m.joinTable));
-      }
-      if (_data.length > results.filter((r) => !!r).length) {
-        throw createNotFoundError(model);
+        await this.handleManyToManyRelation(kysely, "connect", fromRelation.model, fromRelation.field, fromRelation.ids, m2m.otherModel, m2m.otherField, allIds, m2m.joinTable);
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
@@ -4029,6 +4155,13 @@ var BaseOperationHandler = class {
       return txBuilder.execute(callback);
     }
   }
+  async safeTransactionIf(condition, callback, isolationLevel) {
+    if (condition) {
+      return this.safeTransaction(callback, isolationLevel);
+    } else {
+      return callback(this.kysely);
+    }
+  }
   // Given a unique filter of a model, load the entity and return its id fields
   getEntityIds(kysely, model, uniqueFilter) {
     return this.readUnique(kysely, model, {
@@ -4036,6 +4169,15 @@ var BaseOperationHandler = class {
       select: this.makeIdSelect(model)
     });
   }
+  // Given multiple unique filters, load all matching entities and return their id fields in one query
+  getEntitiesIds(kysely, model, uniqueFilters) {
+    return this.read(kysely, model, {
+      where: {
+        OR: uniqueFilters
+      },
+      select: this.makeIdSelect(model)
+    });
+  }
   /**
    * Normalize input args to strip `undefined` fields
    */
@@ -4073,29 +4215,30 @@ var BaseOperationHandler = class {
     return result.rows[0];
   }
   mutationNeedsReadBack(model, args) {
+    const idFields = requireIdFields(this.schema, model);
     if (this.hasPolicyEnabled) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     if (!this.dialect.supportsReturning) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     if (args.include && typeof args.include === "object" && Object.keys(args.include).length > 0) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     const modelDef = this.requireModel(model);
     if (modelDef.baseModel || modelDef.isDelegate) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     const allFields = Object.keys(modelDef.fields);
@@ -4110,7 +4253,7 @@ var BaseOperationHandler = class {
     if (allFieldsSelected.some((f) => relationFields.includes(f) || computedFields.includes(f))) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     } else {
       return {
@@ -4182,7 +4325,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = match8(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = match5(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(eb.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -4215,7 +4358,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = match8(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = match5(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4265,14 +4408,14 @@ var CountOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/create.ts
-import { match as match9 } from "ts-pattern";
+import { match as match6 } from "ts-pattern";
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return match9(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+    return match6(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
       return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, normalizedArgs));
     }).with("createManyAndReturn", () => {
       return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizedArgs));
@@ -4280,7 +4423,8 @@ var CreateOperationHandler = class extends BaseOperationHandler {
   }
   async runCreate(args) {
     const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
-    const result = await this.safeTransaction(async (tx) => {
+    const needsNestedCreate = this.needsNestedCreate(args.data);
+    const result = await this.safeTransactionIf(needReadBack || needsNestedCreate, async (tx) => {
       const createResult = await this.create(tx, this.model, args.data, void 0, false, selectedFields);
       if (needReadBack) {
         return this.readUnique(tx, this.model, {
@@ -4304,14 +4448,16 @@ var CreateOperationHandler = class extends BaseOperationHandler {
         count: 0
       };
     }
-    return this.safeTransaction((tx) => this.createMany(tx, this.model, args, false));
+    const needsNestedCreate = this.needsNestedCreate(args.data);
+    return this.safeTransactionIf(needsNestedCreate, (tx) => this.createMany(tx, this.model, args, false));
   }
   async runCreateManyAndReturn(args) {
     if (args === void 0) {
       return [];
     }
     const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
-    return this.safeTransaction(async (tx) => {
+    const needsNestedCreate = this.needsNestedCreate(args.data);
+    return this.safeTransactionIf(needReadBack || needsNestedCreate, async (tx) => {
       const createResult = await this.createMany(tx, this.model, args, true, void 0, selectedFields);
       if (needReadBack) {
         return this.read(tx, this.model, {
@@ -4326,21 +4472,36 @@ var CreateOperationHandler = class extends BaseOperationHandler {
       }
     });
   }
+  needsNestedCreate(data) {
+    const modelDef = this.requireModel(this.model);
+    if (modelDef.baseModel) {
+      return true;
+    }
+    const hasRelation = Object.entries(data).some(([field, value]) => {
+      const fieldDef = this.getField(this.model, field);
+      return fieldDef?.relation && value !== void 0;
+    });
+    if (hasRelation) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/client/crud/operations/delete.ts
-import { match as match10 } from "ts-pattern";
+import { match as match7 } from "ts-pattern";
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return match10(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
+    return match7(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runDelete(args) {
     const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
-    const result = await this.safeTransaction(async (tx) => {
+    const needsNestedDelete = this.needsNestedDelete();
+    const result = await this.safeTransactionIf(needReadBack || needsNestedDelete, async (tx) => {
       let preDeleteRead = void 0;
       if (needReadBack) {
         preDeleteRead = await this.readUnique(tx, this.model, {
@@ -4362,13 +4523,30 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     return result;
   }
   async runDeleteMany(args) {
-    return await this.safeTransaction(async (tx) => {
+    const needsNestedDelete = this.needsNestedDelete();
+    return await this.safeTransactionIf(needsNestedDelete, async (tx) => {
       const result = await this.delete(tx, this.model, args?.where, args?.limit);
       return {
         count: Number(result.numAffectedRows ?? 0)
       };
     });
   }
+  needsNestedDelete() {
+    const modelDef = this.requireModel(this.model);
+    if (modelDef.baseModel) {
+      return true;
+    }
+    for (const fieldDef of Object.values(modelDef.fields)) {
+      if (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") {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
 };
 
 // src/client/crud/operations/exists.ts
@@ -4403,7 +4581,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/group-by.ts
-import { match as match11 } from "ts-pattern";
+import { match as match8 } from "ts-pattern";
 var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "GroupByOperationHandler");
@@ -4491,7 +4669,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = match11(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = match8(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4506,18 +4684,19 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-import { match as match12 } from "ts-pattern";
+import { match as match9 } from "ts-pattern";
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return match12(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();
+    return match9(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 { needReadBack, selectedFields } = this.needReadBack(args);
-    const result = await this.safeTransaction(async (tx) => {
+    const needsNestedUpdate = this.needsNestedUpdate(args.data);
+    const result = await this.safeTransactionIf(needReadBack || needsNestedUpdate, async (tx) => {
       const updateResult = await this.update(tx, this.model, args.where, args.data, void 0, void 0, void 0, selectedFields);
       if (needReadBack) {
         const readFilter = updateResult ? getIdValues(this.schema, this.model, updateResult) : args.where;
@@ -4544,7 +4723,8 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     }
   }
   async runUpdateMany(args) {
-    return this.safeTransaction(async (tx) => {
+    const needsNestedUpdate = this.needsNestedUpdate(args.data);
+    return this.safeTransactionIf(needsNestedUpdate, async (tx) => {
       return this.updateMany(tx, this.model, args.where, args.data, args.limit, false);
     });
   }
@@ -4553,7 +4733,8 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
       return [];
     }
     const { needReadBack, selectedFields } = this.needReadBack(args);
-    const { readBackResult, updateResult } = await this.safeTransaction(async (tx) => {
+    const needsNestedUpdate = this.needsNestedUpdate(args.data);
+    const { readBackResult, updateResult } = await this.safeTransactionIf(needReadBack || needsNestedUpdate, async (tx) => {
       const updateResult2 = await this.updateMany(tx, this.model, args.where, args.data, args.limit, true, void 0, void 0, selectedFields);
       if (needReadBack) {
         const readBackResult2 = await this.read(tx, this.model, {
@@ -4607,10 +4788,11 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     if (baseResult.needReadBack) {
       return baseResult;
     }
+    const idFields = requireIdFields(this.schema, this.model);
     if (!this.dialect.supportsReturning) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     const modelDef = this.requireModel(this.model);
@@ -4618,28 +4800,42 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     if (args.data && !Object.keys(args.data).some((field) => nonRelationFields.includes(field))) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     if (args.update && !Object.keys(args.update).some((field) => nonRelationFields.includes(field))) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     }
     return baseResult;
   }
+  needsNestedUpdate(data) {
+    const modelDef = this.requireModel(this.model);
+    if (modelDef.baseModel) {
+      return true;
+    }
+    const hasRelation = Object.entries(data).some(([field, value]) => {
+      const fieldDef = this.getField(this.model, field);
+      return fieldDef?.relation && value !== void 0;
+    });
+    if (hasRelation) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/client/crud/validator/validator.ts
 import { invariant as invariant9 } from "@zenstackhq/common-helpers";
-import { match as match14 } from "ts-pattern";
+import { match as match11 } from "ts-pattern";
 
 // src/client/zod/factory.ts
-import { enumerate as enumerate3, invariant as invariant8, lowerCaseFirst } from "@zenstackhq/common-helpers";
+import { enumerate as enumerate3, invariant as invariant8, lowerCaseFirst as lowerCaseFirst2 } from "@zenstackhq/common-helpers";
 import { ZodUtils } from "@zenstackhq/zod";
 import Decimal4 from "decimal.js";
-import { match as match13, P as P2 } from "ts-pattern";
+import { match as match10, P as P2 } from "ts-pattern";
 import { z, ZodObject, ZodType } from "zod";
 
 // src/client/zod/cache-decorator.ts
@@ -4722,6 +4918,13 @@ var ZodSchemaFactory = class {
   get plugins() {
     return this.options.plugins ?? [];
   }
+  /**
+   * Returns model field entries, excluding Unsupported fields.
+   */
+  getModelFields(model) {
+    const modelDef = requireModel(this.schema, model);
+    return Object.entries(modelDef.fields).filter(([, def]) => def.type !== "Unsupported");
+  }
   shouldIncludeRelations(options) {
     return options?.relationDepth === void 0 || options.relationDepth > 0;
   }
@@ -4807,7 +5010,7 @@ var ZodSchemaFactory = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return match13(type).with("String", () => this.extraValidationsEnabled ? ZodUtils.addStringValidation(z.string(), attributes) : z.string()).with("Int", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int()).with("Float", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number(), attributes) : z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
+      return match10(type).with("String", () => this.extraValidationsEnabled ? ZodUtils.addStringValidation(z.string(), attributes) : z.string()).with("Int", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int()).with("Float", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number(), attributes) : z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
         this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int(),
         this.extraValidationsEnabled ? ZodUtils.addBigIntValidation(z.bigint(), attributes) : z.bigint()
       ])).with("Decimal", () => {
@@ -4852,15 +5055,13 @@ var ZodSchemaFactory = class {
     return finalSchema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false, options) {
-    const modelDef = requireModel(this.schema, model);
     const uniqueFieldNames = unique ? getUniqueFields(this.schema, model).filter((uf) => (
       // single-field unique
       "def" in uf
     )).map((uf) => uf.name) : void 0;
     const nextOpts = this.nextOptions(options);
     const fields = {};
-    for (const field of Object.keys(modelDef.fields)) {
-      const fieldDef = requireField(this.schema, model, field);
+    for (const [field, fieldDef] of this.getModelFields(model)) {
       let fieldSchema;
       if (fieldDef.relation) {
         if (withoutRelationFields || !this.shouldIncludeRelations(options)) {
@@ -5055,7 +5256,7 @@ var ZodSchemaFactory = class {
     const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(contextModel, fieldInfo.name);
     const type = fieldInfo.type;
     const optional = !!fieldInfo.optional;
-    return match13(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P2.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(contextModel, fieldInfo.name, optional)).with("Unsupported", () => z.never()).exhaustive();
+    return match10(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P2.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(contextModel, fieldInfo.name, optional)).with("Unsupported", () => z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
@@ -5220,10 +5421,8 @@ var ZodSchemaFactory = class {
     ]);
   }
   makeSelectSchema(model, options) {
-    const modelDef = requireModel(this.schema, model);
     const fields = {};
-    for (const field of Object.keys(modelDef.fields)) {
-      const fieldDef = requireField(this.schema, model, field);
+    for (const [field, fieldDef] of this.getModelFields(model)) {
       if (fieldDef.relation) {
         if (!this.shouldIncludeRelations(options)) {
           continue;
@@ -5241,6 +5440,7 @@ var ZodSchemaFactory = class {
         fields["_count"] = _countSchema;
       }
     }
+    this.addExtResultFields(model, fields);
     return z.strictObject(fields);
   }
   makeCountSelectionSchema(model, options) {
@@ -5295,10 +5495,8 @@ var ZodSchemaFactory = class {
     ]);
   }
   makeOmitSchema(model) {
-    const modelDef = requireModel(this.schema, model);
     const fields = {};
-    for (const field of Object.keys(modelDef.fields)) {
-      const fieldDef = requireField(this.schema, model, field);
+    for (const [field, fieldDef] of this.getModelFields(model)) {
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
           fields[field] = z.boolean().optional();
@@ -5307,8 +5505,22 @@ var ZodSchemaFactory = class {
         }
       }
     }
+    this.addExtResultFields(model, fields);
     return z.strictObject(fields);
   }
+  addExtResultFields(model, fields) {
+    for (const plugin of this.plugins) {
+      const resultConfig = plugin.result;
+      if (resultConfig) {
+        const modelConfig = resultConfig[lowerCaseFirst2(model)];
+        if (modelConfig) {
+          for (const field of Object.keys(modelConfig)) {
+            fields[field] = z.boolean().optional();
+          }
+        }
+      }
+    }
+  }
   makeIncludeSchema(model, options) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
@@ -5332,15 +5544,13 @@ var ZodSchemaFactory = class {
     return z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation, options) {
-    const modelDef = requireModel(this.schema, model);
     const fields = {};
     const sort = z.union([
       z.literal("asc"),
       z.literal("desc")
     ]);
     const nextOpts = this.nextOptions(options);
-    for (const field of Object.keys(modelDef.fields)) {
-      const fieldDef = requireField(this.schema, model, field);
+    for (const [field, fieldDef] of this.getModelFields(model)) {
       if (fieldDef.relation) {
         if (withRelation && this.shouldIncludeRelations(options)) {
           fields[field] = z.lazy(() => {
@@ -5385,8 +5595,7 @@ var ZodSchemaFactory = class {
     return z.strictObject(fields);
   }
   makeDistinctSchema(model) {
-    const modelDef = requireModel(this.schema, model);
-    const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
+    const nonRelationFields = this.getModelFields(model).filter(([, def]) => !def.relation).map(([name]) => name);
     return nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : z.never();
   }
   makeCursorSchema(model, options) {
@@ -5425,13 +5634,13 @@ var ZodSchemaFactory = class {
     const uncheckedVariantFields = {};
     const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
-    const hasRelation = !skipRelations && Object.entries(modelDef.fields).some(([f, def]) => !withoutFields.includes(f) && def.relation);
+    const modelFields = this.getModelFields(model);
+    const hasRelation = !skipRelations && modelFields.some(([f, def]) => !withoutFields.includes(f) && def.relation);
     const nextOpts = this.nextOptions(options);
-    Object.keys(modelDef.fields).forEach((field) => {
+    modelFields.forEach(([field, fieldDef]) => {
       if (withoutFields.includes(field)) {
         return;
       }
-      const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.computed || fieldDef.isDiscriminator) {
         return;
       }
@@ -5524,12 +5733,15 @@ var ZodSchemaFactory = class {
     const fieldDef = requireField(this.schema, model, field);
     const fieldType = fieldDef.type;
     const array = !!fieldDef.array;
+    const canCreateModel = this.canCreateModel(fieldType);
     const fields = {
-      create: this.makeCreateDataSchema(fieldDef.type, !!fieldDef.array, withoutFields, false, options).optional(),
-      connect: this.makeConnectDataSchema(fieldType, array, options).optional(),
-      connectOrCreate: this.makeConnectOrCreateDataSchema(fieldType, array, withoutFields, options).optional()
+      connect: this.makeConnectDataSchema(fieldType, array, options).optional()
     };
-    if (array) {
+    if (canCreateModel) {
+      fields["create"] = this.makeCreateDataSchema(fieldDef.type, !!fieldDef.array, withoutFields, false, options).optional();
+      fields["connectOrCreate"] = this.makeConnectOrCreateDataSchema(fieldType, array, withoutFields, options).optional();
+    }
+    if (array && canCreateModel) {
       fields["createMany"] = this.makeCreateManyPayloadSchema(fieldType, withoutFields, options).optional();
     }
     if (mode === "update") {
@@ -5547,15 +5759,17 @@ var ZodSchemaFactory = class {
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
       ]).optional();
-      let upsertWhere = this.makeWhereSchema(fieldType, true, false, false, options);
-      if (!fieldDef.array) {
-        upsertWhere = upsertWhere.optional();
-      }
-      fields["upsert"] = this.orArray(z.strictObject({
-        where: upsertWhere,
-        create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
-        update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
-      }), true).optional();
+      if (canCreateModel) {
+        let upsertWhere = this.makeWhereSchema(fieldType, true, false, false, options);
+        if (!fieldDef.array) {
+          upsertWhere = upsertWhere.optional();
+        }
+        fields["upsert"] = this.orArray(z.strictObject({
+          where: upsertWhere,
+          create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
+          update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
+        }), true).optional();
+      }
       if (array) {
         fields["set"] = this.makeSetDataSchema(fieldType, true, options).optional();
         fields["updateMany"] = this.orArray(z.strictObject({
@@ -5656,13 +5870,13 @@ var ZodSchemaFactory = class {
     const uncheckedVariantFields = {};
     const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
-    const hasRelation = !skipRelations && Object.entries(modelDef.fields).some(([key, value]) => value.relation && !withoutFields.includes(key));
+    const modelFields = this.getModelFields(model);
+    const hasRelation = !skipRelations && modelFields.some(([key, value]) => value.relation && !withoutFields.includes(key));
     const nextOpts = this.nextOptions(options);
-    Object.keys(modelDef.fields).forEach((field) => {
+    modelFields.forEach(([field, fieldDef]) => {
       if (withoutFields.includes(field)) {
         return;
       }
-      const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.computed || fieldDef.isDiscriminator) {
         return;
       }
@@ -5779,12 +5993,11 @@ var ZodSchemaFactory = class {
     }), "count").optional();
   }
   makeCountAggregateInputSchema(model) {
-    const modelDef = requireModel(this.schema, model);
     return z.union([
       z.literal(true),
       z.strictObject({
         _all: z.literal(true).optional(),
-        ...Object.keys(modelDef.fields).reduce((acc, field) => {
+        ...this.getModelFields(model).reduce((acc, [field]) => {
           acc[field] = z.literal(true).optional();
           return acc;
         }, {})
@@ -5807,9 +6020,7 @@ var ZodSchemaFactory = class {
     }), "aggregate").optional();
   }
   makeSumAvgInputSchema(model) {
-    const modelDef = requireModel(this.schema, model);
-    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
-      const fieldDef = requireField(this.schema, model, field);
+    return z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
       if (this.isNumericField(fieldDef)) {
         acc[field] = z.literal(true).optional();
       }
@@ -5817,9 +6028,7 @@ var ZodSchemaFactory = class {
     }, {}));
   }
   makeMinMaxInputSchema(model) {
-    const modelDef = requireModel(this.schema, model);
-    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
-      const fieldDef = requireField(this.schema, model, field);
+    return z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
       if (!fieldDef.relation && !fieldDef.array) {
         acc[field] = z.literal(true).optional();
       }
@@ -5829,8 +6038,7 @@ var ZodSchemaFactory = class {
   // #endregion
   // #region Group By
   makeGroupBySchema(model, options) {
-    const modelDef = requireModel(this.schema, model);
-    const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
+    const nonRelationFields = this.getModelFields(model).filter(([, def]) => !def.relation).map(([name]) => name);
     const bySchema = nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : z.never();
     const baseSchema = z.strictObject({
       where: this.makeWhereSchema(model, false, false, false, options).optional(),
@@ -6019,7 +6227,7 @@ var ZodSchemaFactory = class {
       return void 0;
     }
     const modelsRecord = slicing.models;
-    const modelConfig = modelsRecord[lowerCaseFirst(model)];
+    const modelConfig = modelsRecord[lowerCaseFirst2(model)];
     if (modelConfig?.fields) {
       const fieldConfig = modelConfig.fields[field];
       if (fieldConfig) {
@@ -6092,10 +6300,17 @@ var ZodSchemaFactory = class {
       return z.strictObject(components);
     }
   }
-  /**
-   * Checks if a model is included in the slicing configuration.
-   * Returns true if the model is allowed, false if it's excluded.
-   */
+  canCreateModel(model) {
+    const modelDef = requireModel(this.schema, model);
+    if (modelDef.isDelegate) {
+      return false;
+    }
+    const hasRequiredUnsupportedFields = Object.values(modelDef.fields).some((fieldDef) => fieldDef.type === "Unsupported" && !fieldDef.optional && !fieldHasDefaultValue(fieldDef));
+    if (hasRequiredUnsupportedFields) {
+      return false;
+    }
+    return true;
+  }
   isModelAllowed(targetModel) {
     const slicing = this.options.slicing;
     if (!slicing) {
@@ -6572,7 +6787,7 @@ var InputValidator = class {
   }
   // #region Entry points
   validateFindArgs(model, args, operation) {
-    return this.validate(model, operation, (model2) => match14(operation).with("findFirst", () => this.zodFactory.makeFindFirstSchema(model2)).with("findUnique", () => this.zodFactory.makeFindUniqueSchema(model2)).with("findMany", () => this.zodFactory.makeFindManySchema(model2)).exhaustive(), args);
+    return this.validate(model, operation, (model2) => match11(operation).with("findFirst", () => this.zodFactory.makeFindFirstSchema(model2)).with("findUnique", () => this.zodFactory.makeFindUniqueSchema(model2)).with("findMany", () => this.zodFactory.makeFindManySchema(model2)).exhaustive(), args);
   }
   validateExistsArgs(model, args) {
     return this.validate(model, "exists", (model2) => this.zodFactory.makeExistsSchema(model2), args);
@@ -6882,7 +7097,7 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 import { invariant as invariant11 } from "@zenstackhq/common-helpers";
 import { AndNode, ColumnNode as ColumnNode3, ColumnUpdateNode as ColumnUpdateNode2, createQueryId as createQueryId2, DefaultQueryExecutor, DeleteQueryNode, expressionBuilder as expressionBuilder7, InsertQueryNode, PrimitiveValueListNode as PrimitiveValueListNode2, ReturningNode, SelectionNode as SelectionNode2, SingleConnectionProvider, TableNode as TableNode3, UpdateQueryNode, ValueNode as ValueNode2, ValuesNode as ValuesNode2, WhereNode } from "kysely";
-import { match as match15 } from "ts-pattern";
+import { match as match12 } from "ts-pattern";
 
 // src/client/executor/name-mapper.ts
 import { invariant as invariant10 } from "@zenstackhq/common-helpers";
@@ -6905,7 +7120,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       if (mappedName) {
         this.modelToTableMap.set(modelName, mappedName);
       }
-      for (const fieldDef of this.getModelFields(modelDef)) {
+      for (const fieldDef of getModelFields(this.schema, modelName)) {
         const mappedName2 = this.getMappedName(fieldDef);
         if (mappedName2) {
           this.fieldToColumnMap.set(`${modelName}.${fieldDef.name}`, mappedName2);
@@ -7166,7 +7381,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
           if (!modelDef) {
             continue;
           }
-          if (this.getModelFields(modelDef).some((f) => f.name === name)) {
+          if (getModelFields(this.schema, scope.model).some((f) => f.name === name)) {
             return scope;
           }
         }
@@ -7280,8 +7495,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     return schema;
   }
   createSelectAllFields(model, alias) {
-    const modelDef = requireModel(this.schema, model);
-    return this.getModelFields(modelDef).map((fieldDef) => {
+    return getModelFields(this.schema, model).map((fieldDef) => {
       const columnName = this.mapFieldName(model, fieldDef.name);
       const columnRef = ReferenceNode2.create(ColumnNode2.create(columnName), alias && IdentifierNode.is(alias) ? TableNode2.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
@@ -7298,9 +7512,6 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       }
     });
   }
-  getModelFields(modelDef) {
-    return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
-  }
   processSelections(selections) {
     const result = [];
     selections.forEach((selection) => {
@@ -7337,9 +7548,8 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     if (!scope.model || !(this.hasMappedColumns(scope.model) || this.modelUsesEnumWithMappedValues(scope.model))) {
       return super.transformSelectAll(node);
     }
-    const modelDef = requireModel(this.schema, scope.model);
-    return this.getModelFields(modelDef).map((fieldDef) => {
-      const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
+    return getModelFields(this.schema, scope.model).map((fieldDef) => {
+      const columnName = this.mapFieldName(scope.model, fieldDef.name);
       const columnRef = ReferenceNode2.create(ColumnNode2.create(columnName));
       const enumProcessed = this.processEnumSelection(columnRef, fieldDef.name);
       return columnName !== fieldDef.name && !AliasNode2.is(enumProcessed) ? this.wrapAlias(enumProcessed, IdentifierNode.create(fieldDef.name)) : enumProcessed;
@@ -7360,7 +7570,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     if (!modelDef) {
       return false;
     }
-    return this.getModelFields(modelDef).some((fieldDef) => {
+    return getModelFields(this.schema, model).some((fieldDef) => {
       const enumDef = getEnum(this.schema, fieldDef.type);
       if (!enumDef) {
         return false;
@@ -7561,14 +7771,18 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
   get hasEntityMutationPluginsWithAfterMutationHooks() {
     return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation?.afterEntityMutation);
   }
+  get hasOnKyselyHooks() {
+    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onKyselyQuery);
+  }
   // #endregion
   // #region main entry point
   async executeQuery(compiledQuery) {
     const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
+    const needEnsureTx = this.hasOnKyselyHooks || this.hasEntityMutationPlugins;
     const result = await this.provideConnection(async (connection) => {
       let startedTx = false;
       try {
-        if (this.isMutationNode(compiledQuery.query) && !this.driver.isTransactionConnection(connection)) {
+        if (this.isMutationNode(compiledQuery.query) && !this.driver.isTransactionConnection(connection) && needEnsureTx) {
           await this.driver.beginTransaction(connection, {
             isolationLevel: TransactionIsolationLevel.ReadCommitted
           });
@@ -7858,7 +8072,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   // #region utilities
   getMutationInfo(queryNode) {
     const model = this.getMutationModel(queryNode);
-    const { action, where } = match15(queryNode).when(InsertQueryNode.is, () => ({
+    const { action, where } = match12(queryNode).when(InsertQueryNode.is, () => ({
       action: "create",
       where: void 0
     })).when(UpdateQueryNode.is, (node) => ({
@@ -7878,7 +8092,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     return InsertQueryNode.is(queryNode) || UpdateQueryNode.is(queryNode) || DeleteQueryNode.is(queryNode);
   }
   getMutationModel(queryNode) {
-    return match15(queryNode).when(InsertQueryNode.is, (node) => {
+    return match12(queryNode).when(InsertQueryNode.is, (node) => {
       invariant11(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(UpdateQueryNode.is, (node) => {
@@ -8034,9 +8248,9 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-import { invariant as invariant12, lowerCaseFirst as lowerCaseFirst2, upperCaseFirst } from "@zenstackhq/common-helpers";
+import { invariant as invariant12, lowerCaseFirst as lowerCaseFirst3, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { sql as sql6, ValueNode as ValueNode3 } from "kysely";
-import { match as match16 } from "ts-pattern";
+import { match as match13 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
 var search = /* @__PURE__ */ __name((_eb, _args) => {
   throw new Error(`"search" function is not implemented yet`);
@@ -8075,7 +8289,7 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   }
   searchExpr = eb.fn.coalesce(searchExpr, sql6.lit(""));
   const escapedSearch = sql6`REPLACE(REPLACE(REPLACE(${dialect.castText(searchExpr)}, ${sql6.val("\\")}, ${sql6.val("\\\\")}), ${sql6.val("%")}, ${sql6.val("\\%")}), ${sql6.val("_")}, ${sql6.val("\\_")})`;
-  searchExpr = match16(method).with("contains", () => eb.fn("CONCAT", [
+  searchExpr = match13(method).with("contains", () => eb.fn("CONCAT", [
     sql6.lit("%"),
     escapedSearch,
     sql6.lit("%")
@@ -8125,7 +8339,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   }
   return eb(dialect.buildArrayLength(field), "=", sql6.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name((_eb, _args, context) => match16(context.dialect.provider).with("sqlite", () => sql6.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => sql6.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => sql6.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
+var now = /* @__PURE__ */ __name((_eb, _args, context) => match13(context.dialect.provider).with("sqlite", () => sql6.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => sql6.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => sql6.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
   const [casing] = args;
@@ -8145,7 +8359,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
   invariant12(ValueNode3.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = match16(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst2(result)).otherwise(() => {
+  result = match13(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst3(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -8165,7 +8379,7 @@ __name(readBoolean, "readBoolean");
 import { invariant as invariant13 } from "@zenstackhq/common-helpers";
 import { sql as sql7 } from "kysely";
 import toposort from "toposort";
-import { match as match17 } from "ts-pattern";
+import { match as match14 } from "ts-pattern";
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -8252,6 +8466,9 @@ var SchemaDbPusher = class {
       if (fieldDef.originModel && !fieldDef.id) {
         continue;
       }
+      if (isUnsupportedField(fieldDef)) {
+        continue;
+      }
       if (fieldDef.relation) {
         table = this.addForeignKeyConstraint(table, modelDef.name, fieldName, fieldDef);
       } else if (!this.isComputedField(fieldDef)) {
@@ -8368,7 +8585,7 @@ var SchemaDbPusher = class {
     });
   }
   isDefaultValueSupportedForType(type) {
-    return match17(this.schema.provider.type).with("postgresql", () => true).with("sqlite", () => true).with("mysql", () => ![
+    return match14(this.schema.provider.type).with("postgresql", () => true).with("sqlite", () => true).with("mysql", () => ![
       "Json",
       "Bytes"
     ].includes(type)).exhaustive();
@@ -8406,7 +8623,7 @@ var SchemaDbPusher = class {
       return this.jsonType;
     }
     const type = fieldDef.type;
-    const result = match17(type).with("String", () => this.stringType).with("Boolean", () => this.booleanType).with("Int", () => this.intType).with("Float", () => this.floatType).with("BigInt", () => this.bigIntType).with("Decimal", () => this.decimalType).with("DateTime", () => this.dateTimeType).with("Bytes", () => this.bytesType).with("Json", () => this.jsonType).otherwise(() => {
+    const result = match14(type).with("String", () => this.stringType).with("Boolean", () => this.booleanType).with("Int", () => this.intType).with("Float", () => this.floatType).with("BigInt", () => this.bigIntType).with("Decimal", () => this.decimalType).with("DateTime", () => this.dateTimeType).with("Bytes", () => this.bytesType).with("Json", () => this.jsonType).otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
@@ -8446,35 +8663,35 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return match17(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return match14(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
   }
   // #region Type mappings and capabilities
   get jsonType() {
-    return match17(this.schema.provider.type).with("mysql", () => "json").otherwise(() => "jsonb");
+    return match14(this.schema.provider.type).with("mysql", () => "json").otherwise(() => "jsonb");
   }
   get bytesType() {
-    return match17(this.schema.provider.type).with("postgresql", () => "bytea").with("mysql", () => "blob").otherwise(() => "blob");
+    return match14(this.schema.provider.type).with("postgresql", () => "bytea").with("mysql", () => "blob").otherwise(() => "blob");
   }
   get stringType() {
-    return match17(this.schema.provider.type).with("mysql", () => sql7.raw("varchar(255)")).otherwise(() => "text");
+    return match14(this.schema.provider.type).with("mysql", () => sql7.raw("varchar(255)")).otherwise(() => "text");
   }
   get booleanType() {
-    return match17(this.schema.provider.type).with("mysql", () => sql7.raw("tinyint(1)")).otherwise(() => "boolean");
+    return match14(this.schema.provider.type).with("mysql", () => sql7.raw("tinyint(1)")).otherwise(() => "boolean");
   }
   get intType() {
     return "integer";
   }
   get floatType() {
-    return match17(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => sql7.raw("double")).otherwise(() => "real");
+    return match14(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => sql7.raw("double")).otherwise(() => "real");
   }
   get bigIntType() {
     return "bigint";
   }
   get decimalType() {
-    return match17(this.schema.provider.type).with("mysql", () => sql7.raw("decimal(65, 30)")).otherwise(() => "decimal");
+    return match14(this.schema.provider.type).with("mysql", () => sql7.raw("decimal(65, 30)")).otherwise(() => "decimal");
   }
   get dateTimeType() {
-    return match17(this.schema.provider.type).with("mysql", () => sql7.raw("datetime(3)")).otherwise(() => "timestamp");
+    return match14(this.schema.provider.type).with("mysql", () => sql7.raw("datetime(3)")).otherwise(() => "timestamp");
   }
   columnSupportsAutoIncrement() {
     return [
@@ -8535,26 +8752,46 @@ var ResultProcessor = class {
     return result;
   }
   doProcessResult(data, model) {
+    const firstRow = Array.isArray(data) ? data[0] : data;
+    if (!firstRow || typeof firstRow !== "object") {
+      return data;
+    }
+    const fields = this.resolveFields(firstRow, model);
     if (Array.isArray(data)) {
-      data.forEach((row, i) => data[i] = this.processRow(row, model));
+      data.forEach((row, i) => data[i] = this.processRow(row, fields));
       return data;
     } else {
-      return this.processRow(data, model);
+      return this.processRow(data, fields);
     }
   }
-  processRow(data, model) {
+  resolveFields(row, model) {
+    if (!row || typeof row !== "object") {
+      return [];
+    }
+    const result = [];
+    for (const key of Object.keys(row)) {
+      if (key === "_count" || key.startsWith(DELEGATE_JOINED_FIELD_PREFIX)) {
+        continue;
+      }
+      const fieldDef = getField(this.schema, model, key);
+      if (fieldDef) {
+        result.push(fieldDef);
+      }
+    }
+    return result;
+  }
+  processRow(data, fields) {
     if (!data || typeof data !== "object") {
       return data;
     }
-    for (const [key, value] of Object.entries(data)) {
+    for (const key of Object.keys(data)) {
+      const value = data[key];
       if (value === void 0) {
         continue;
       }
       if (key === "_count") {
         data[key] = typeof value === "string" ? JSON.parse(value) : value;
-        continue;
-      }
-      if (key.startsWith(DELEGATE_JOINED_FIELD_PREFIX)) {
+      } else if (key.startsWith(DELEGATE_JOINED_FIELD_PREFIX)) {
         if (value) {
           const subRow = this.dialect.transformOutput(value, "Json", false);
           const subModel = key.slice(DELEGATE_JOINED_FIELD_PREFIX.length);
@@ -8563,26 +8800,28 @@ var ResultProcessor = class {
             delete data[key];
             continue;
           }
-          const processedSubRow = this.processRow(subRow, subModel);
+          const subFields = this.resolveFields(subRow, subModel);
+          const processedSubRow = this.processRow(subRow, subFields);
           Object.assign(data, processedSubRow);
         }
         delete data[key];
-        continue;
       }
-      const fieldDef = getField(this.schema, model, key);
-      if (!fieldDef) {
+    }
+    for (const fieldDef of fields) {
+      const value = data[fieldDef.name];
+      if (value === void 0) {
         continue;
       }
       if (value === null) {
-        if (fieldDef.array && !fieldDef.relation && value === null) {
-          data[key] = [];
+        if (fieldDef.array && !fieldDef.relation) {
+          data[fieldDef.name] = [];
         }
         continue;
       }
       if (fieldDef.relation) {
-        data[key] = this.processRelation(value, fieldDef);
+        data[fieldDef.name] = this.processRelation(value, fieldDef);
       } else {
-        data[key] = this.processFieldValue(value, fieldDef);
+        data[fieldDef.name] = this.processFieldValue(value, fieldDef);
       }
     }
     return data;
@@ -8688,7 +8927,11 @@ var ClientImpl = class _ClientImpl {
         executor: new DefaultQueryExecutor2(compiler, adapter, connectionProvider, [])
       });
     }
-    this.kysely = new Kysely(this.kyselyProps);
+    if (baseClient?.isTransaction && !executor) {
+      this.kysely = baseClient.$qb;
+    } else {
+      this.kysely = new Kysely(this.kyselyProps);
+    }
     this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this, {
       enabled: this.$options.validateInput !== false
     });
@@ -8717,7 +8960,7 @@ var ClientImpl = class _ClientImpl {
     for (const [modelName, modelDef] of Object.entries(this.$schema.models)) {
       if (modelDef.computedFields) {
         for (const fieldName of Object.keys(modelDef.computedFields)) {
-          const modelConfig = computedFieldsConfig?.[modelName];
+          const modelConfig = computedFieldsConfig?.[lowerCaseFirst4(modelName)] ?? computedFieldsConfig?.[modelName];
           const fieldConfig = modelConfig?.[fieldName];
           if (fieldConfig === null || fieldConfig === void 0) {
             throw createConfigError(`Computed field "${fieldName}" in model "${modelName}" does not have a configuration. Please provide an implementation in the computedFields option.`);
@@ -8926,13 +9169,13 @@ var ClientImpl = class _ClientImpl {
     };
     return this.$setOptions(newOptions);
   }
-  async $diagnostics() {
-    return {
+  get $diagnostics() {
+    return Promise.resolve({
       zodCache: this.inputValidator.zodFactory.cacheStats,
       slowQueries: this.slowQueries.map((q) => ({
         ...q
       })).sort((a, b) => b.durationMs - a.durationMs)
-    };
+    });
   }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
@@ -9036,26 +9279,34 @@ function isProcedureIncluded(options, procedureName) {
 }
 __name(isProcedureIncluded, "isProcedureIncluded");
 function createModelCrudHandler(client, model, inputValidator, resultProcessor) {
+  const plugins = client.$options.plugins ?? [];
+  const schema = client.$schema;
+  const hasAnyExtResult = hasExtResultFieldDefs(plugins);
   const createPromise = /* @__PURE__ */ __name((operation, nominalOperation, args, handler, postProcess = false, throwIfNoResult = false) => {
     return createZenStackPromise(async (txClient) => {
       let proceed = /* @__PURE__ */ __name(async (_args) => {
+        const shouldApplyExtResult = hasAnyExtResult && EXT_RESULT_OPERATIONS.has(operation);
+        const processedArgs = shouldApplyExtResult ? prepareArgsForExtResult(_args, model, schema, plugins2) : _args;
         const _handler = txClient ? handler.withClient(txClient) : handler;
-        const r = await _handler.handle(operation, _args);
+        const r = await _handler.handle(operation, processedArgs);
         if (!r && throwIfNoResult) {
           throw createNotFoundError(model);
         }
         let result;
         if (r && postProcess) {
-          result = resultProcessor.processResult(r, model, args);
+          result = resultProcessor.processResult(r, model, processedArgs);
         } else {
           result = r ?? null;
         }
+        if (result && shouldApplyExtResult) {
+          result = applyExtResult(result, model, _args, schema, plugins2);
+        }
         return result;
       }, "proceed");
-      const plugins = [
+      const plugins2 = [
         ...client.$options.plugins ?? []
       ];
-      for (const plugin of plugins) {
+      for (const plugin of plugins2) {
         const onQuery = plugin.onQuery;
         if (onQuery) {
           const _proceed = proceed;
@@ -9140,7 +9391,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
   const slicing = client.$options.slicing;
   if (slicing?.models) {
-    const modelSlicing = slicing.models[lowerCaseFirst3(model)];
+    const modelSlicing = slicing.models[lowerCaseFirst4(model)];
     const allSlicing = slicing.models.$all;
     const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
     const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;
@@ -9157,13 +9408,241 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       }
     }
   }
+  const modelDef = requireModel(client.$schema, model);
+  if (Object.values(modelDef.fields).some((f) => isUnsupportedField(f) && !f.optional && !fieldHasDefaultValue(f))) {
+    for (const op of [
+      "create",
+      "createMany",
+      "createManyAndReturn",
+      "upsert"
+    ]) {
+      delete operations[op];
+    }
+  }
   return operations;
 }
 __name(createModelCrudHandler, "createModelCrudHandler");
+var EXT_RESULT_OPERATIONS = /* @__PURE__ */ new Set([
+  "findMany",
+  "findUnique",
+  "findFirst",
+  "create",
+  "createManyAndReturn",
+  "update",
+  "updateManyAndReturn",
+  "upsert",
+  "delete"
+]);
+function hasExtResultFieldDefs(plugins) {
+  return plugins.some((p) => p.result && Object.keys(p.result).length > 0);
+}
+__name(hasExtResultFieldDefs, "hasExtResultFieldDefs");
+function collectExtResultFieldDefs(model, schema, plugins) {
+  const defs = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    const resultConfig = plugin.result;
+    if (resultConfig) {
+      const modelConfig = resultConfig[lowerCaseFirst4(model)];
+      if (modelConfig) {
+        for (const [fieldName, fieldDef] of Object.entries(modelConfig)) {
+          if (getField(schema, model, fieldName)) {
+            throw new Error(`Plugin "${plugin.id}" registers ext result field "${fieldName}" on model "${model}" which conflicts with an existing model field`);
+          }
+          for (const needField of Object.keys(fieldDef.needs ?? {})) {
+            const needDef = getField(schema, model, needField);
+            if (!needDef || needDef.relation) {
+              throw new Error(`Plugin "${plugin.id}" registers ext result field "${fieldName}" on model "${model}" with invalid need "${needField}"`);
+            }
+          }
+          defs.set(fieldName, fieldDef);
+        }
+      }
+    }
+  }
+  return defs;
+}
+__name(collectExtResultFieldDefs, "collectExtResultFieldDefs");
+function prepareArgsForExtResult(args, model, schema, plugins) {
+  if (!args || typeof args !== "object") {
+    return args;
+  }
+  const extResultDefs = collectExtResultFieldDefs(model, schema, plugins);
+  const typedArgs = args;
+  let result = typedArgs;
+  let changed = false;
+  const select = typedArgs["select"];
+  const omit = typedArgs["omit"];
+  const include = typedArgs["include"];
+  if (select && extResultDefs.size > 0) {
+    const newSelect = {
+      ...select
+    };
+    for (const [fieldName, fieldDef] of extResultDefs) {
+      if (newSelect[fieldName]) {
+        delete newSelect[fieldName];
+        for (const needField of Object.keys(fieldDef.needs)) {
+          if (!newSelect[needField]) {
+            newSelect[needField] = true;
+          }
+        }
+      }
+    }
+    result = {
+      ...result,
+      select: newSelect
+    };
+    changed = true;
+  }
+  if (omit && extResultDefs.size > 0) {
+    const newOmit = {
+      ...omit
+    };
+    for (const [fieldName, fieldDef] of extResultDefs) {
+      if (newOmit[fieldName]) {
+        delete newOmit[fieldName];
+      } else {
+        for (const needField of Object.keys(fieldDef.needs)) {
+          if (newOmit[needField]) {
+            delete newOmit[needField];
+          }
+        }
+      }
+    }
+    result = {
+      ...result,
+      omit: newOmit
+    };
+    changed = true;
+  }
+  if (include) {
+    const newInclude = {
+      ...include
+    };
+    let includeChanged = false;
+    for (const [field, value] of Object.entries(newInclude)) {
+      if (value && typeof value === "object") {
+        const fieldDef = getField(schema, model, field);
+        if (fieldDef?.relation) {
+          const targetModel = fieldDef.type;
+          const processed = prepareArgsForExtResult(value, targetModel, schema, plugins);
+          if (processed !== value) {
+            newInclude[field] = processed;
+            includeChanged = true;
+          }
+        }
+      }
+    }
+    if (includeChanged) {
+      result = changed ? {
+        ...result,
+        include: newInclude
+      } : {
+        ...typedArgs,
+        include: newInclude
+      };
+      changed = true;
+    }
+  }
+  if (select) {
+    const currentSelect = changed ? result["select"] : select;
+    if (currentSelect) {
+      const newSelect = {
+        ...currentSelect
+      };
+      let selectChanged = false;
+      for (const [field, value] of Object.entries(newSelect)) {
+        if (value && typeof value === "object") {
+          const fieldDef = getField(schema, model, field);
+          if (fieldDef?.relation) {
+            const targetModel = fieldDef.type;
+            const processed = prepareArgsForExtResult(value, targetModel, schema, plugins);
+            if (processed !== value) {
+              newSelect[field] = processed;
+              selectChanged = true;
+            }
+          }
+        }
+      }
+      if (selectChanged) {
+        result = {
+          ...result,
+          select: newSelect
+        };
+        changed = true;
+      }
+    }
+  }
+  return changed ? result : args;
+}
+__name(prepareArgsForExtResult, "prepareArgsForExtResult");
+function applyExtResult(result, model, originalArgs, schema, plugins) {
+  const extResultDefs = collectExtResultFieldDefs(model, schema, plugins);
+  if (Array.isArray(result)) {
+    for (let i = 0; i < result.length; i++) {
+      result[i] = applyExtResultToRow(result[i], model, originalArgs, schema, plugins, extResultDefs);
+    }
+    return result;
+  } else {
+    return applyExtResultToRow(result, model, originalArgs, schema, plugins, extResultDefs);
+  }
+}
+__name(applyExtResult, "applyExtResult");
+function applyExtResultToRow(row, model, originalArgs, schema, plugins, extResultDefs) {
+  if (!row || typeof row !== "object") {
+    return row;
+  }
+  const data = row;
+  const typedArgs = originalArgs && typeof originalArgs === "object" ? originalArgs : {};
+  const select = typedArgs["select"];
+  const omit = typedArgs["omit"];
+  const include = typedArgs["include"];
+  for (const [fieldName, fieldDef] of extResultDefs) {
+    if (select && !select[fieldName]) {
+      continue;
+    }
+    if (omit?.[fieldName]) {
+      continue;
+    }
+    const needsSatisfied = Object.keys(fieldDef.needs).every((needField) => needField in data);
+    if (needsSatisfied) {
+      data[fieldName] = fieldDef.compute(data);
+    }
+  }
+  if (select) {
+    for (const key of Object.keys(data)) {
+      if (!select[key] && !extResultDefs.has(key)) {
+        delete data[key];
+      }
+    }
+  } else if (omit) {
+    for (const key of Object.keys(omit)) {
+      if (omit[key] && !extResultDefs.has(key)) {
+        delete data[key];
+      }
+    }
+  }
+  const relationSource = include ?? select;
+  if (relationSource) {
+    for (const [field, value] of Object.entries(relationSource)) {
+      if (data[field] == null) {
+        continue;
+      }
+      const fieldDef = getField(schema, model, field);
+      if (!fieldDef?.relation) {
+        continue;
+      }
+      const targetModel = fieldDef.type;
+      const nestedArgs = value && typeof value === "object" ? value : void 0;
+      data[field] = applyExtResult(data[field], targetModel, nestedArgs, schema, plugins);
+    }
+  }
+  return data;
+}
+__name(applyExtResultToRow, "applyExtResultToRow");
 
 // src/client/plugin.ts
-function definePlugin(plugin) {
-  return plugin;
+function definePlugin(...args) {
+  return args.length === 2 ? args[1] : args[0];
 }
 __name(definePlugin, "definePlugin");
 
@@ -9489,13 +9968,13 @@ __export(schema_utils_exports, {
   ExpressionVisitor: () => ExpressionVisitor,
   MatchingExpressionVisitor: () => MatchingExpressionVisitor
 });
-import { match as match18 } from "ts-pattern";
+import { match as match15 } from "ts-pattern";
 var ExpressionVisitor = class {
   static {
     __name(this, "ExpressionVisitor");
   }
   visit(expr) {
-    return match18(expr).with({
+    return match15(expr).with({
       kind: "literal"
     }, (e) => this.visitLiteral(e)).with({
       kind: "array"