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

package/dist/index.js

@@ -1891,7 +1891,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.`);
@@ -1944,8 +1944,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"
     }));
@@ -2150,7 +2150,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
@@ -2219,8 +2219,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;
     }
   }
@@ -2300,7 +2300,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");
     }
@@ -2406,8 +2406,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"
       }));
@@ -2499,7 +2499,7 @@ var BaseOperationHandler = class {
   makeContextComment(_context) {
     return sql4``;
   }
-  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");
     }
@@ -2556,8 +2556,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;
     }
@@ -2961,7 +2961,7 @@ var BaseOperationHandler = class {
         });
       }
     }
-    if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
+    if (throwForNotFound && expectedDeleteCount > deleteResult.rows.length) {
       throw new NotFoundError(deleteFromModel);
     }
   }
@@ -2969,7 +2969,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) {
@@ -2978,7 +2978,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;
@@ -2998,10 +2999,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)) {
@@ -3055,7 +3053,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);
     }
   }
@@ -3107,6 +3105,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
@@ -3267,14 +3307,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`);
@@ -3293,15 +3338,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;
+      }
     });
   }
 };
@@ -3317,27 +3367,34 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     return match9(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
+      };
     });
   }
 };
@@ -3478,29 +3535,31 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     return match11(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) {
@@ -3512,19 +3571,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");
@@ -3532,23 +3599,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
@@ -5552,7 +5645,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       try {
         if (this.isMutationNode(compiledQuery.query) && !this.driver.isTransactionConnection(connection)) {
           await this.driver.beginTransaction(connection, {
-            isolationLevel: TransactionIsolationLevel.RepeatableRead
+            isolationLevel: TransactionIsolationLevel.ReadCommitted
           });
           startedTx = true;
         }