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

package/dist/index.cjs

@@ -77,7 +77,7 @@ function formatError(error) {
 __name(formatError, "formatError");
 
 // src/client/crud/operations/aggregate.ts
-var import_ts_pattern8 = require("ts-pattern");
+var import_ts_pattern5 = require("ts-pattern");
 
 // src/client/query-utils.ts
 var query_utils_exports = {};
@@ -110,6 +110,7 @@ __export(query_utils_exports, {
   isRelationField: () => isRelationField,
   isScalarField: () => isScalarField,
   isTypeDef: () => isTypeDef,
+  isUnsupportedField: () => isUnsupportedField,
   makeDefaultOrderBy: () => makeDefaultOrderBy,
   requireField: () => requireField,
   requireIdFields: () => requireIdFields,
@@ -310,10 +311,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;
@@ -647,7 +655,7 @@ var import_common_helpers7 = require("@zenstackhq/common-helpers");
 var import_cuid = __toESM(require("cuid"), 1);
 var import_kysely6 = require("kysely");
 var import_nanoid = require("nanoid");
-var import_ts_pattern7 = require("ts-pattern");
+var import_ts_pattern4 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
 
@@ -730,13 +738,12 @@ var CRUD_EXT = [
 ];
 
 // src/client/crud/dialects/index.ts
-var import_ts_pattern6 = require("ts-pattern");
+var import_ts_pattern3 = require("ts-pattern");
 
 // src/client/crud/dialects/mysql.ts
 var import_common_helpers4 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_kysely3 = require("kysely");
-var import_ts_pattern3 = require("ts-pattern");
 
 // src/common-types.ts
 var DbNullClass = class {
@@ -1451,27 +1458,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)) {
-        continue;
-      }
-      if (this.shouldOmitField(omit, model, field)) {
+    for (const fieldDef of getModelFields(this.schema, model, {
+      inherited: true,
+      computed: true
+    })) {
+      if (this.shouldOmitField(omit, model, fieldDef.name)) {
         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}`);
       });
@@ -1482,8 +1490,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 = (0, import_common_helpers2.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;
@@ -1601,7 +1611,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?.[(0, import_common_helpers2.lowerCaseFirst)(computedModel)]?.[field] ?? computedFields?.[computedModel]?.[field];
       }
       if (!computer) {
         throw createConfigError(`Computed field "${field}" implementation not provided for model "${model}"`);
@@ -1804,24 +1815,46 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
         throw createNotSupportedError(`MySQL does not support array literals`);
       }
     } else {
-      return (0, import_ts_pattern3.match)(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 (0, import_ts_pattern3.match)(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;
@@ -1927,15 +1960,25 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return (0, import_ts_pattern3.match)(operation).with("array_contains", () => {
-      const v = Array.isArray(value) ? value : [
-        value
-      ];
-      return import_kysely3.sql`JSON_CONTAINS(${lhs}, ${import_kysely3.sql.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(import_kysely3.sql`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 import_kysely3.sql`JSON_CONTAINS(${lhs}, ${import_kysely3.sql.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(import_kysely3.sql`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(import_kysely3.sql`JSON_TABLE(${receiver}, '$[*]' COLUMNS(value JSON PATH '$'))`.as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
@@ -1978,12 +2021,22 @@ var import_common_helpers5 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_kysely4 = require("kysely");
 var import_postgres_array = require("postgres-array");
-var import_ts_pattern4 = require("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();
@@ -1994,19 +2047,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 = (0, import_postgres_array.parse)(value);
+            return arr.map(fixTimezone);
+          } catch {
+            return value;
           }
-          const result = new Date(value);
-          return isNaN(result.getTime()) ? value : result;
         });
       }).catch(() => {
       });
@@ -2060,20 +2125,42 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
         return value.map((v) => this.transformInput(v, type, false));
       }
     } else {
-      return (0, import_ts_pattern4.match)(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 (0, import_ts_pattern4.match)(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") {
@@ -2182,18 +2269,24 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return (0, import_ts_pattern4.match)(operation).with("array_contains", () => {
-      const v = Array.isArray(value) ? value : [
-        value
-      ];
-      return import_kysely4.sql`${lhs} @> ${import_kysely4.sql.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,
-      import_kysely4.sql`(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 import_kysely4.sql`${lhs} @> ${import_kysely4.sql.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,
+          import_kysely4.sql`(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", [
@@ -2204,7 +2297,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     if (isEnum(this.schema, zmodelType)) {
       return "text";
     } else {
-      return (0, import_ts_pattern4.match)(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() {
@@ -2246,7 +2339,6 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
 var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_decimal3 = __toESM(require("decimal.js"), 1);
 var import_kysely5 = require("kysely");
-var import_ts_pattern5 = require("ts-pattern");
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -2295,7 +2387,18 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (Array.isArray(value)) {
       return value.map((v) => this.transformInput(v, type, false));
     } else {
-      return (0, import_ts_pattern5.match)(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) {
@@ -2304,7 +2407,22 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     } else if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.transformOutputJson(value);
     } else {
-      return (0, import_ts_pattern5.match)(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) {
@@ -2475,16 +2593,21 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return (0, import_ts_pattern5.match)(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 import_kysely5.sql`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(import_kysely5.sql`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 import_kysely5.sql`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(import_kysely5.sql`json_extract(${lhs}, '$[' || (json_array_length(${lhs}) - 1) || ']')`, "=", value);
+    }
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(this.eb.fn("json_each", [
@@ -2553,7 +2676,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return (0, import_ts_pattern6.match)(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).with("mysql", () => new MySqlCrudDialect(schema, options)).exhaustive();
+  return (0, import_ts_pattern3.match)(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");
 
@@ -2839,7 +2962,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);
@@ -2896,41 +3021,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);
-    (0, import_common_helpers7.invariant)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
-    (0, import_common_helpers7.invariant)(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);
+    (0, import_common_helpers7.invariant)(leftIdField.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers7.invariant)(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 = (0, import_kysely6.expressionBuilder)();
-      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) {
@@ -3188,7 +3308,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 (0, import_ts_pattern7.match)(defaultValue.function).with("cuid", () => {
+      return (0, import_ts_pattern4.match)(defaultValue.function).with("cuid", () => {
         const version = firstArgVal;
         const generated = version === 2 ? (0, import_cuid2.createId)() : (0, import_cuid.default)();
         return this.formatGeneratedValue(generated, defaultValue.args?.[1]);
@@ -3217,6 +3337,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");
@@ -3231,6 +3358,7 @@ var BaseOperationHandler = class {
         ]
       } : parentWhere;
     }
+    const origWhere = combinedWhere;
     const modelDef = this.requireModel(model);
     let finalData = data;
     const autoUpdatedFields = [];
@@ -3247,46 +3375,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 = {};
@@ -3298,7 +3431,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);
         }
@@ -3309,17 +3446,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();
+          (0, import_common_helpers7.invariant)(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"
@@ -3327,26 +3488,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");
           }
@@ -3416,13 +3563,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 = {};
@@ -3434,7 +3574,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
@@ -3446,7 +3586,7 @@ var BaseOperationHandler = class {
     const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely6.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field);
-    return (0, import_ts_pattern7.match)(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 (0, import_ts_pattern4.match)(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}`);
     });
   }
@@ -3456,7 +3596,7 @@ var BaseOperationHandler = class {
     const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely6.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field);
-    return (0, import_ts_pattern7.match)(key).with("set", () => value).with("push", () => {
+    return (0, import_ts_pattern4.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw createInvalidInputError(`Invalid array update operation: ${key}`);
@@ -3696,18 +3836,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) {
@@ -3784,12 +3917,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);
@@ -3854,16 +3984,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);
@@ -4075,6 +4201,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, {
@@ -4082,6 +4215,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
    */
@@ -4119,29 +4261,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);
@@ -4156,7 +4299,7 @@ var BaseOperationHandler = class {
     if (allFieldsSelected.some((f) => relationFields.includes(f) || computedFields.includes(f))) {
       return {
         needReadBack: true,
-        selectedFields: void 0
+        selectedFields: idFields
       };
     } else {
       return {
@@ -4228,7 +4371,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern8.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern5.match)(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}`);
               });
             }
@@ -4261,7 +4404,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern8.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern5.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4311,14 +4454,14 @@ var CountOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/create.ts
-var import_ts_pattern9 = require("ts-pattern");
+var import_ts_pattern6 = require("ts-pattern");
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern9.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+    return (0, import_ts_pattern6.match)(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));
@@ -4326,7 +4469,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, {
@@ -4350,14 +4494,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, {
@@ -4372,21 +4518,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
-var import_ts_pattern10 = require("ts-pattern");
+var import_ts_pattern7 = require("ts-pattern");
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern10.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern7.match)(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, {
@@ -4408,13 +4569,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
@@ -4449,7 +4627,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/group-by.ts
-var import_ts_pattern11 = require("ts-pattern");
+var import_ts_pattern8 = require("ts-pattern");
 var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "GroupByOperationHandler");
@@ -4537,7 +4715,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern11.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern8.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -4552,18 +4730,19 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-var import_ts_pattern12 = require("ts-pattern");
+var import_ts_pattern9 = require("ts-pattern");
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern12.match)(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 (0, import_ts_pattern9.match)(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;
@@ -4590,7 +4769,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);
     });
   }
@@ -4599,7 +4779,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, {
@@ -4653,10 +4834,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);
@@ -4664,28 +4846,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
 var import_common_helpers9 = require("@zenstackhq/common-helpers");
-var import_ts_pattern14 = require("ts-pattern");
+var import_ts_pattern11 = require("ts-pattern");
 
 // src/client/zod/factory.ts
 var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_zod = require("@zenstackhq/zod");
 var import_decimal4 = __toESM(require("decimal.js"), 1);
-var import_ts_pattern13 = require("ts-pattern");
+var import_ts_pattern10 = require("ts-pattern");
 var import_zod2 = require("zod");
 
 // src/client/zod/cache-decorator.ts
@@ -4768,6 +4964,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;
   }
@@ -4853,7 +5056,7 @@ var ZodSchemaFactory = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
+      return (0, import_ts_pattern10.match)(type).with("String", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
         this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
         this.extraValidationsEnabled ? import_zod.ZodUtils.addBigIntValidation(import_zod2.z.bigint(), attributes) : import_zod2.z.bigint()
       ])).with("Decimal", () => {
@@ -4898,15 +5101,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)) {
@@ -5101,7 +5302,7 @@ var ZodSchemaFactory = class {
     const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(contextModel, fieldInfo.name);
     const type = fieldInfo.type;
     const optional = !!fieldInfo.optional;
-    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(import_ts_pattern13.P.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", () => import_zod2.z.never()).exhaustive();
+    return (0, import_ts_pattern10.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(import_ts_pattern10.P.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", () => import_zod2.z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
@@ -5266,10 +5467,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;
@@ -5287,6 +5486,7 @@ var ZodSchemaFactory = class {
         fields["_count"] = _countSchema;
       }
     }
+    this.addExtResultFields(model, fields);
     return import_zod2.z.strictObject(fields);
   }
   makeCountSelectionSchema(model, options) {
@@ -5341,10 +5541,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] = import_zod2.z.boolean().optional();
@@ -5353,8 +5551,22 @@ var ZodSchemaFactory = class {
         }
       }
     }
+    this.addExtResultFields(model, fields);
     return import_zod2.z.strictObject(fields);
   }
+  addExtResultFields(model, fields) {
+    for (const plugin of this.plugins) {
+      const resultConfig = plugin.result;
+      if (resultConfig) {
+        const modelConfig = resultConfig[(0, import_common_helpers8.lowerCaseFirst)(model)];
+        if (modelConfig) {
+          for (const field of Object.keys(modelConfig)) {
+            fields[field] = import_zod2.z.boolean().optional();
+          }
+        }
+      }
+    }
+  }
   makeIncludeSchema(model, options) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
@@ -5378,15 +5590,13 @@ var ZodSchemaFactory = class {
     return import_zod2.z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation, options) {
-    const modelDef = requireModel(this.schema, model);
     const fields = {};
     const sort = import_zod2.z.union([
       import_zod2.z.literal("asc"),
       import_zod2.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] = import_zod2.z.lazy(() => {
@@ -5431,8 +5641,7 @@ var ZodSchemaFactory = class {
     return import_zod2.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(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
   }
   makeCursorSchema(model, options) {
@@ -5471,13 +5680,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;
       }
@@ -5570,12 +5779,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") {
@@ -5593,15 +5805,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(import_zod2.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(import_zod2.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(import_zod2.z.strictObject({
@@ -5702,13 +5916,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;
       }
@@ -5825,12 +6039,11 @@ var ZodSchemaFactory = class {
     }), "count").optional();
   }
   makeCountAggregateInputSchema(model) {
-    const modelDef = requireModel(this.schema, model);
     return import_zod2.z.union([
       import_zod2.z.literal(true),
       import_zod2.z.strictObject({
         _all: import_zod2.z.literal(true).optional(),
-        ...Object.keys(modelDef.fields).reduce((acc, field) => {
+        ...this.getModelFields(model).reduce((acc, [field]) => {
           acc[field] = import_zod2.z.literal(true).optional();
           return acc;
         }, {})
@@ -5853,9 +6066,7 @@ var ZodSchemaFactory = class {
     }), "aggregate").optional();
   }
   makeSumAvgInputSchema(model) {
-    const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
-      const fieldDef = requireField(this.schema, model, field);
+    return import_zod2.z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
       if (this.isNumericField(fieldDef)) {
         acc[field] = import_zod2.z.literal(true).optional();
       }
@@ -5863,9 +6074,7 @@ var ZodSchemaFactory = class {
     }, {}));
   }
   makeMinMaxInputSchema(model) {
-    const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
-      const fieldDef = requireField(this.schema, model, field);
+    return import_zod2.z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
       if (!fieldDef.relation && !fieldDef.array) {
         acc[field] = import_zod2.z.literal(true).optional();
       }
@@ -5875,8 +6084,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(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
     const baseSchema = import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false, false, false, options).optional(),
@@ -6138,10 +6346,17 @@ var ZodSchemaFactory = class {
       return import_zod2.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) {
@@ -6618,7 +6833,7 @@ var InputValidator = class {
   }
   // #region Entry points
   validateFindArgs(model, args, operation) {
-    return this.validate(model, operation, (model2) => (0, import_ts_pattern14.match)(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) => (0, import_ts_pattern11.match)(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);
@@ -6928,7 +7143,7 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely9 = require("kysely");
-var import_ts_pattern15 = require("ts-pattern");
+var import_ts_pattern12 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
 var import_common_helpers10 = require("@zenstackhq/common-helpers");
@@ -6951,7 +7166,7 @@ var QueryNameMapper = class extends import_kysely7.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);
@@ -7212,7 +7427,7 @@ var QueryNameMapper = class extends import_kysely7.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;
           }
         }
@@ -7326,8 +7541,7 @@ var QueryNameMapper = class extends import_kysely7.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 = import_kysely7.ReferenceNode.create(import_kysely7.ColumnNode.create(columnName), alias && import_kysely7.IdentifierNode.is(alias) ? import_kysely7.TableNode.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
@@ -7344,9 +7558,6 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       }
     });
   }
-  getModelFields(modelDef) {
-    return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
-  }
   processSelections(selections) {
     const result = [];
     selections.forEach((selection) => {
@@ -7383,9 +7594,8 @@ var QueryNameMapper = class extends import_kysely7.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 = import_kysely7.ReferenceNode.create(import_kysely7.ColumnNode.create(columnName));
       const enumProcessed = this.processEnumSelection(columnRef, fieldDef.name);
       return columnName !== fieldDef.name && !import_kysely7.AliasNode.is(enumProcessed) ? this.wrapAlias(enumProcessed, import_kysely7.IdentifierNode.create(fieldDef.name)) : enumProcessed;
@@ -7406,7 +7616,7 @@ var QueryNameMapper = class extends import_kysely7.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;
@@ -7607,14 +7817,18 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.
   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
           });
@@ -7904,7 +8118,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 } = (0, import_ts_pattern15.match)(queryNode).when(import_kysely9.InsertQueryNode.is, () => ({
+    const { action, where } = (0, import_ts_pattern12.match)(queryNode).when(import_kysely9.InsertQueryNode.is, () => ({
       action: "create",
       where: void 0
     })).when(import_kysely9.UpdateQueryNode.is, (node) => ({
@@ -7924,7 +8138,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     return import_kysely9.InsertQueryNode.is(queryNode) || import_kysely9.UpdateQueryNode.is(queryNode) || import_kysely9.DeleteQueryNode.is(queryNode);
   }
   getMutationModel(queryNode) {
-    return (0, import_ts_pattern15.match)(queryNode).when(import_kysely9.InsertQueryNode.is, (node) => {
+    return (0, import_ts_pattern12.match)(queryNode).when(import_kysely9.InsertQueryNode.is, (node) => {
       (0, import_common_helpers11.invariant)(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(import_kysely9.UpdateQueryNode.is, (node) => {
@@ -8082,7 +8296,7 @@ __export(functions_exports, {
 });
 var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_kysely10 = require("kysely");
-var import_ts_pattern16 = require("ts-pattern");
+var import_ts_pattern13 = require("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`);
@@ -8121,7 +8335,7 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   }
   searchExpr = eb.fn.coalesce(searchExpr, import_kysely10.sql.lit(""));
   const escapedSearch = import_kysely10.sql`REPLACE(REPLACE(REPLACE(${dialect.castText(searchExpr)}, ${import_kysely10.sql.val("\\")}, ${import_kysely10.sql.val("\\\\")}), ${import_kysely10.sql.val("%")}, ${import_kysely10.sql.val("\\%")}), ${import_kysely10.sql.val("_")}, ${import_kysely10.sql.val("\\_")})`;
-  searchExpr = (0, import_ts_pattern16.match)(method).with("contains", () => eb.fn("CONCAT", [
+  searchExpr = (0, import_ts_pattern13.match)(method).with("contains", () => eb.fn("CONCAT", [
     import_kysely10.sql.lit("%"),
     escapedSearch,
     import_kysely10.sql.lit("%")
@@ -8171,7 +8385,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   }
   return eb(dialect.buildArrayLength(field), "=", import_kysely10.sql.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name((_eb, _args, context) => (0, import_ts_pattern16.match)(context.dialect.provider).with("sqlite", () => import_kysely10.sql.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => import_kysely10.sql.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => import_kysely10.sql.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
+var now = /* @__PURE__ */ __name((_eb, _args, context) => (0, import_ts_pattern13.match)(context.dialect.provider).with("sqlite", () => import_kysely10.sql.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => import_kysely10.sql.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => import_kysely10.sql.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
   const [casing] = args;
@@ -8191,7 +8405,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
   (0, import_common_helpers12.invariant)(import_kysely10.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern16.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers12.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers12.lowerCaseFirst)(result)).otherwise(() => {
+  result = (0, import_ts_pattern13.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers12.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers12.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -8211,7 +8425,7 @@ __name(readBoolean, "readBoolean");
 var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely11 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
-var import_ts_pattern17 = require("ts-pattern");
+var import_ts_pattern14 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -8298,6 +8512,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)) {
@@ -8414,7 +8631,7 @@ var SchemaDbPusher = class {
     });
   }
   isDefaultValueSupportedForType(type) {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => true).with("sqlite", () => true).with("mysql", () => ![
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("postgresql", () => true).with("sqlite", () => true).with("mysql", () => ![
       "Json",
       "Bytes"
     ].includes(type)).exhaustive();
@@ -8452,7 +8669,7 @@ var SchemaDbPusher = class {
       return this.jsonType;
     }
     const type = fieldDef.type;
-    const result = (0, import_ts_pattern17.match)(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 = (0, import_ts_pattern14.match)(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) {
@@ -8492,35 +8709,35 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return (0, import_ts_pattern17.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return (0, import_ts_pattern14.match)(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 (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => "json").otherwise(() => "jsonb");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => "json").otherwise(() => "jsonb");
   }
   get bytesType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => "bytea").with("mysql", () => "blob").otherwise(() => "blob");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("postgresql", () => "bytea").with("mysql", () => "blob").otherwise(() => "blob");
   }
   get stringType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("varchar(255)")).otherwise(() => "text");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("varchar(255)")).otherwise(() => "text");
   }
   get booleanType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("tinyint(1)")).otherwise(() => "boolean");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("tinyint(1)")).otherwise(() => "boolean");
   }
   get intType() {
     return "integer";
   }
   get floatType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => import_kysely11.sql.raw("double")).otherwise(() => "real");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => import_kysely11.sql.raw("double")).otherwise(() => "real");
   }
   get bigIntType() {
     return "bigint";
   }
   get decimalType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("decimal(65, 30)")).otherwise(() => "decimal");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("decimal(65, 30)")).otherwise(() => "decimal");
   }
   get dateTimeType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("datetime(3)")).otherwise(() => "timestamp");
+    return (0, import_ts_pattern14.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("datetime(3)")).otherwise(() => "timestamp");
   }
   columnSupportsAutoIncrement() {
     return [
@@ -8581,26 +8798,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);
@@ -8609,26 +8846,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;
@@ -8734,7 +8973,11 @@ var ClientImpl = class _ClientImpl {
         executor: new import_kysely12.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
       });
     }
-    this.kysely = new import_kysely12.Kysely(this.kyselyProps);
+    if (baseClient?.isTransaction && !executor) {
+      this.kysely = baseClient.$qb;
+    } else {
+      this.kysely = new import_kysely12.Kysely(this.kyselyProps);
+    }
     this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this, {
       enabled: this.$options.validateInput !== false
     });
@@ -8763,7 +9006,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?.[(0, import_common_helpers14.lowerCaseFirst)(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.`);
@@ -8972,13 +9215,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 () => {
@@ -9082,26 +9325,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;
@@ -9203,13 +9454,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[(0, import_common_helpers14.lowerCaseFirst)(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");
 
@@ -9535,13 +10014,13 @@ __export(schema_utils_exports, {
   ExpressionVisitor: () => ExpressionVisitor,
   MatchingExpressionVisitor: () => MatchingExpressionVisitor
 });
-var import_ts_pattern18 = require("ts-pattern");
+var import_ts_pattern15 = require("ts-pattern");
 var ExpressionVisitor = class {
   static {
     __name(this, "ExpressionVisitor");
   }
   visit(expr) {
-    return (0, import_ts_pattern18.match)(expr).with({
+    return (0, import_ts_pattern15.match)(expr).with({
       kind: "literal"
     }, (e) => this.visitLiteral(e)).with({
       kind: "array"