@zenstackhq/runtime 3.0.0-alpha.7 → 3.0.0-alpha.9

package/dist/index.cjs

@@ -31,12 +31,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ZenStackClient: () => ZenStackClient
+  InputValidationError: () => InputValidationError,
+  InternalError: () => InternalError,
+  NotFoundError: () => NotFoundError,
+  QueryError: () => QueryError,
+  ZenStackClient: () => ZenStackClient,
+  definePlugin: () => definePlugin
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely16 = require("kysely");
 var import_ts_pattern19 = require("ts-pattern");
 
@@ -45,12 +50,24 @@ var import_kysely9 = require("kysely");
 var import_ts_pattern9 = require("ts-pattern");
 
 // src/client/errors.ts
+var InputValidationError = class extends Error {
+  static {
+    __name(this, "InputValidationError");
+  }
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
+  }
+};
 var QueryError = class extends Error {
   static {
     __name(this, "QueryError");
   }
-  constructor(message) {
-    super(message);
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
   }
 };
 var InternalError = class extends Error {
@@ -78,7 +95,7 @@ __name(getModel, "getModel");
 function requireModel(schema, model) {
   const matchedName = Object.keys(schema.models).find((k) => k.toLowerCase() === model.toLowerCase());
   if (!matchedName) {
-    throw new QueryError(`Model "${model}" not found`);
+    throw new QueryError(`Model "${model}" not found in schema`);
   }
   return schema.models[matchedName];
 }
@@ -203,7 +220,7 @@ function buildFieldRef(schema, model, field, options, eb, modelAlias) {
       computer = computedFields?.[model]?.[field];
     }
     if (!computer) {
-      throw new QueryError(`Computed field "${field}" implementation not provided`);
+      throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
     }
     return computer(eb);
   }
@@ -314,6 +331,7 @@ var import_cuid2 = require("@paralleldrive/cuid2");
 var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_kysely8 = require("kysely");
 var import_nanoid = require("nanoid");
+var import_node_util = require("util");
 var import_ts_pattern8 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
@@ -373,7 +391,7 @@ var BaseCrudDialect = class {
     this.schema = schema;
     this.options = options;
   }
-  transformPrimitive(value, _type) {
+  transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
   buildFilter(eb, model, modelAlias, where) {
@@ -516,7 +534,7 @@ var BaseCrudDialect = class {
       if (_value === void 0) {
         continue;
       }
-      const value = this.transformPrimitive(_value, fieldType);
+      const value = this.transformPrimitive(_value, fieldType, !!fieldDef.array);
       switch (key) {
         case "equals": {
           clauses.push(this.buildLiteralFilter(eb, fieldRef, fieldType, eb.val(value)));
@@ -554,10 +572,14 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(eb, modelAlias, field, fieldDef, payload);
     }
-    return (0, import_ts_pattern.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(import_ts_pattern.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, model, modelAlias, field, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, modelAlias, field, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, modelAlias, field, payload)).with("Bytes", () => this.buildBytesFilter(eb, modelAlias, field, payload)).exhaustive();
+    return (0, import_ts_pattern.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(import_ts_pattern.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, model, modelAlias, field, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, modelAlias, field, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, modelAlias, field, payload)).with("Bytes", () => this.buildBytesFilter(eb, modelAlias, field, payload)).with("Json", () => {
+      throw new InternalError("JSON filters are not supported yet");
+    }).with("Unsupported", () => {
+      throw new QueryError(`Unsupported field cannot be used in filters`);
+    }).exhaustive();
   }
   buildLiteralFilter(eb, lhs, type, rhs) {
-    return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type) : rhs);
+    return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type, false) : rhs);
   }
   buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0) {
     if (payload === null || !(0, import_common_helpers.isPlainObject)(payload)) {
@@ -644,22 +666,22 @@ var BaseCrudDialect = class {
     }
   }
   buildNumberFilter(eb, model, table, field, type, payload) {
-    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type), (value) => this.buildNumberFilter(eb, model, table, field, type, value));
+    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, model, table, field, type, value));
     return this.and(eb, ...conditions);
   }
   buildBooleanFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean"), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
       "equals",
       "not"
     ]);
     return this.and(eb, ...conditions);
   }
   buildDateTimeFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime"), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
     return this.and(eb, ...conditions);
   }
   buildBytesFilter(eb, table, field, payload) {
-    const conditions = this.buildStandardFilter(eb, "Bytes", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes"), (value) => this.buildBytesFilter(eb, table, field, value), true, [
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, import_kysely.sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, table, field, value), true, [
       "equals",
       "in",
       "notIn",
@@ -758,10 +780,10 @@ var BaseCrudDialect = class {
     return negated ? sort === "asc" ? "desc" : "asc" : sort;
   }
   true(eb) {
-    return eb.lit(this.transformPrimitive(true, "Boolean"));
+    return eb.lit(this.transformPrimitive(true, "Boolean", false));
   }
   false(eb) {
-    return eb.lit(this.transformPrimitive(false, "Boolean"));
+    return eb.lit(this.transformPrimitive(false, "Boolean", false));
   }
   isTrue(expression) {
     const node = expression.toOperationNode();
@@ -810,14 +832,18 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "postgresql";
   }
-  transformPrimitive(value, type) {
+  transformPrimitive(value, type, forArrayField) {
     if (value === void 0) {
       return value;
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type));
+      if (type === "Json" && !forArrayField) {
+        return JSON.stringify(value);
+      } else {
+        return value.map((v) => this.transformPrimitive(v, type, false));
+      }
     } else {
-      return (0, import_ts_pattern2.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).otherwise(() => value);
+      return (0, import_ts_pattern2.match)(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -884,25 +910,33 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         buildFieldRef(this.schema, relationModel, field, this.options, eb)
       ]).flatMap((v) => v));
     } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field]) => [
-        import_kysely2.sql.lit(field),
-        buildFieldRef(this.schema, relationModel, field, this.options, eb)
-      ]).flatMap((v) => v));
+      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field]) => {
+        const fieldDef = requireField(this.schema, relationModel, field);
+        const fieldValue = fieldDef.relation ? eb.ref(`${parentName}$${relationField}$${field}.$j`) : buildFieldRef(this.schema, relationModel, field, this.options, eb);
+        return [
+          import_kysely2.sql.lit(field),
+          fieldValue
+        ];
+      }).flatMap((v) => v));
     }
     if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
       objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => [
         import_kysely2.sql.lit(field),
+        // reference the synthesized JSON field
         eb.ref(`${parentName}$${relationField}$${field}.$j`)
       ]).flatMap((v) => v));
     }
     return objArgs;
   }
-  buildRelationJoins(model, relationField, qb, payload, parentName) {
+  buildRelationJoins(relationModel, relationField, qb, payload, parentName) {
     let result = qb;
-    if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
-      Object.entries(payload.include).filter(([, value]) => value).forEach(([field, value]) => {
-        result = this.buildRelationJSON(model, result, field, `${parentName}$${relationField}`, value);
-      });
+    if (typeof payload === "object") {
+      const selectInclude = payload.include ?? payload.select;
+      if (selectInclude && typeof selectInclude === "object") {
+        Object.entries(selectInclude).filter(([, value]) => value).filter(([field]) => isRelationField(this.schema, relationModel, field)).forEach(([field, value]) => {
+          result = this.buildRelationJSON(relationModel, result, field, `${parentName}$${relationField}`, value);
+        });
+      }
     }
     return result;
   }
@@ -955,14 +989,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "sqlite";
   }
-  transformPrimitive(value, type) {
+  transformPrimitive(value, type, _forArrayField) {
     if (value === void 0) {
       return value;
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type));
+      return value.map((v) => this.transformPrimitive(v, type, false));
     } else {
-      return (0, import_ts_pattern3.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
+      return (0, import_ts_pattern3.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -1567,11 +1601,11 @@ var ExpressionEvaluator = class {
 // src/plugins/policy/utils.ts
 var import_kysely5 = require("kysely");
 function trueNode(dialect) {
-  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean"));
+  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
 }
 __name(trueNode, "trueNode");
 function falseNode(dialect) {
-  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean"));
+  return import_kysely5.ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
 }
 __name(falseNode, "falseNode");
 function isTrueNode(node) {
@@ -1829,7 +1863,7 @@ var ExpressionTransformer = class {
     }
   }
   transformValue(value, type) {
-    return import_kysely6.ValueNode.create(this.dialect.transformPrimitive(value, type) ?? null);
+    return import_kysely6.ValueNode.create(this.dialect.transformPrimitive(value, type, false) ?? null);
   }
   _unary(expr2, context) {
     (0, import_common_helpers5.invariant)(expr2.op === "!", 'only "!" operator is supported');
@@ -2072,7 +2106,7 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
   get kysely() {
     return this.client.$qb;
   }
-  async handle(node, proceed, transaction) {
+  async handle(node, proceed) {
     if (!this.isCrudQueryNode(node)) {
       throw new RejectedByPolicyError(void 0, "non-CRUD queries are not allowed");
     }
@@ -2092,27 +2126,20 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     if (!mutationRequiresTransaction && !node.returning) {
       return proceed(this.transformNode(node));
     }
-    let readBackError = false;
-    const result = await transaction(async (txProceed) => {
-      if (import_kysely7.InsertQueryNode.is(node)) {
-        await this.enforcePreCreatePolicy(node, txProceed);
-      }
-      const transformedNode = this.transformNode(node);
-      const result2 = await txProceed(transformedNode);
-      if (!this.onlyReturningId(node)) {
-        const readBackResult = await this.processReadBack(node, result2, txProceed);
-        if (readBackResult.rows.length !== result2.rows.length) {
-          readBackError = true;
-        }
-        return readBackResult;
-      } else {
-        return result2;
+    if (import_kysely7.InsertQueryNode.is(node)) {
+      await this.enforcePreCreatePolicy(node, proceed);
+    }
+    const transformedNode = this.transformNode(node);
+    const result = await proceed(transformedNode);
+    if (!this.onlyReturningId(node)) {
+      const readBackResult = await this.processReadBack(node, result, proceed);
+      if (readBackResult.rows.length !== result.rows.length) {
+        throw new RejectedByPolicyError(mutationModel, "result is not allowed to be read back");
       }
-    });
-    if (readBackError) {
-      throw new RejectedByPolicyError(mutationModel, "result is not allowed to be read back");
+      return readBackResult;
+    } else {
+      return result;
     }
-    return result;
   }
   onlyReturningId(node) {
     if (!node.returning) {
@@ -2173,11 +2200,11 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
       if (typeof item === "object" && item && "kind" in item) {
         (0, import_common_helpers6.invariant)(item.kind === "ValueNode", "expecting a ValueNode");
         result.push({
-          node: import_kysely7.ValueNode.create(this.dialect.transformPrimitive(item.value, fieldDef.type)),
+          node: import_kysely7.ValueNode.create(this.dialect.transformPrimitive(item.value, fieldDef.type, !!fieldDef.array)),
           raw: item.value
         });
       } else {
-        const value = this.dialect.transformPrimitive(item, fieldDef.type);
+        const value = this.dialect.transformPrimitive(item, fieldDef.type, !!fieldDef.array);
         if (Array.isArray(value)) {
           result.push({
             node: import_kysely7.RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
@@ -2408,9 +2435,18 @@ var PolicyPlugin = class {
   get description() {
     return "Enforces access policies defined in the schema.";
   }
-  onKyselyQuery({ query, client, proceed, transaction }) {
+  onKyselyQuery({
+    query,
+    client,
+    proceed
+    /*, transaction*/
+  }) {
     const handler = new PolicyHandler(client);
-    return handler.handle(query, proceed, transaction);
+    return handler.handle(
+      query,
+      proceed
+      /*, transaction*/
+    );
   }
 };
 
@@ -2550,8 +2586,13 @@ var BaseOperationHandler = class {
     try {
       result = await query.execute();
     } catch (err) {
-      const { sql: sql10, parameters } = query.compile();
-      throw new QueryError(`Failed to execute query: ${err}, sql: ${sql10}, parameters: ${parameters}`);
+      const { sql: sql11, parameters } = query.compile();
+      let message = `Failed to execute query: ${err}, sql: ${sql11}`;
+      if (this.options.debug) {
+        message += `, parameters: 
+${parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
     if (inMemoryDistinct) {
       const distinctResult = [];
@@ -2610,30 +2651,20 @@ var BaseOperationHandler = class {
     for (const [field, value] of Object.entries(selections.select)) {
       const fieldDef = requireField(this.schema, model, field);
       const fieldModel = fieldDef.type;
-      const jointTable = `${parentAlias}$${field}$count`;
-      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, jointTable);
-      query = query.leftJoin((eb2) => {
-        let result = eb2.selectFrom(fieldModel).selectAll();
-        if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
-          const filter = this.dialect.buildFilter(eb2, fieldModel, fieldModel, value.where);
-          result = result.where(filter);
-        }
-        return result.as(jointTable);
-      }, (join) => {
-        for (const [left, right] of joinPairs) {
-          join = join.onRef(left, "=", right);
-        }
-        return join;
-      });
-      jsonObject[field] = this.countIdDistinct(eb, fieldDef.type, jointTable);
+      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
+      let fieldCountQuery = eb.selectFrom(fieldModel).select(eb.fn.countAll().as(`_count$${field}`));
+      for (const [left, right] of joinPairs) {
+        fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
+      }
+      if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
+        const filter = this.dialect.buildFilter(eb, fieldModel, fieldModel, value.where);
+        fieldCountQuery = fieldCountQuery.where(filter);
+      }
+      jsonObject[field] = fieldCountQuery;
     }
     query = query.select((eb2) => this.dialect.buildJsonObject(eb2, jsonObject).as("_count"));
     return query;
   }
-  countIdDistinct(eb, model, table) {
-    const idFields = getIdFields(this.schema, model);
-    return eb.fn.count(import_kysely8.sql.join(idFields.map((f) => import_kysely8.sql.ref(`${table}.${f}`)))).distinct();
-  }
   buildSelectAllScalarFields(model, query, omit) {
     const modelDef = this.requireModel(model);
     return Object.keys(modelDef.fields).filter((f) => !isRelationField(this.schema, model, f)).filter((f) => omit?.[f] !== true).reduce((acc, f) => this.selectField(acc, model, model, f), query);
@@ -2699,14 +2730,14 @@ var BaseOperationHandler = class {
       const fieldDef = this.requireField(model, field);
       if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) {
         if (fieldDef.array && value && typeof value === "object" && "set" in value && Array.isArray(value.set)) {
-          createFields[field] = this.dialect.transformPrimitive(value.set, fieldDef.type);
+          createFields[field] = this.dialect.transformPrimitive(value.set, fieldDef.type, true);
         } else {
-          createFields[field] = this.dialect.transformPrimitive(value, fieldDef.type);
+          createFields[field] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
         }
       } else {
         const subM2M = getManyToManyRelation(this.schema, model, field);
         if (!subM2M && fieldDef.relation?.fields && fieldDef.relation?.references) {
-          const fkValues = await this.processOwnedRelation(kysely, fieldDef, value);
+          const fkValues = await this.processOwnedRelationForCreate(kysely, fieldDef, value);
           for (let i = 0; i < fieldDef.relation.fields.length; i++) {
             createFields[fieldDef.relation.fields[i]] = fkValues[fieldDef.relation.references[i]];
           }
@@ -2727,7 +2758,7 @@ var BaseOperationHandler = class {
     const createdEntity = await query.executeTakeFirst();
     if (Object.keys(postCreateRelations).length > 0) {
       const relationPromises = Object.entries(postCreateRelations).map(([field, subPayload]) => {
-        return this.processNoneOwnedRelation(kysely, model, field, subPayload, createdEntity);
+        return this.processNoneOwnedRelationForCreate(kysely, model, field, subPayload, createdEntity);
       });
       await Promise.all(relationPromises);
     }
@@ -2794,7 +2825,7 @@ var BaseOperationHandler = class {
     const eb = (0, import_kysely8.expressionBuilder)();
     return kysely.deleteFrom(m2m.joinTable).where(eb(`${m2m.joinTable}.${m2m.parentFkName}`, "=", parentId)).execute();
   }
-  async processOwnedRelation(kysely, relationField, payload) {
+  async processOwnedRelationForCreate(kysely, relationField, payload) {
     if (!payload) {
       return;
     }
@@ -2844,21 +2875,27 @@ var BaseOperationHandler = class {
     }
     return result;
   }
-  processNoneOwnedRelation(kysely, contextModel, relationFieldName, payload, parentEntity) {
+  processNoneOwnedRelationForCreate(kysely, contextModel, relationFieldName, payload, parentEntity) {
     const relationFieldDef = this.requireField(contextModel, relationFieldName);
     const relationModel = relationFieldDef.type;
     const tasks = [];
+    const fromRelationContext = {
+      model: contextModel,
+      field: relationFieldName,
+      ids: parentEntity
+    };
     for (const [action, subPayload] of Object.entries(payload)) {
       if (!subPayload) {
         continue;
       }
       switch (action) {
         case "create": {
-          tasks.push(...enumerate(subPayload).map((item) => this.create(kysely, relationModel, item, {
-            model: contextModel,
-            field: relationFieldName,
-            ids: parentEntity
-          })));
+          tasks.push(...enumerate(subPayload).map((item) => this.create(kysely, relationModel, item, fromRelationContext)));
+          break;
+        }
+        case "createMany": {
+          (0, import_common_helpers8.invariant)(relationFieldDef.array, "relation must be an array for createMany");
+          tasks.push(this.createMany(kysely, relationModel, subPayload, false, fromRelationContext));
           break;
         }
         case "connect": {
@@ -2888,6 +2925,11 @@ var BaseOperationHandler = class {
     return Promise.all(tasks);
   }
   async createMany(kysely, model, input, returnData, fromRelation) {
+    if (!input.data || Array.isArray(input.data) && input.data.length === 0) {
+      return returnData ? [] : {
+        count: 0
+      };
+    }
     const modelDef = this.requireModel(model);
     let relationKeyPairs = [];
     if (fromRelation) {
@@ -2902,7 +2944,7 @@ var BaseOperationHandler = class {
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
         (0, import_common_helpers8.invariant)(!fieldDef.relation, "createMany does not support relations");
-        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type);
+        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
       }
       if (fromRelation) {
         for (const { fk, pk } of relationKeyPairs) {
@@ -2937,7 +2979,7 @@ var BaseOperationHandler = class {
             values[field] = generated;
           }
         } else if (fields[field]?.updatedAt) {
-          values[field] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime");
+          values[field] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
         }
       }
     }
@@ -3002,7 +3044,7 @@ var BaseOperationHandler = class {
         if (finalData === data) {
           finalData = clone(data);
         }
-        finalData[fieldName] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime");
+        finalData[fieldName] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
       }
     }
     if (Object.keys(finalData).length === 0) {
@@ -3027,7 +3069,7 @@ var BaseOperationHandler = class {
           updateFields[field] = this.transformScalarListUpdate(model, field, fieldDef, finalData[field]);
           continue;
         }
-        updateFields[field] = this.dialect.transformPrimitive(finalData[field], fieldDef.type);
+        updateFields[field] = this.dialect.transformPrimitive(finalData[field], fieldDef.type, !!fieldDef.array);
       } else {
         if (!allowRelationUpdate) {
           throw new QueryError(`Relation update not allowed for field "${field}"`);
@@ -3072,7 +3114,7 @@ var BaseOperationHandler = class {
   transformIncrementalUpdate(model, field, fieldDef, payload) {
     (0, import_common_helpers8.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
     const key = Object.keys(payload)[0];
-    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type);
+    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely8.expressionBuilder)();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
     return (0, import_ts_pattern8.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(() => {
@@ -3082,7 +3124,7 @@ var BaseOperationHandler = class {
   transformScalarListUpdate(model, field, fieldDef, payload) {
     (0, import_common_helpers8.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
     const key = Object.keys(payload)[0];
-    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type);
+    const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely8.expressionBuilder)();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
     return (0, import_ts_pattern8.match)(key).with("set", () => value).with("push", () => {
@@ -3112,7 +3154,7 @@ var BaseOperationHandler = class {
       if (isRelationField(this.schema, model, field)) {
         continue;
       }
-      updateFields[field] = this.dialect.transformPrimitive(data[field], fieldDef.type);
+      updateFields[field] = this.dialect.transformPrimitive(data[field], fieldDef.type, !!fieldDef.array);
     }
     let query = kysely.updateTable(model).set(updateFields);
     if (limit === void 0) {
@@ -3130,20 +3172,15 @@ var BaseOperationHandler = class {
       model,
       operation: "update"
     }));
-    try {
-      if (!returnData) {
-        const result = await query.executeTakeFirstOrThrow();
-        return {
-          count: Number(result.numUpdatedRows)
-        };
-      } else {
-        const idFields = getIdFields(this.schema, model);
-        const result = await query.returning(idFields).execute();
-        return result;
-      }
-    } catch (err) {
-      const { sql: sql10, parameters } = query.compile();
-      throw new QueryError(`Error during updateMany: ${err}, sql: ${sql10}, parameters: ${parameters}`);
+    if (!returnData) {
+      const result = await query.executeTakeFirstOrThrow();
+      return {
+        count: Number(result.numUpdatedRows)
+      };
+    } else {
+      const idFields = getIdFields(this.schema, model);
+      const result = await query.returning(idFields).execute();
+      return result;
     }
   }
   buildIdFieldRefs(kysely, model) {
@@ -3563,11 +3600,15 @@ var BaseOperationHandler = class {
     }
     return returnRelation;
   }
-  async safeTransaction(callback) {
+  async safeTransaction(callback, isolationLevel) {
     if (this.kysely.isTransaction) {
       return callback(this.kysely);
     } else {
-      return this.kysely.transaction().setIsolationLevel("repeatable read").execute(callback);
+      let txBuilder = this.kysely.transaction();
+      if (isolationLevel) {
+        txBuilder = txBuilder.setIsolationLevel(isolationLevel);
+      }
+      return txBuilder.execute(callback);
     }
   }
   // Given a unique filter of a model, return the entity ids by trying to
@@ -3586,6 +3627,28 @@ var BaseOperationHandler = class {
       where: uniqueFilter
     });
   }
+  /**
+   * Normalize input args to strip `undefined` fields
+   */
+  normalizeArgs(args) {
+    if (!args) {
+      return;
+    }
+    const newArgs = clone(args);
+    this.doNormalizeArgs(newArgs);
+    return newArgs;
+  }
+  doNormalizeArgs(args) {
+    if (args && typeof args === "object") {
+      for (const [key, value] of Object.entries(args)) {
+        if (value === void 0) {
+          delete args[key];
+        } else if (value && (0, import_common_helpers8.isPlainObject)(value)) {
+          this.doNormalizeArgs(value);
+        }
+      }
+    }
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -3594,21 +3657,22 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
     __name(this, "AggregateOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateAggregateArgs(this.model, args);
+    const normalizeArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateAggregateArgs(this.model, normalizeArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll(this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, validatedArgs?.where));
-      const skip = validatedArgs?.skip;
-      let take = validatedArgs?.take;
+      let subQuery = eb.selectFrom(this.model).selectAll(this.model).where((eb1) => this.dialect.buildFilter(eb1, 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, validatedArgs.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
       return subQuery.as("$sub");
     });
-    for (const [key, value] of Object.entries(validatedArgs)) {
+    for (const [key, value] of Object.entries(parsedArgs)) {
       switch (key) {
         case "_count": {
           if (value === true) {
@@ -3687,14 +3751,15 @@ var CountOperationHandler = class extends BaseOperationHandler {
     __name(this, "CountOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateCountArgs(this.model, args);
+    const normalizeArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateCountArgs(this.model, normalizeArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, validatedArgs?.where));
-      subQuery = this.dialect.buildSkipTake(subQuery, validatedArgs?.skip, validatedArgs?.take);
+      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      subQuery = this.dialect.buildSkipTake(subQuery, parsedArgs?.skip, parsedArgs?.take);
       return subQuery.as("$sub");
     });
-    if (validatedArgs?.select && typeof validatedArgs.select === "object") {
-      query = query.select((eb) => Object.keys(validatedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(import_kysely10.sql.ref(`$sub.${key}`)), "integer").as(key)));
+    if (parsedArgs?.select && typeof parsedArgs.select === "object") {
+      query = query.select((eb) => Object.keys(parsedArgs.select).map((key) => key === "_all" ? eb.cast(eb.fn.countAll(), "integer").as("_all") : eb.cast(eb.fn.count(import_kysely10.sql.ref(`$sub.${key}`)), "integer").as(key)));
       return query.executeTakeFirstOrThrow();
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
@@ -3711,10 +3776,11 @@ var CreateOperationHandler = class extends BaseOperationHandler {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
-    return (0, import_ts_pattern10.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, args))).with("createMany", () => {
-      return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, args));
+    const normalizeArgs = this.normalizeArgs(args);
+    return (0, import_ts_pattern10.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizeArgs))).with("createMany", () => {
+      return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, normalizeArgs));
     }).with("createManyAndReturn", () => {
-      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, args));
+      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizeArgs));
     }).exhaustive();
   }
   async runCreate(args) {
@@ -3764,7 +3830,8 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
-    return (0, import_ts_pattern11.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, args))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, args))).exhaustive();
+    const normalizeArgs = this.normalizeArgs(args);
+    return (0, import_ts_pattern11.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizeArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizeArgs))).exhaustive();
   }
   async runDelete(args) {
     const existing = await this.readUnique(this.kysely, this.model, {
@@ -3794,7 +3861,8 @@ var FindOperationHandler = class extends BaseOperationHandler {
     __name(this, "FindOperationHandler");
   }
   async handle(operation, args, validateArgs = true) {
-    const parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, operation === "findUnique", args) : args;
+    const normalizeArgs = this.normalizeArgs(args);
+    const parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, operation === "findUnique", normalizeArgs) : normalizeArgs;
     const result = await this.read(this.client.$qb, this.model, parsedArgs);
     const finalResult = operation === "findMany" ? result : result[0] ?? null;
     return finalResult;
@@ -3809,11 +3877,12 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
     __name(this, "GroupByeOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateGroupByArgs(this.model, args);
+    const normalizeArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateGroupByArgs(this.model, normalizeArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, validatedArgs?.where));
-      const skip = validatedArgs?.skip;
-      let take = validatedArgs?.take;
+      let subQuery = eb.selectFrom(this.model).selectAll().where((eb1) => this.dialect.buildFilter(eb1, 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;
@@ -3823,20 +3892,20 @@ var GroupByeOperationHandler = class extends BaseOperationHandler {
       subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, void 0, skip !== void 0 || take !== void 0, negateOrderBy);
       return subQuery.as("$sub");
     });
-    const bys = typeof validatedArgs.by === "string" ? [
-      validatedArgs.by
-    ] : validatedArgs.by;
+    const bys = typeof parsedArgs.by === "string" ? [
+      parsedArgs.by
+    ] : parsedArgs.by;
     query = query.groupBy(bys);
-    if (validatedArgs.orderBy) {
-      query = this.dialect.buildOrderBy(query, this.model, "$sub", validatedArgs.orderBy, false, false);
+    if (parsedArgs.orderBy) {
+      query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
     }
-    if (validatedArgs.having) {
-      query = query.having((eb1) => this.dialect.buildFilter(eb1, this.model, "$sub", validatedArgs.having));
+    if (parsedArgs.having) {
+      query = query.having((eb1) => this.dialect.buildFilter(eb1, this.model, "$sub", parsedArgs.having));
     }
     for (const by of bys) {
       query = query.select(() => import_kysely11.sql.ref(`$sub.${by}`).as(by));
     }
-    for (const [key, value] of Object.entries(validatedArgs)) {
+    for (const [key, value] of Object.entries(parsedArgs)) {
       switch (key) {
         case "_count": {
           if (value === true) {
@@ -3919,7 +3988,8 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
-    return (0, import_ts_pattern13.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, args))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, args))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, args))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, args))).exhaustive();
+    const normalizeArgs = this.normalizeArgs(args);
+    return (0, import_ts_pattern13.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizeArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizeArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizeArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizeArgs))).exhaustive();
   }
   async runUpdate(args) {
     const result = await this.safeTransaction(async (tx) => {
@@ -3975,6 +4045,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator.ts
+var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
 var import_ts_pattern14 = require("ts-pattern");
@@ -4043,7 +4114,7 @@ var InputValidator = class {
     }
     const { error } = schema.safeParse(args);
     if (error) {
-      throw new QueryError(`Invalid ${operation} args: ${error.message}`);
+      throw new InputValidationError(`Invalid ${operation} args: ${error.message}`, error);
     }
     return args;
   }
@@ -4090,7 +4161,7 @@ var InputValidator = class {
   makeWhereSchema(model, unique, withoutRelationFields = false) {
     const modelDef = getModel(this.schema, model);
     if (!modelDef) {
-      throw new QueryError(`Model "${model}" not found`);
+      throw new QueryError(`Model "${model}" not found in schema`);
     }
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
@@ -4140,10 +4211,24 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = import_v4.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => [
-            key,
-            this.makePrimitiveFilterSchema(def.type, !!def.optional)
-          ]))).optional();
+          fields[uniqueField.name] = import_v4.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+            (0, import_common_helpers9.invariant)(!def.relation, "unique field cannot be a relation");
+            let fieldSchema;
+            const enumDef = getEnum(this.schema, def.type);
+            if (enumDef) {
+              if (Object.keys(enumDef).length > 0) {
+                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional);
+              } else {
+                fieldSchema = import_v4.z.never();
+              }
+            } else {
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional);
+            }
+            return [
+              key,
+              fieldSchema
+            ];
+          }))).optional();
         }
       }
     }
@@ -4193,7 +4278,7 @@ var InputValidator = class {
     });
   }
   makePrimitiveFilterSchema(type, optional) {
-    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).exhaustive();
+    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).with("Json", () => import_v4.z.any()).with("Unsupported", () => import_v4.z.never()).exhaustive();
   }
   makeDateTimeFilterSchema(optional) {
     return this.makeCommonPrimitiveFilterSchema(import_v4.z.union([
@@ -4387,8 +4472,8 @@ var InputValidator = class {
     return this.refineForSelectOmitMutuallyExclusive(result).optional();
   }
   makeCreateDataSchema(model, canBeArray, withoutFields = [], withoutRelationFields = false) {
-    const regularAndFkFields = {};
-    const regularAndRelationFields = {};
+    const uncheckedVariantFields = {};
+    const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
     const hasRelation = !withoutRelationFields && Object.entries(modelDef.fields).some(([f, def]) => !withoutFields.includes(f) && def.relation);
     Object.keys(modelDef.fields).forEach((field) => {
@@ -4430,7 +4515,10 @@ var InputValidator = class {
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
-        regularAndRelationFields[field] = fieldSchema;
+        checkedVariantFields[field] = fieldSchema;
+        if (fieldDef.array || !fieldDef.relation.references) {
+          uncheckedVariantFields[field] = fieldSchema;
+        }
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type);
         if (fieldDef.array) {
@@ -4447,23 +4535,23 @@ var InputValidator = class {
         if (fieldDef.optional) {
           fieldSchema = fieldSchema.nullable();
         }
-        regularAndFkFields[field] = fieldSchema;
+        uncheckedVariantFields[field] = fieldSchema;
         if (!fieldDef.foreignKeyFor) {
-          regularAndRelationFields[field] = fieldSchema;
+          checkedVariantFields[field] = fieldSchema;
         }
       }
     });
     if (!hasRelation) {
-      return this.orArray(import_v4.z.object(regularAndFkFields).strict(), canBeArray);
+      return this.orArray(import_v4.z.object(uncheckedVariantFields).strict(), canBeArray);
     } else {
       return import_v4.z.union([
-        import_v4.z.object(regularAndFkFields).strict(),
-        import_v4.z.object(regularAndRelationFields).strict(),
+        import_v4.z.object(uncheckedVariantFields).strict(),
+        import_v4.z.object(checkedVariantFields).strict(),
         ...canBeArray ? [
-          import_v4.z.array(import_v4.z.object(regularAndFkFields).strict())
+          import_v4.z.array(import_v4.z.object(uncheckedVariantFields).strict())
         ] : [],
         ...canBeArray ? [
-          import_v4.z.array(import_v4.z.object(regularAndRelationFields).strict())
+          import_v4.z.array(import_v4.z.object(checkedVariantFields).strict())
         ] : []
       ]);
     }
@@ -4508,7 +4596,7 @@ var InputValidator = class {
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return import_v4.z.object(fields).strict().refine((v) => Object.keys(v).length > 0, "At least one action is required");
+    return import_v4.z.object(fields).strict();
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4945,6 +5033,7 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 var import_kysely13 = require("kysely");
 var import_nanoid2 = require("nanoid");
+var import_node_util2 = require("util");
 var import_ts_pattern15 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
@@ -5179,7 +5268,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       mutationInterceptionInfo = await this.callMutationInterceptionFilters(queryNode);
     }
     const task = /* @__PURE__ */ __name(async () => {
-      await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
+      if (this.isMutationNode(queryNode)) {
+        await this.callBeforeMutationHooks(queryNode, mutationInterceptionInfo);
+      }
       const oldQueryNode = queryNode;
       if ((import_kysely13.InsertQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
         queryNode = {
@@ -5189,19 +5280,19 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           ])
         };
       }
-      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryId);
-      await this.callAfterQueryInterceptionFilters(result, queryNode, mutationInterceptionInfo);
+      const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
+      const result = await this.proceedQueryWithKyselyInterceptors(queryNode, queryParams, queryId);
+      if (this.isMutationNode(queryNode)) {
+        await this.callAfterQueryInterceptionFilters(result, queryNode, mutationInterceptionInfo);
+      }
       if (oldQueryNode !== queryNode) {
       }
       return result;
     }, "task");
-    return this.executeWithTransaction(task, !!mutationInterceptionInfo?.useTransactionForMutation);
+    return task();
   }
-  proceedQueryWithKyselyInterceptors(queryNode, queryId) {
-    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, queryId), "proceed");
-    const makeTx = /* @__PURE__ */ __name((p) => (callback) => {
-      return this.executeWithTransaction(() => callback(p));
-    }, "makeTx");
+  proceedQueryWithKyselyInterceptors(queryNode, parameters, queryId) {
+    let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(q, parameters, queryId), "proceed");
     const hooks = this.options.plugins?.filter((plugin) => typeof plugin.onKyselyQuery === "function").map((plugin) => plugin.onKyselyQuery.bind(plugin)) ?? [];
     for (const hook of hooks) {
       const _proceed = proceed;
@@ -5211,20 +5302,30 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           schema: this.client.$schema,
           kysely: this.kysely,
           query,
-          proceed: _proceed,
-          transaction: makeTx(_proceed)
+          proceed: _proceed
         });
       }, "proceed");
     }
     return proceed(queryNode);
   }
-  async proceedQuery(query, queryId) {
+  async proceedQuery(query, parameters, queryId) {
     const finalQuery = this.nameMapper.transformNode(query);
-    const compiled = this.compileQuery(finalQuery);
+    let compiled = this.compileQuery(finalQuery);
+    if (parameters) {
+      compiled = {
+        ...compiled,
+        parameters
+      };
+    }
     try {
-      return this.driver.txConnection ? await super.withConnectionProvider(new import_kysely13.SingleConnectionProvider(this.driver.txConnection)).executeQuery(compiled, queryId) : await super.executeQuery(compiled, queryId);
+      return await super.executeQuery(compiled, queryId);
     } catch (err) {
-      throw new QueryError(`Failed to execute query: ${err}, sql: ${compiled.sql}, parameters: ${compiled.parameters}`);
+      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
+      if (this.options.debug) {
+        message += `, parameters: 
+${compiled.parameters.map((p) => (0, import_node_util2.inspect)(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
   }
   isMutationNode(queryNode) {
@@ -5252,24 +5353,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
     return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, []);
   }
   withConnectionProvider(connectionProvider) {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider);
-  }
-  async executeWithTransaction(callback, useTransaction = true) {
-    if (!useTransaction || this.driver.txConnection) {
-      return callback();
-    } else {
-      return this.provideConnection(async (connection) => {
-        try {
-          await this.driver.beginTransaction(connection, {});
-          const result = await callback();
-          await this.driver.commitTransaction(connection);
-          return result;
-        } catch (error) {
-          await this.driver.rollbackTransaction(connection);
-          throw error;
-        }
-      });
-    }
+    const newExecutor = new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider);
+    newExecutor.client = this.client.withExecutor(newExecutor);
+    return newExecutor;
   }
   get hasMutationHooks() {
     return this.client.$options.plugins?.some((plugin) => plugin.beforeEntityMutation || plugin.afterEntityMutation);
@@ -5311,14 +5397,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
             queryNode
           });
           result.intercept ||= filterResult.intercept;
-          result.useTransactionForMutation ||= filterResult.useTransactionForMutation;
           result.loadBeforeMutationEntity ||= filterResult.loadBeforeMutationEntity;
           result.loadAfterMutationEntity ||= filterResult.loadAfterMutationEntity;
         }
       }
       let beforeMutationEntities;
       if (result.loadBeforeMutationEntity && (import_kysely13.UpdateQueryNode.is(queryNode) || import_kysely13.DeleteQueryNode.is(queryNode))) {
-        beforeMutationEntities = await this.loadEntities(this.kysely, mutationModel, where);
+        beforeMutationEntities = await this.loadEntities(mutationModel, where);
       }
       return {
         ...result,
@@ -5331,15 +5416,14 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       return void 0;
     }
   }
-  callBeforeMutationHooks(queryNode, mutationInterceptionInfo) {
+  async callBeforeMutationHooks(queryNode, mutationInterceptionInfo) {
     if (!mutationInterceptionInfo?.intercept) {
       return;
     }
     if (this.options.plugins) {
       for (const plugin of this.options.plugins) {
         if (plugin.beforeEntityMutation) {
-          plugin.beforeEntityMutation({
-            // context: this.queryContext,
+          await plugin.beforeEntityMutation({
             model: this.getMutationModel(queryNode),
             action: mutationInterceptionInfo.action,
             queryNode,
@@ -5360,12 +5444,12 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
           let afterMutationEntities = void 0;
           if (mutationInterceptionInfo.loadAfterMutationEntity) {
             if (import_kysely13.UpdateQueryNode.is(queryNode)) {
-              afterMutationEntities = await this.loadEntities(this.kysely, mutationModel, mutationInterceptionInfo.where);
+              afterMutationEntities = await this.loadEntities(mutationModel, mutationInterceptionInfo.where);
             } else {
               afterMutationEntities = queryResult.rows;
             }
           }
-          plugin.afterEntityMutation({
+          await plugin.afterEntityMutation({
             model: this.getMutationModel(queryNode),
             action: mutationInterceptionInfo.action,
             queryNode,
@@ -5376,17 +5460,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
       }
     }
   }
-  async loadEntities(kysely, model, where) {
-    const selectQuery = kysely.selectFrom(model).selectAll();
+  async loadEntities(model, where) {
+    const selectQuery = this.kysely.selectFrom(model).selectAll();
     let selectQueryNode = selectQuery.toOperationNode();
     selectQueryNode = {
       ...selectQueryNode,
       where: this.andNodes(selectQueryNode.where, where)
     };
-    const compiled = kysely.getExecutor().compileQuery(selectQueryNode, {
+    const compiled = this.compileQuery(selectQueryNode);
+    const result = await this.executeQuery(compiled, {
       queryId: `zenstack-${(0, import_nanoid2.nanoid)()}`
     });
-    const result = await kysely.executeQuery(compiled);
     return result.rows;
   }
   andNodes(condition1, condition2) {
@@ -5415,7 +5499,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers9 = require("@zenstackhq/common-helpers");
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely14 = require("kysely");
 var import_ts_pattern16 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
@@ -5522,8 +5606,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers9.invariant)(import_kysely14.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_helpers9.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers9.lowerCaseFirst)(result)).otherwise(() => {
+  (0, import_common_helpers10.invariant)(import_kysely14.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_helpers10.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers10.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -5531,7 +5615,7 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
 var import_ts_pattern17 = require("ts-pattern");
 var SchemaDbPusher = class {
@@ -5588,7 +5672,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers10.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers11.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -5634,7 +5718,7 @@ var SchemaDbPusher = class {
       return "serial";
     }
     const type = fieldDef.type;
-    const result = (0, import_ts_pattern17.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").otherwise(() => {
+    const result = (0, import_ts_pattern17.match)(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
@@ -5647,7 +5731,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers10.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers11.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -5668,11 +5752,11 @@ var SchemaDbPusher = class {
 };
 
 // src/client/promise.ts
-function createDeferredPromise(callback) {
+function createZenStackPromise(callback) {
   let promise;
-  const cb = /* @__PURE__ */ __name(() => {
+  const cb = /* @__PURE__ */ __name((txClient) => {
     try {
-      return promise ??= valueToPromise(callback());
+      return promise ??= valueToPromise(callback(txClient));
     } catch (err) {
       return Promise.reject(err);
     }
@@ -5687,10 +5771,11 @@ function createDeferredPromise(callback) {
     finally(onFinally) {
       return cb().finally(onFinally);
     },
+    cb,
     [Symbol.toStringTag]: "ZenStackPromise"
   };
 }
-__name(createDeferredPromise, "createDeferredPromise");
+__name(createZenStackPromise, "createZenStackPromise");
 function valueToPromise(thing) {
   if (typeof thing === "object" && typeof thing?.then === "function") {
     return thing;
@@ -5701,7 +5786,7 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern18 = require("ts-pattern");
 var ResultProcessor = class {
@@ -5776,20 +5861,20 @@ var ResultProcessor = class {
     return this.doProcessResult(relationData, fieldDef.type);
   }
   transformScalar(value, type) {
-    return (0, import_ts_pattern18.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).otherwise(() => value);
+    return (0, import_ts_pattern18.match)(type).with("Boolean", () => this.transformBoolean(value)).with("DateTime", () => this.transformDate(value)).with("Bytes", () => this.transformBytes(value)).with("Decimal", () => this.transformDecimal(value)).with("BigInt", () => this.transformBigInt(value)).with("Json", () => this.transformJson(value)).otherwise(() => value);
   }
   transformDecimal(value) {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_common_helpers11.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers12.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers11.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers12.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -5808,6 +5893,9 @@ var ResultProcessor = class {
     return Buffer.isBuffer(value) ? Uint8Array.from(value) : value;
   }
   fixReversedResult(data, model, args) {
+    if (!data) {
+      return;
+    }
     if (Array.isArray(data) && typeof args === "object" && args && args.take !== void 0 && args.take < 0) {
       data.reverse();
     }
@@ -5821,13 +5909,19 @@ var ResultProcessor = class {
           continue;
         }
         const fieldDef = getField(this.schema, model, field);
-        if (!fieldDef?.relation) {
+        if (!fieldDef || !fieldDef.relation || !fieldDef.array) {
           continue;
         }
         this.fixReversedResult(row[field], fieldDef.type, value);
       }
     }
   }
+  transformJson(value) {
+    return (0, import_ts_pattern18.match)(this.schema.provider.type).with("sqlite", () => {
+      (0, import_common_helpers12.invariant)(typeof value === "string", "Expected string, got " + typeof value);
+      return JSON.parse(value);
+    }).otherwise(() => value);
+  }
 };
 
 // src/client/client-impl.ts
@@ -5846,7 +5940,7 @@ var ClientImpl = class _ClientImpl {
   $schema;
   kyselyProps;
   auth;
-  constructor(schema, options, baseClient) {
+  constructor(schema, options, baseClient, executor) {
     this.schema = schema;
     this.options = options;
     this.$schema = schema;
@@ -5858,16 +5952,16 @@ var ClientImpl = class _ClientImpl {
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
-        executor: new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely16.DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely16.DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
+      this.auth = baseClient.auth;
     } else {
       const dialect = this.getKyselyDialect();
       const driver = new ZenStackDriver(dialect.createDriver(), new import_kysely16.Log(this.$options.log ?? []));
       const compiler = dialect.createQueryCompiler();
       const adapter = dialect.createAdapter();
       const connectionProvider = new import_kysely16.DefaultConnectionProvider(driver);
-      const executor = new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider);
       this.kyselyProps = {
         config: {
           dialect,
@@ -5875,7 +5969,7 @@ var ClientImpl = class _ClientImpl {
         },
         dialect,
         driver,
-        executor
+        executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
       this.kyselyRaw = new import_kysely16.Kysely({
         ...this.kyselyProps,
@@ -5891,6 +5985,15 @@ var ClientImpl = class _ClientImpl {
   get $qbRaw() {
     return this.kyselyRaw;
   }
+  get isTransaction() {
+    return this.kysely.isTransaction;
+  }
+  /**
+   * Create a new client with a new query executor.
+   */
+  withExecutor(executor) {
+    return new _ClientImpl(this.schema, this.$options, this, executor);
+  }
   getKyselyDialect() {
     return (0, import_ts_pattern19.match)(this.schema.provider.type).with("sqlite", () => this.makeSqliteKyselyDialect()).with("postgresql", () => this.makePostgresKyselyDialect()).exhaustive();
   }
@@ -5900,12 +6003,49 @@ var ClientImpl = class _ClientImpl {
   makeSqliteKyselyDialect() {
     return new import_kysely16.SqliteDialect(this.options.dialectConfig);
   }
-  async $transaction(callback) {
-    return this.kysely.transaction().execute((tx) => {
-      const txClient = new _ClientImpl(this.schema, this.$options);
+  // implementation
+  async $transaction(input, options) {
+    (0, import_common_helpers13.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    if (typeof input === "function") {
+      return this.interactiveTransaction(input, options);
+    } else {
+      return this.sequentialTransaction(input, options);
+    }
+  }
+  async interactiveTransaction(callback, options) {
+    if (this.kysely.isTransaction) {
+      return callback(this);
+    } else {
+      let txBuilder = this.kysely.transaction();
+      if (options?.isolationLevel) {
+        txBuilder = txBuilder.setIsolationLevel(options.isolationLevel);
+      }
+      return txBuilder.execute((tx) => {
+        const txClient = new _ClientImpl(this.schema, this.$options, this);
+        txClient.kysely = tx;
+        return callback(txClient);
+      });
+    }
+  }
+  async sequentialTransaction(arg, options) {
+    const execute = /* @__PURE__ */ __name(async (tx) => {
+      const txClient = new _ClientImpl(this.schema, this.$options, this);
       txClient.kysely = tx;
-      return callback(txClient);
-    });
+      const result = [];
+      for (const promise of arg) {
+        result.push(await promise.cb(txClient));
+      }
+      return result;
+    }, "execute");
+    if (this.kysely.isTransaction) {
+      return execute(this.kysely);
+    } else {
+      let txBuilder = this.kysely.transaction();
+      if (options?.isolationLevel) {
+        txBuilder = txBuilder.setIsolationLevel(options.isolationLevel);
+      }
+      return txBuilder.execute((tx) => execute(tx));
+    }
   }
   get $procedures() {
     return Object.keys(this.$schema.procedures ?? {}).reduce((acc, name) => {
@@ -5967,6 +6107,39 @@ var ClientImpl = class _ClientImpl {
   get $auth() {
     return this.auth;
   }
+  $executeRaw(query, ...values) {
+    return createZenStackPromise(async () => {
+      const result = await (0, import_kysely16.sql)(query, ...values).execute(this.kysely);
+      return Number(result.numAffectedRows ?? 0);
+    });
+  }
+  $executeRawUnsafe(query, ...values) {
+    return createZenStackPromise(async () => {
+      const compiledQuery = this.createRawCompiledQuery(query, values);
+      const result = await this.kysely.executeQuery(compiledQuery);
+      return Number(result.numAffectedRows ?? 0);
+    });
+  }
+  $queryRaw(query, ...values) {
+    return createZenStackPromise(async () => {
+      const result = await (0, import_kysely16.sql)(query, ...values).execute(this.kysely);
+      return result.rows;
+    });
+  }
+  $queryRawUnsafe(query, ...values) {
+    return createZenStackPromise(async () => {
+      const compiledQuery = this.createRawCompiledQuery(query, values);
+      const result = await this.kysely.executeQuery(compiledQuery);
+      return result.rows;
+    });
+  }
+  createRawCompiledQuery(query, values) {
+    const q = import_kysely16.CompiledQuery.raw(query, values);
+    return {
+      ...q,
+      $raw: true
+    };
+  }
 };
 function createClientProxy(client) {
   const inputValidator = new InputValidator(client.$schema);
@@ -5989,9 +6162,9 @@ function createClientProxy(client) {
 __name(createClientProxy, "createClientProxy");
 function createModelCrudHandler(client, model, inputValidator, resultProcessor) {
   const createPromise = /* @__PURE__ */ __name((operation, args, handler, postProcess = false, throwIfNoResult = false) => {
-    return createDeferredPromise(async () => {
-      let proceed = /* @__PURE__ */ __name(async (_args, tx) => {
-        const _handler = tx ? handler.withClient(tx) : handler;
+    return createZenStackPromise(async (txClient) => {
+      let proceed = /* @__PURE__ */ __name(async (_args) => {
+        const _handler = txClient ? handler.withClient(txClient) : handler;
         const r = await _handler.handle(operation, _args ?? args);
         if (!r && throwIfNoResult) {
           throw new NotFoundError(model);
@@ -6010,7 +6183,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       for (const plugin of plugins) {
         if (plugin.onQuery && typeof plugin.onQuery === "object") {
           for (const [_model, modelHooks] of Object.entries(plugin.onQuery)) {
-            if (_model === (0, import_common_helpers12.lowerCaseFirst)(model) || _model === "$allModels") {
+            if (_model === (0, import_common_helpers13.lowerCaseFirst)(model) || _model === "$allModels") {
               if (modelHooks && typeof modelHooks === "object") {
                 for (const [op, opHooks] of Object.entries(modelHooks)) {
                   if (op === operation || op === "$allOperations") {
@@ -6089,8 +6262,19 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
 }
 __name(createModelCrudHandler, "createModelCrudHandler");
+
+// src/client/plugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+__name(definePlugin, "definePlugin");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ZenStackClient
+  InputValidationError,
+  InternalError,
+  NotFoundError,
+  QueryError,
+  ZenStackClient,
+  definePlugin
 });
 //# sourceMappingURL=index.cjs.map