@zenstackhq/runtime 3.0.0-beta.10 → 3.0.0-beta.12

package/dist/index.cjs

@@ -62,7 +62,6 @@ var import_ts_pattern7 = require("ts-pattern");
 var query_utils_exports = {};
 __export(query_utils_exports, {
   aggregate: () => aggregate,
-  buildFieldRef: () => buildFieldRef,
   buildJoinPairs: () => buildJoinPairs,
   ensureArray: () => ensureArray,
   extractFieldName: () => extractFieldName,
@@ -408,28 +407,6 @@ function getIdValues(schema, model, data) {
   }), {});
 }
 __name(getIdValues, "getIdValues");
-function buildFieldRef(schema, model, field, options, eb, modelAlias, inlineComputedField = true) {
-  const fieldDef = requireField(schema, model, field);
-  if (!fieldDef.computed) {
-    return eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
-  } else {
-    if (!inlineComputedField) {
-      return eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
-    }
-    let computer;
-    if ("computedFields" in options) {
-      const computedFields = options.computedFields;
-      computer = computedFields?.[model]?.[field];
-    }
-    if (!computer) {
-      throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
-    }
-    return computer(eb, {
-      modelAlias
-    });
-  }
-}
-__name(buildFieldRef, "buildFieldRef");
 function fieldHasDefaultValue(fieldDef) {
   return fieldDef.default !== void 0 || fieldDef.updatedAt;
 }
@@ -781,7 +758,7 @@ var BaseCrudDialect = class {
       take = -take;
     }
     result = this.buildSkipTake(result, skip, take);
-    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, negateOrderBy);
     if ("distinct" in args && args.distinct) {
       const distinct = ensureArray(args.distinct);
       if (this.supportsDistinctOn) {
@@ -1140,16 +1117,12 @@ var BaseCrudDialect = class {
     ]);
     return this.and(...conditions.conditions);
   }
-  buildOrderBy(query, model, modelAlias, orderBy, useDefaultIfEmpty, negated) {
+  buildOrderBy(query, model, modelAlias, orderBy, negated) {
     if (!orderBy) {
-      if (useDefaultIfEmpty) {
-        orderBy = makeDefaultOrderBy(this.schema, model);
-      } else {
-        return query;
-      }
+      return query;
     }
     let result = query;
-    const buildFieldRef2 = /* @__PURE__ */ __name((model2, field, modelAlias2) => {
+    const buildFieldRef = /* @__PURE__ */ __name((model2, field, modelAlias2) => {
       const fieldDef = requireField(this.schema, model2, field);
       return fieldDef.originModel ? this.fieldRef(fieldDef.originModel, field, fieldDef.originModel) : this.fieldRef(model2, field, modelAlias2);
     }, "buildFieldRef");
@@ -1168,7 +1141,7 @@ var BaseCrudDialect = class {
           (0, import_common_helpers3.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, buildFieldRef2(model, k, modelAlias), field), import_kysely2.sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), import_kysely2.sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -1177,7 +1150,7 @@ var BaseCrudDialect = class {
             (0, import_common_helpers3.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
               (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(buildFieldRef2(model, k, modelAlias)), import_kysely2.sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), import_kysely2.sql.raw(this.negateSort(v, negated)));
             }
             continue;
           }
@@ -1186,7 +1159,7 @@ var BaseCrudDialect = class {
         }
         const fieldDef = requireField(this.schema, model, field);
         if (!fieldDef.relation) {
-          const fieldRef = buildFieldRef2(model, field, modelAlias);
+          const fieldRef = buildFieldRef(model, field, modelAlias);
           if (value === "asc" || value === "desc") {
             result = result.orderBy(fieldRef, this.negateSort(value, negated));
           } else if (value && typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
@@ -1215,7 +1188,7 @@ var BaseCrudDialect = class {
               const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
               return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
             });
-            result = this.buildOrderBy(result, fieldDef.type, relationModel, value, false, negated);
+            result = this.buildOrderBy(result, fieldDef.type, relationModel, value, negated);
           }
         }
       }
@@ -1262,13 +1235,9 @@ var BaseCrudDialect = class {
   }
   buildSelectField(query, model, modelAlias, field) {
     const fieldDef = requireField(this.schema, model, field);
-    if (fieldDef.computed) {
-      return query.select(() => this.fieldRef(model, field, modelAlias).as(field));
-    } else if (!fieldDef.originModel) {
-      return query.select(this.eb.ref(`${modelAlias}.${field}`).as(field));
-    } else {
-      return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
-    }
+    const fieldModel = fieldDef.originModel ?? model;
+    const alias = fieldDef.originModel ?? modelAlias;
+    return query.select(() => this.fieldRef(fieldModel, field, alias).as(field));
   }
   buildDelegateJoin(thisModel, thisModelAlias, otherModelAlias, query) {
     const idFields = requireIdFields(this.schema, thisModel);
@@ -1357,7 +1326,25 @@ var BaseCrudDialect = class {
     return this.eb.not(this.and(...args));
   }
   fieldRef(model, field, modelAlias, inlineComputedField = true) {
-    return buildFieldRef(this.schema, model, field, this.options, this.eb, modelAlias, inlineComputedField);
+    const fieldDef = requireField(this.schema, model, field);
+    if (!fieldDef.computed) {
+      return this.eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
+    } else {
+      if (!inlineComputedField) {
+        return this.eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
+      }
+      let computer;
+      if ("computedFields" in this.options) {
+        const computedFields = this.options.computedFields;
+        computer = computedFields?.[fieldDef.originModel ?? model]?.[field];
+      }
+      if (!computer) {
+        throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
+      }
+      return computer(this.eb, {
+        modelAlias
+      });
+    }
   }
   canJoinWithoutNestedSelect(modelDef, payload) {
     if (modelDef.computedFields) {
@@ -1950,7 +1937,7 @@ var BaseOperationHandler = class {
   buildCountSelection(query, model, parentAlias, payload) {
     return query.select((eb) => this.dialect.buildCountJson(model, eb, parentAlias, payload).as("_count"));
   }
-  async create(kysely, model, data, fromRelation, creatingForDelegate = false) {
+  async create(kysely, model, data, fromRelation, creatingForDelegate = false, returnFields) {
     const modelDef = this.requireModel(model);
     if (modelDef.isDelegate && !creatingForDelegate) {
       throw new QueryError(`Model "${this.model}" is a delegate and cannot be created directly.`);
@@ -2003,8 +1990,8 @@ var BaseOperationHandler = class {
       createFields = baseCreateResult.remainingFields;
     }
     const updatedData = this.fillGeneratedAndDefaultValues(modelDef, createFields);
-    const idFields = requireIdFields(this.schema, model);
-    const query = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.defaultValues()).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).returning(idFields).modifyEnd(this.makeContextComment({
+    returnFields = returnFields ?? requireIdFields(this.schema, model);
+    const query = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.defaultValues()).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).returning(returnFields).modifyEnd(this.makeContextComment({
       model,
       operation: "create"
     }));
@@ -2209,7 +2196,7 @@ var BaseOperationHandler = class {
       }
     }
   }
-  async createMany(kysely, model, input, returnData, fromRelation) {
+  async createMany(kysely, model, input, returnData, fromRelation, fieldsToReturn) {
     if (!input.data || Array.isArray(input.data) && input.data.length === 0) {
       return returnData ? [] : {
         count: 0
@@ -2278,8 +2265,8 @@ var BaseOperationHandler = class {
         count: Number(result.numAffectedRows)
       };
     } else {
-      const idFields = requireIdFields(this.schema, model);
-      const result = await query.returning(idFields).execute();
+      fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
+      const result = await query.returning(fieldsToReturn).execute();
       return result;
     }
   }
@@ -2359,7 +2346,7 @@ var BaseOperationHandler = class {
       return void 0;
     }
   }
-  async update(kysely, model, where, data, fromRelation, allowRelationUpdate = true, throwIfNotFound = true) {
+  async update(kysely, model, where, data, fromRelation, allowRelationUpdate = true, throwIfNotFound = true, fieldsToReturn) {
     if (!data || typeof data !== "object") {
       throw new InternalError("data must be an object");
     }
@@ -2465,8 +2452,8 @@ var BaseOperationHandler = class {
     if (!hasFieldUpdate) {
       return combinedWhere;
     } else {
-      const idFields = requireIdFields(this.schema, model);
-      const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).returning(idFields).modifyEnd(this.makeContextComment({
+      fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
+      const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).returning(fieldsToReturn).modifyEnd(this.makeContextComment({
         model,
         operation: "update"
       }));
@@ -2558,7 +2545,7 @@ var BaseOperationHandler = class {
   makeContextComment(_context) {
     return import_kysely5.sql``;
   }
-  async updateMany(kysely, model, where, data, limit, returnData, filterModel) {
+  async updateMany(kysely, model, where, data, limit, returnData, filterModel, fieldsToReturn) {
     if (typeof data !== "object") {
       throw new InternalError("data must be an object");
     }
@@ -2615,8 +2602,8 @@ var BaseOperationHandler = class {
         count: Number(result.numAffectedRows)
       };
     } else {
-      const idFields = requireIdFields(this.schema, model);
-      const finalQuery = query.returning(idFields);
+      fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
+      const finalQuery = query.returning(fieldsToReturn);
       const result = await this.executeQuery(kysely, finalQuery, "update");
       return result.rows;
     }
@@ -3020,7 +3007,7 @@ var BaseOperationHandler = class {
         });
       }
     }
-    if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
+    if (throwForNotFound && expectedDeleteCount > deleteResult.rows.length) {
       throw new NotFoundError(deleteFromModel);
     }
   }
@@ -3028,7 +3015,7 @@ var BaseOperationHandler = class {
     return enumerate(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
   }
   // #endregion
-  async delete(kysely, model, where, limit, filterModel) {
+  async delete(kysely, model, where, limit, filterModel, fieldsToReturn) {
     filterModel ??= model;
     const modelDef = this.requireModel(model);
     if (modelDef.baseModel) {
@@ -3037,7 +3024,8 @@ var BaseOperationHandler = class {
       }
       return this.processBaseModelDelete(kysely, modelDef.baseModel, where, limit, filterModel);
     }
-    let query = kysely.deleteFrom(model);
+    fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
+    let query = kysely.deleteFrom(model).returning(fieldsToReturn);
     let needIdFilter = false;
     if (limit !== void 0 && !this.dialect.supportsDeleteWithLimit) {
       needIdFilter = true;
@@ -3057,10 +3045,7 @@ var BaseOperationHandler = class {
       model,
       operation: "delete"
     }));
-    const result = await this.executeQuery(kysely, query, "delete");
-    return {
-      count: Number(result.numAffectedRows)
-    };
+    return this.executeQuery(kysely, query, "delete");
   }
   async processDelegateRelationDelete(kysely, modelDef, where, limit) {
     for (const fieldDef of Object.values(modelDef.fields)) {
@@ -3114,7 +3099,7 @@ var BaseOperationHandler = class {
       return callback(this.kysely);
     } else {
       let txBuilder = this.kysely.transaction();
-      txBuilder = txBuilder.setIsolationLevel(isolationLevel ?? TransactionIsolationLevel.RepeatableRead);
+      txBuilder = txBuilder.setIsolationLevel(isolationLevel ?? TransactionIsolationLevel.ReadCommitted);
       return txBuilder.execute(callback);
     }
   }
@@ -3166,6 +3151,48 @@ var BaseOperationHandler = class {
     }
     return result.rows[0];
   }
+  mutationNeedsReadBack(model, args) {
+    if (this.hasPolicyEnabled) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
+    if (args.include && typeof args.include === "object" && Object.keys(args.include).length > 0) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
+    const modelDef = this.requireModel(model);
+    if (modelDef.baseModel || modelDef.isDelegate) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
+    const allFields = Object.keys(modelDef.fields);
+    const relationFields = Object.values(modelDef.fields).filter((f) => f.relation).map((f) => f.name);
+    const computedFields = Object.values(modelDef.fields).filter((f) => f.computed).map((f) => f.name);
+    const omit = Object.entries(args.omit ?? {}).filter(([, v]) => v).map(([k]) => k);
+    const allFieldsSelected = [];
+    if (!args.select || typeof args.select !== "object") {
+      allFieldsSelected.push(...allFields.filter((f) => !relationFields.includes(f) && !omit.includes(f)));
+    } else {
+      allFieldsSelected.push(...Object.entries(args.select).filter(([k, v]) => v && !omit.includes(k)).map(([k]) => k));
+    }
+    if (allFieldsSelected.some((f) => relationFields.includes(f) || computedFields.includes(f))) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    } else {
+      return {
+        needReadBack: false,
+        selectedFields: allFieldsSelected
+      };
+    }
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -3201,7 +3228,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
         take = -take;
       }
       subQuery = this.dialect.buildSkipTake(subQuery, skip, take);
-      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, negateOrderBy);
       return subQuery.as("$sub");
     });
     for (const [key, value] of Object.entries(parsedArgs)) {
@@ -3326,14 +3353,19 @@ var CreateOperationHandler = class extends BaseOperationHandler {
     }).exhaustive();
   }
   async runCreate(args) {
+    const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
     const result = await this.safeTransaction(async (tx) => {
-      const createResult = await this.create(tx, this.model, args.data);
-      return this.readUnique(tx, this.model, {
-        select: args.select,
-        include: args.include,
-        omit: args.omit,
-        where: getIdValues(this.schema, this.model, createResult)
-      });
+      const createResult = await this.create(tx, this.model, args.data, void 0, false, selectedFields);
+      if (needReadBack) {
+        return this.readUnique(tx, this.model, {
+          select: args.select,
+          include: args.include,
+          omit: args.omit,
+          where: getIdValues(this.schema, this.model, createResult)
+        });
+      } else {
+        return createResult;
+      }
     });
     if (!result && this.hasPolicyEnabled) {
       throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, `result is not allowed to be read back`);
@@ -3352,15 +3384,20 @@ var CreateOperationHandler = class extends BaseOperationHandler {
     if (args === void 0) {
       return [];
     }
+    const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
     return this.safeTransaction(async (tx) => {
-      const createResult = await this.createMany(tx, this.model, args, true);
-      return this.read(tx, this.model, {
-        select: args.select,
-        omit: args.omit,
-        where: {
-          OR: createResult.map((item) => getIdValues(this.schema, this.model, item))
-        }
-      });
+      const createResult = await this.createMany(tx, this.model, args, true, void 0, selectedFields);
+      if (needReadBack) {
+        return this.read(tx, this.model, {
+          select: args.select,
+          omit: args.omit,
+          where: {
+            OR: createResult.map((item) => getIdValues(this.schema, this.model, item))
+          }
+        });
+      } else {
+        return createResult;
+      }
     });
   }
 };
@@ -3376,27 +3413,34 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     return (0, import_ts_pattern9.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 existing = await this.readUnique(this.kysely, this.model, {
-      select: args.select,
-      include: args.include,
-      omit: args.omit,
-      where: args.where
-    });
-    await this.safeTransaction(async (tx) => {
-      const result = await this.delete(tx, this.model, args.where);
-      if (result.count === 0) {
+    const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
+    const result = await this.safeTransaction(async (tx) => {
+      let preDeleteRead = void 0;
+      if (needReadBack) {
+        preDeleteRead = await this.readUnique(tx, this.model, {
+          select: args.select,
+          include: args.include,
+          omit: args.omit,
+          where: args.where
+        });
+      }
+      const deleteResult = await this.delete(tx, this.model, args.where, void 0, void 0, selectedFields);
+      if (deleteResult.rows.length === 0) {
         throw new NotFoundError(this.model);
       }
+      return needReadBack ? preDeleteRead : deleteResult.rows[0];
     });
-    if (!existing && this.hasPolicyEnabled) {
+    if (!result && this.hasPolicyEnabled) {
       throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
     }
-    return existing;
+    return result;
   }
   async runDeleteMany(args) {
     return await this.safeTransaction(async (tx) => {
       const result = await this.delete(tx, this.model, args?.where, args?.limit);
-      return result;
+      return {
+        count: result.rows.length
+      };
     });
   }
 };
@@ -3432,29 +3476,23 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
   async handle(_operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
     const parsedArgs = this.inputValidator.validateGroupByArgs(this.model, normalizedArgs);
-    let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where(() => this.dialect.buildFilter(this.model, this.model, parsedArgs?.where));
-      const skip = parsedArgs?.skip;
-      let take = parsedArgs?.take;
-      let negateOrderBy = false;
-      if (take !== void 0 && take < 0) {
-        negateOrderBy = true;
-        take = -take;
-      }
-      subQuery = this.dialect.buildSkipTake(subQuery, skip, take);
-      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, void 0, skip !== void 0 || take !== void 0, negateOrderBy);
-      return subQuery.as("$sub");
-    });
-    const fieldRef = /* @__PURE__ */ __name((field) => this.dialect.fieldRef(this.model, field, "$sub"), "fieldRef");
+    let query = this.kysely.selectFrom(this.model).where(() => this.dialect.buildFilter(this.model, this.model, parsedArgs?.where));
+    const fieldRef = /* @__PURE__ */ __name((field) => this.dialect.fieldRef(this.model, field), "fieldRef");
     const bys = typeof parsedArgs.by === "string" ? [
       parsedArgs.by
     ] : parsedArgs.by;
     query = query.groupBy(bys.map((by) => fieldRef(by)));
-    if (parsedArgs.orderBy) {
-      query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
+    const skip = parsedArgs?.skip;
+    let take = parsedArgs?.take;
+    let negateOrderBy = false;
+    if (take !== void 0 && take < 0) {
+      negateOrderBy = true;
+      take = -take;
     }
+    query = this.dialect.buildSkipTake(query, skip, take);
+    query = this.dialect.buildOrderBy(query, this.model, this.model, parsedArgs.orderBy, negateOrderBy);
     if (parsedArgs.having) {
-      query = query.having(() => this.dialect.buildFilter(this.model, "$sub", parsedArgs.having));
+      query = query.having(() => this.dialect.buildFilter(this.model, this.model, parsedArgs.having));
     }
     for (const by of bys) {
       query = query.select(() => fieldRef(by).as(by));
@@ -3543,29 +3581,31 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     return (0, import_ts_pattern11.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 readBackResult = await this.safeTransaction(async (tx) => {
-      const updateResult = await this.update(tx, this.model, args.where, args.data);
-      const readFilter = updateResult ?? args.where;
-      let readBackResult2 = void 0;
-      try {
-        readBackResult2 = await this.readUnique(tx, this.model, {
+    const { needReadBack, selectedFields } = this.needReadBack(args);
+    const result = await this.safeTransaction(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 ?? args.where;
+        let readBackResult = void 0;
+        readBackResult = await this.readUnique(tx, this.model, {
           select: args.select,
           include: args.include,
           omit: args.omit,
           where: readFilter
         });
-      } catch {
+        return readBackResult;
+      } else {
+        return updateResult;
       }
-      return readBackResult2;
     });
-    if (!readBackResult) {
+    if (!result) {
       if (this.hasPolicyEnabled) {
         throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
       } else {
         return null;
       }
     } else {
-      return readBackResult;
+      return result;
     }
   }
   async runUpdateMany(args) {
@@ -3577,19 +3617,27 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     if (!args) {
       return [];
     }
+    const { needReadBack, selectedFields } = this.needReadBack(args);
     const { readBackResult, updateResult } = await this.safeTransaction(async (tx) => {
-      const updateResult2 = await this.updateMany(tx, this.model, args.where, args.data, args.limit, true);
-      const readBackResult2 = await this.read(tx, this.model, {
-        select: args.select,
-        omit: args.omit,
-        where: {
-          OR: updateResult2.map((item) => getIdValues(this.schema, this.model, item))
-        }
-      });
-      return {
-        readBackResult: readBackResult2,
-        updateResult: updateResult2
-      };
+      const updateResult2 = await this.updateMany(tx, this.model, args.where, args.data, args.limit, true, void 0, selectedFields);
+      if (needReadBack) {
+        const readBackResult2 = await this.read(tx, this.model, {
+          select: args.select,
+          omit: args.omit,
+          where: {
+            OR: updateResult2.map((item) => getIdValues(this.schema, this.model, item))
+          }
+        });
+        return {
+          readBackResult: readBackResult2,
+          updateResult: updateResult2
+        };
+      } else {
+        return {
+          readBackResult: updateResult2,
+          updateResult: updateResult2
+        };
+      }
     });
     if (readBackResult.length < updateResult.length && this.hasPolicyEnabled) {
       throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
@@ -3597,23 +3645,49 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     return readBackResult;
   }
   async runUpsert(args) {
+    const { needReadBack, selectedFields } = this.needReadBack(args);
     const result = await this.safeTransaction(async (tx) => {
-      let mutationResult = await this.update(tx, this.model, args.where, args.update, void 0, true, false);
+      let mutationResult = await this.update(tx, this.model, args.where, args.update, void 0, true, false, selectedFields);
       if (!mutationResult) {
-        mutationResult = await this.create(tx, this.model, args.create);
+        mutationResult = await this.create(tx, this.model, args.create, void 0, void 0, selectedFields);
+      }
+      if (needReadBack) {
+        return this.readUnique(tx, this.model, {
+          select: args.select,
+          include: args.include,
+          omit: args.omit,
+          where: getIdValues(this.schema, this.model, mutationResult)
+        });
+      } else {
+        return mutationResult;
       }
-      return this.readUnique(tx, this.model, {
-        select: args.select,
-        include: args.include,
-        omit: args.omit,
-        where: getIdValues(this.schema, this.model, mutationResult)
-      });
     });
     if (!result && this.hasPolicyEnabled) {
       throw new RejectedByPolicyError(this.model, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
     }
     return result;
   }
+  needReadBack(args) {
+    const baseResult = this.mutationNeedsReadBack(this.model, args);
+    if (baseResult.needReadBack) {
+      return baseResult;
+    }
+    const modelDef = this.requireModel(this.model);
+    const nonRelationFields = Object.entries(modelDef.fields).filter(([_, def]) => !def.relation).map(([name, _]) => name);
+    if (args.data && !Object.keys(args.data).some((field) => nonRelationFields.includes(field))) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
+    if (args.update && !Object.keys(args.update).some((field) => nonRelationFields.includes(field))) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
+    return baseResult;
+  }
 };
 
 // src/client/crud/validator/index.ts
@@ -3978,12 +4052,12 @@ function evalCall(data, expr) {
 __name(evalCall, "evalCall");
 
 // src/client/crud/validator/index.ts
+var schemaCache = /* @__PURE__ */ new WeakMap();
 var InputValidator = class {
   static {
     __name(this, "InputValidator");
   }
   client;
-  schemaCache = /* @__PURE__ */ new Map();
   constructor(client) {
     this.client = client;
   }
@@ -4032,16 +4106,34 @@ var InputValidator = class {
   validateGroupByArgs(model, args) {
     return this.validate(model, "groupBy", void 0, (model2) => this.makeGroupBySchema(model2), args);
   }
+  getSchemaCache(cacheKey) {
+    let thisCache = schemaCache.get(this.schema);
+    if (!thisCache) {
+      thisCache = /* @__PURE__ */ new Map();
+      schemaCache.set(this.schema, thisCache);
+    }
+    return thisCache.get(cacheKey);
+  }
+  setSchemaCache(cacheKey, schema) {
+    let thisCache = schemaCache.get(this.schema);
+    if (!thisCache) {
+      thisCache = /* @__PURE__ */ new Map();
+      schemaCache.set(this.schema, thisCache);
+    }
+    return thisCache.set(cacheKey, schema);
+  }
   validate(model, operation, options, getSchema, args) {
     const cacheKey = (0, import_json_stable_stringify.default)({
+      type: "model",
       model,
       operation,
-      options
+      options,
+      extraValidationsEnabled: this.extraValidationsEnabled
     });
-    let schema = this.schemaCache.get(cacheKey);
+    let schema = this.getSchemaCache(cacheKey);
     if (!schema) {
       schema = getSchema(model, options);
-      this.schemaCache.set(cacheKey, schema);
+      this.setSchemaCache(cacheKey, schema);
     }
     const { error, data } = schema.safeParse(args);
     if (error) {
@@ -4100,8 +4192,12 @@ var InputValidator = class {
     }
   }
   makeTypeDefSchema(type) {
-    const key = `$typedef-${type}`;
-    let schema = this.schemaCache.get(key);
+    const key = (0, import_json_stable_stringify.default)({
+      type: "typedef",
+      name: type,
+      extraValidationsEnabled: this.extraValidationsEnabled
+    });
+    let schema = this.getSchemaCache(key);
     if (schema) {
       return schema;
     }
@@ -4120,7 +4216,7 @@ var InputValidator = class {
         fieldSchema
       ];
     }))).passthrough();
-    this.schemaCache.set(key, schema);
+    this.setSchemaCache(key, schema);
     return schema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
@@ -5569,7 +5665,18 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   nameMapper;
   constructor(client, driver, compiler, adapter, connectionProvider, plugins = [], suppressMutationHooks = false) {
     super(compiler, adapter, connectionProvider, plugins), this.client = client, this.driver = driver, this.compiler = compiler, this.connectionProvider = connectionProvider, this.suppressMutationHooks = suppressMutationHooks;
-    this.nameMapper = new QueryNameMapper(client.$schema);
+    if (this.schemaHasMappedNames(client.$schema)) {
+      this.nameMapper = new QueryNameMapper(client.$schema);
+    }
+  }
+  schemaHasMappedNames(schema) {
+    const hasMapAttr = /* @__PURE__ */ __name((decl) => {
+      if (decl.attributes?.some((attr) => attr.name === "@@map")) {
+        return true;
+      }
+      return Object.values(decl.fields).some((field) => field.attributes?.some((attr) => attr.name === "@map"));
+    }, "hasMapAttr");
+    return Object.values(schema.models).some(hasMapAttr) || Object.values(schema.typeDefs ?? []).some(hasMapAttr);
   }
   get kysely() {
     return this.client.$qb;
@@ -5584,7 +5691,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
       try {
         if (this.isMutationNode(compiledQuery.query) && !this.driver.isTransactionConnection(connection)) {
           await this.driver.beginTransaction(connection, {
-            isolationLevel: TransactionIsolationLevel.RepeatableRead
+            isolationLevel: TransactionIsolationLevel.ReadCommitted
           });
           startedTx = true;
         }
@@ -5651,7 +5758,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   async proceedQuery(connection, query, parameters, queryId) {
     let compiled;
     if (this.suppressMutationHooks || !this.isMutationNode(query) || !this.hasEntityMutationPlugins) {
-      const finalQuery2 = this.nameMapper.transformNode(query);
+      const finalQuery2 = this.processNameMapping(query);
       compiled = this.compileQuery(finalQuery2);
       if (parameters) {
         compiled = {
@@ -5669,7 +5776,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
         ])
       };
     }
-    const finalQuery = this.nameMapper.transformNode(query);
+    const finalQuery = this.processNameMapping(query);
     compiled = this.compileQuery(finalQuery);
     if (parameters) {
       compiled = {
@@ -5697,6 +5804,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
     }
     return result;
   }
+  processNameMapping(query) {
+    return this.nameMapper?.transformNode(query) ?? query;
+  }
   createClientForConnection(connection, inTx) {
     const innerExecutor = this.withConnectionProvider(new import_kysely7.SingleConnectionProvider(connection));
     innerExecutor.suppressMutationHooks = true;
@@ -6481,6 +6591,11 @@ var ClientImpl = class _ClientImpl {
       ...args
     ]);
   }
+  async $connect() {
+    await this.kysely.connection().execute(async (conn) => {
+      await conn.executeQuery(import_kysely10.sql`select 1`.compile(this.kysely));
+    });
+  }
   async $disconnect() {
     await this.kysely.destroy();
   }