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

package/dist/index.cjs

@@ -90,7 +90,6 @@ __export(query_utils_exports, {
   requireField: () => requireField,
   requireIdFields: () => requireIdFields,
   requireModel: () => requireModel,
-  safeJSONStringify: () => safeJSONStringify,
   stripAlias: () => stripAlias
 });
 var import_common_helpers = require("@zenstackhq/common-helpers");
@@ -205,10 +204,11 @@ var InputValidationError = class extends ZenStackError {
   static {
     __name(this, "InputValidationError");
   }
-  constructor(message, cause) {
+  model;
+  constructor(model, message, cause) {
     super(message, {
       cause
-    });
+    }), this.model = model;
   }
 };
 var QueryError = class extends ZenStackError {
@@ -230,8 +230,9 @@ var NotFoundError = class extends ZenStackError {
   static {
     __name(this, "NotFoundError");
   }
+  model;
   constructor(model, details) {
-    super(`Entity not found for model "${model}"${details ? `: ${details}` : ""}`);
+    super(`Entity not found for model "${model}"${details ? `: ${details}` : ""}`), this.model = model;
   }
 };
 var RejectedByPolicyReason = /* @__PURE__ */ function(RejectedByPolicyReason2) {
@@ -545,16 +546,6 @@ function ensureArray(value) {
   }
 }
 __name(ensureArray, "ensureArray");
-function safeJSONStringify(value) {
-  return JSON.stringify(value, (_, v) => {
-    if (typeof v === "bigint") {
-      return v.toString();
-    } else {
-      return v;
-    }
-  });
-}
-__name(safeJSONStringify, "safeJSONStringify");
 function extractIdFields(entity, schema, model) {
   const idFields = requireIdFields(schema, model);
   return extractFields(entity, idFields);
@@ -1415,7 +1406,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     }
   }
   transformOutputBytes(value) {
-    return Buffer.isBuffer(value) ? Uint8Array.from(value) : value;
+    return Buffer.isBuffer(value) ? Uint8Array.from(value) : typeof value === "string" && value.startsWith("\\x") ? Uint8Array.from(Buffer.from(value.slice(2), "hex")) : value;
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     const relationResultName = `${parentAlias}$${relationField}`;
@@ -1937,7 +1928,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.`);
@@ -1990,8 +1981,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"
     }));
@@ -2196,7 +2187,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
@@ -2265,8 +2256,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;
     }
   }
@@ -2346,7 +2337,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");
     }
@@ -2452,8 +2443,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"
       }));
@@ -2545,7 +2536,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");
     }
@@ -2602,8 +2593,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;
     }
@@ -3007,7 +2998,7 @@ var BaseOperationHandler = class {
         });
       }
     }
-    if (throwForNotFound && expectedDeleteCount > deleteResult.count) {
+    if (throwForNotFound && expectedDeleteCount > deleteResult.rows.length) {
       throw new NotFoundError(deleteFromModel);
     }
   }
@@ -3015,7 +3006,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) {
@@ -3024,7 +3015,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;
@@ -3044,10 +3036,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)) {
@@ -3101,7 +3090,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);
     }
   }
@@ -3153,6 +3142,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
@@ -3313,14 +3344,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`);
@@ -3339,15 +3375,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;
+      }
     });
   }
 };
@@ -3363,27 +3404,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
+      };
     });
   }
 };
@@ -3524,29 +3572,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) {
@@ -3558,19 +3608,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");
@@ -3578,23 +3636,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
@@ -4044,7 +4128,7 @@ var InputValidator = class {
     }
     const { error, data } = schema.safeParse(args);
     if (error) {
-      throw new InputValidationError(`Invalid ${operation} args for model "${model}": ${formatError(error)}`, error);
+      throw new InputValidationError(model, `Invalid ${operation} args for model "${model}": ${formatError(error)}`, error);
     }
     return data;
   }
@@ -5598,7 +5682,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;
         }
@@ -6199,9 +6283,15 @@ var SchemaDbPusher = class {
     table = table.addForeignKeyConstraint(`fk_${model}_${fieldName}`, fieldDef.relation.fields.map((f) => this.getColumnName(modelDef.fields[f])), this.getTableName(relationModelDef), fieldDef.relation.references.map((f) => this.getColumnName(relationModelDef.fields[f])), (cb) => {
       if (fieldDef.relation?.onDelete) {
         cb = cb.onDelete(this.mapCascadeAction(fieldDef.relation.onDelete));
+      } else if (fieldDef.optional) {
+        cb = cb.onDelete("set null");
+      } else {
+        cb = cb.onDelete("restrict");
       }
       if (fieldDef.relation?.onUpdate) {
         cb = cb.onUpdate(this.mapCascadeAction(fieldDef.relation.onUpdate));
+      } else {
+        cb = cb.onUpdate("cascade");
       }
       return cb;
     });