@zenstackhq/runtime 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/index.js

@@ -6,7 +6,8 @@ var __export = (target, all) => {
 };
 
 // src/client/client-impl.ts
-import { DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, PostgresDialect, SqliteDialect } from "kysely";
+import { invariant as invariant12, lowerCaseFirst as lowerCaseFirst2 } from "@zenstackhq/common-helpers";
+import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, PostgresDialect, sql as sql10, SqliteDialect } from "kysely";
 import { match as match19 } from "ts-pattern";
 
 // src/client/crud/operations/aggregate.ts
@@ -14,21 +15,30 @@ import { sql as sql5 } from "kysely";
 import { match as match9 } from "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 {
   static {
     __name(this, "InternalError");
   }
-  constructor(message) {
-    super(message);
-  }
 };
 var NotFoundError = class extends Error {
   static {
@@ -47,7 +57,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];
 }
@@ -172,7 +182,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);
   }
@@ -280,9 +290,10 @@ __name(safeJSONStringify, "safeJSONStringify");
 
 // src/client/crud/operations/base.ts
 import { createId } from "@paralleldrive/cuid2";
+import { invariant as invariant7, isPlainObject as isPlainObject3 } from "@zenstackhq/common-helpers";
 import { expressionBuilder as expressionBuilder2, sql as sql4 } from "kysely";
 import { nanoid } from "nanoid";
-import invariant7 from "tiny-invariant";
+import { inspect } from "util";
 import { match as match8 } from "ts-pattern";
 import { ulid } from "ulid";
 import * as uuid from "uuid";
@@ -300,21 +311,21 @@ var RejectedByPolicyError = class extends Error {
 };
 
 // src/plugins/policy/policy-handler.ts
+import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode3, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode2, DeleteQueryNode, FromNode as FromNode2, IdentifierNode as IdentifierNode2, InsertQueryNode, OperationNodeTransformer, OperatorNode as OperatorNode3, PrimitiveValueListNode, RawNode, ReturningNode, SelectionNode as SelectionNode2, SelectQueryNode as SelectQueryNode2, TableNode as TableNode3, UpdateQueryNode, ValueNode as ValueNode3, ValuesNode, WhereNode as WhereNode2 } from "kysely";
-import invariant6 from "tiny-invariant";
 import { match as match7 } from "ts-pattern";
 
 // src/client/crud/dialects/index.ts
 import { match as match4 } from "ts-pattern";
 
 // src/client/crud/dialects/postgresql.ts
+import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { sql as sql2 } from "kysely";
-import invariant2 from "tiny-invariant";
 import { match as match2 } from "ts-pattern";
 
 // src/client/crud/dialects/base.ts
+import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
 import { sql } from "kysely";
-import invariant from "tiny-invariant";
 import { match, P } from "ts-pattern";
 
 // src/utils/enumerate.ts
@@ -332,7 +343,6 @@ function enumerate(x) {
 __name(enumerate, "enumerate");
 
 // src/client/crud/dialects/base.ts
-import { isPlainObject } from "is-plain-object";
 var BaseCrudDialect = class {
   static {
     __name(this, "BaseCrudDialect");
@@ -343,7 +353,7 @@ var BaseCrudDialect = class {
     this.schema = schema;
     this.options = options;
   }
-  transformPrimitive(value, _type) {
+  transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
   buildFilter(eb, model, modelAlias, where) {
@@ -486,7 +496,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)));
@@ -524,10 +534,14 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(eb, modelAlias, field, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(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 match(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(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 || !isPlainObject(payload)) {
@@ -614,22 +628,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, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean"), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, 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, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime"), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, 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, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes"), (value) => this.buildBytesFilter(eb, table, field, value), true, [
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, table, field, value), true, [
       "equals",
       "in",
       "notIn",
@@ -728,10 +742,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();
@@ -780,14 +794,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 match2(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).otherwise(() => value);
+      return match2(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) {
@@ -854,25 +872,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]) => [
-        sql2.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 [
+          sql2.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]) => [
         sql2.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;
   }
@@ -915,8 +941,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
 };
 
 // src/client/crud/dialects/sqlite.ts
+import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import { sql as sql3 } from "kysely";
-import invariant3 from "tiny-invariant";
 import { match as match3 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
@@ -925,14 +951,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 match3(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 match3(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) {
@@ -1460,12 +1486,12 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 };
 
 // src/plugins/policy/expression-transformer.ts
+import { invariant as invariant5 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode2, BinaryOperationNode as BinaryOperationNode2, ColumnNode, expressionBuilder, FromNode, FunctionNode as FunctionNode2, IdentifierNode, OperatorNode as OperatorNode2, ReferenceNode as ReferenceNode2, SelectionNode, SelectQueryNode, TableNode as TableNode2, ValueListNode, ValueNode as ValueNode2, WhereNode } from "kysely";
-import invariant5 from "tiny-invariant";
 import { match as match6 } from "ts-pattern";
 
 // src/plugins/policy/expression-evaluator.ts
-import invariant4 from "tiny-invariant";
+import { invariant as invariant4 } from "@zenstackhq/common-helpers";
 import { match as match5 } from "ts-pattern";
 var ExpressionEvaluator = class {
   static {
@@ -1537,11 +1563,11 @@ var ExpressionEvaluator = class {
 // src/plugins/policy/utils.ts
 import { AliasNode, AndNode, BinaryOperationNode, FunctionNode, OperatorNode, OrNode, ParensNode, ReferenceNode, TableNode, UnaryOperationNode, ValueNode } from "kysely";
 function trueNode(dialect) {
-  return ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean"));
+  return ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
 }
 __name(trueNode, "trueNode");
 function falseNode(dialect) {
-  return ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean"));
+  return ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
 }
 __name(falseNode, "falseNode");
 function isTrueNode(node) {
@@ -1799,7 +1825,7 @@ var ExpressionTransformer = class {
     }
   }
   transformValue(value, type) {
-    return ValueNode2.create(this.dialect.transformPrimitive(value, type) ?? null);
+    return ValueNode2.create(this.dialect.transformPrimitive(value, type, false) ?? null);
   }
   _unary(expr2, context) {
     invariant5(expr2.op === "!", 'only "!" operator is supported');
@@ -2042,7 +2068,7 @@ var PolicyHandler = class extends 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");
     }
@@ -2062,27 +2088,20 @@ var PolicyHandler = class extends OperationNodeTransformer {
     if (!mutationRequiresTransaction && !node.returning) {
       return proceed(this.transformNode(node));
     }
-    let readBackError = false;
-    const result = await transaction(async (txProceed) => {
-      if (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 (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) {
@@ -2143,11 +2162,11 @@ var PolicyHandler = class extends OperationNodeTransformer {
       if (typeof item === "object" && item && "kind" in item) {
         invariant6(item.kind === "ValueNode", "expecting a ValueNode");
         result.push({
-          node: ValueNode3.create(this.dialect.transformPrimitive(item.value, fieldDef.type)),
+          node: ValueNode3.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: RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
@@ -2378,14 +2397,23 @@ 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*/
+    );
   }
 };
 
 // src/utils/clone.ts
-import { isPlainObject as isPlainObject2 } from "is-plain-object";
+import { isPlainObject as isPlainObject2 } from "@zenstackhq/common-helpers";
 function clone(value) {
   if (Array.isArray(value)) {
     return value.map((v) => clone(v));
@@ -2501,13 +2529,13 @@ var BaseOperationHandler = class {
         inMemoryDistinct = distinct;
       }
     }
-    if (args?.select) {
-      query = this.buildFieldSelection(model, query, args?.select, model);
+    if (args && "select" in args && args.select) {
+      query = this.buildFieldSelection(model, query, args.select, model);
     } else {
       query = this.buildSelectAllScalarFields(model, query, args?.omit);
     }
-    if (args?.include) {
-      query = this.buildFieldSelection(model, query, args?.include, model);
+    if (args && "include" in args && args.include) {
+      query = this.buildFieldSelection(model, query, args.include, model);
     }
     if (args?.cursor) {
       query = this.buildCursorFilter(model, query, args.cursor, args.orderBy, negateOrderBy);
@@ -2520,8 +2548,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) => inspect(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
     if (inMemoryDistinct) {
       const distinctResult = [];
@@ -2580,30 +2613,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(sql4.join(idFields.map((f) => sql4.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);
@@ -2669,14 +2692,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]];
           }
@@ -2697,7 +2720,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);
     }
@@ -2764,7 +2787,7 @@ var BaseOperationHandler = class {
     const eb = expressionBuilder2();
     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;
     }
@@ -2814,21 +2837,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": {
+          invariant7(relationFieldDef.array, "relation must be an array for createMany");
+          tasks.push(this.createMany(kysely, relationModel, subPayload, false, fromRelationContext));
           break;
         }
         case "connect": {
@@ -2858,6 +2887,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) {
@@ -2872,7 +2906,7 @@ var BaseOperationHandler = class {
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
         invariant7(!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) {
@@ -2907,7 +2941,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);
         }
       }
     }
@@ -2972,7 +3006,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) {
@@ -2997,7 +3031,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}"`);
@@ -3042,7 +3076,7 @@ var BaseOperationHandler = class {
   transformIncrementalUpdate(model, field, fieldDef, payload) {
     invariant7(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 = expressionBuilder2();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
     return match8(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(() => {
@@ -3052,7 +3086,7 @@ var BaseOperationHandler = class {
   transformScalarListUpdate(model, field, fieldDef, payload) {
     invariant7(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 = expressionBuilder2();
     const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
     return match8(key).with("set", () => value).with("push", () => {
@@ -3082,7 +3116,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) {
@@ -3100,20 +3134,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) {
@@ -3513,7 +3542,7 @@ var BaseOperationHandler = class {
     }, {});
   }
   trimResult(data, args) {
-    if (!args.select) {
+    if (!("select" in args) || !args.select) {
       return data;
     }
     return Object.keys(args.select).reduce((acc, field) => {
@@ -3523,9 +3552,9 @@ var BaseOperationHandler = class {
   }
   needReturnRelations(model, args) {
     let returnRelation = false;
-    if (args.include) {
+    if ("include" in args && args.include) {
       returnRelation = Object.keys(args.include).length > 0;
-    } else if (args.select) {
+    } else if ("select" in args && args.select) {
       returnRelation = Object.entries(args.select).some(([K, v]) => {
         const fieldDef = this.requireField(model, K);
         return fieldDef.relation && v;
@@ -3533,11 +3562,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
@@ -3556,6 +3589,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 && isPlainObject3(value)) {
+          this.doNormalizeArgs(value);
+        }
+      }
+    }
+  }
 };
 
 // src/client/crud/operations/aggregate.ts
@@ -3564,21 +3619,22 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
     __name(this, "AggregateOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateAggregateArgs(this.model, args);
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateAggregateArgs(this.model, normalizedArgs);
     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) {
@@ -3657,14 +3713,15 @@ var CountOperationHandler = class extends BaseOperationHandler {
     __name(this, "CountOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateCountArgs(this.model, args);
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateCountArgs(this.model, normalizedArgs);
     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(sql6.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(sql6.ref(`$sub.${key}`)), "integer").as(key)));
       return query.executeTakeFirstOrThrow();
     } else {
       query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
@@ -3681,10 +3738,11 @@ var CreateOperationHandler = class extends BaseOperationHandler {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
-    return match10(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, args))).with("createMany", () => {
-      return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, args));
+    const normalizedArgs = this.normalizeArgs(args);
+    return match10(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+      return this.runCreateMany(this.inputValidator.validateCreateManyArgs(this.model, normalizedArgs));
     }).with("createManyAndReturn", () => {
-      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, args));
+      return this.runCreateManyAndReturn(this.inputValidator.validateCreateManyAndReturnArgs(this.model, normalizedArgs));
     }).exhaustive();
   }
   async runCreate(args) {
@@ -3734,7 +3792,8 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
-    return match11(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, args))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, args))).exhaustive();
+    const normalizedArgs = this.normalizeArgs(args);
+    return match11(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, {
@@ -3764,7 +3823,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 normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, operation === "findUnique", normalizedArgs) : normalizedArgs;
     const result = await this.read(this.client.$qb, this.model, parsedArgs);
     const finalResult = operation === "findMany" ? result : result[0] ?? null;
     return finalResult;
@@ -3774,16 +3834,17 @@ var FindOperationHandler = class extends BaseOperationHandler {
 // src/client/crud/operations/group-by.ts
 import { sql as sql7 } from "kysely";
 import { match as match12 } from "ts-pattern";
-var GroupByeOperationHandler = class extends BaseOperationHandler {
+var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
-    __name(this, "GroupByeOperationHandler");
+    __name(this, "GroupByOperationHandler");
   }
   async handle(_operation, args) {
-    const validatedArgs = this.inputValidator.validateGroupByArgs(this.model, args);
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateGroupByArgs(this.model, normalizedArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where((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;
@@ -3793,20 +3854,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(() => sql7.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) {
@@ -3889,7 +3950,8 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
-    return match13(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 normalizedArgs = this.normalizeArgs(args);
+    return match13(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 result = await this.safeTransaction(async (tx) => {
@@ -3945,6 +4007,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator.ts
+import { invariant as invariant8 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
 import stableStringify from "json-stable-stringify";
 import { match as match14, P as P2 } from "ts-pattern";
@@ -3954,10 +4017,9 @@ var InputValidator = class {
     __name(this, "InputValidator");
   }
   schema;
-  schemaCache;
+  schemaCache = /* @__PURE__ */ new Map();
   constructor(schema) {
     this.schema = schema;
-    this.schemaCache = /* @__PURE__ */ new Map();
   }
   validateFindArgs(model, unique, args) {
     return this.validate(model, "find", {
@@ -4014,7 +4076,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;
   }
@@ -4061,7 +4123,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)) {
@@ -4111,14 +4173,28 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => [
-            key,
-            this.makePrimitiveFilterSchema(def.type, !!def.optional)
-          ]))).optional();
+          fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+            invariant8(!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 = z.never();
+              }
+            } else {
+              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional);
+            }
+            return [
+              key,
+              fieldSchema
+            ];
+          }))).optional();
         }
       }
     }
-    fields["$expr"] = z.function().optional();
+    fields["$expr"] = z.custom((v) => typeof v === "function").optional();
     fields["AND"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
     fields["OR"] = z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
     fields["NOT"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
@@ -4164,7 +4240,7 @@ var InputValidator = class {
     });
   }
   makePrimitiveFilterSchema(type, optional) {
-    return match14(type).with("String", () => this.makeStringFilterSchema(optional)).with(P2.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 match14(type).with("String", () => this.makeStringFilterSchema(optional)).with(P2.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", () => z.any()).with("Unsupported", () => z.never()).exhaustive();
   }
   makeDateTimeFilterSchema(optional) {
     return this.makeCommonPrimitiveFilterSchema(z.union([
@@ -4358,8 +4434,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) => {
@@ -4401,7 +4477,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) {
@@ -4418,23 +4497,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(z.object(regularAndFkFields).strict(), canBeArray);
+      return this.orArray(z.object(uncheckedVariantFields).strict(), canBeArray);
     } else {
       return z.union([
-        z.object(regularAndFkFields).strict(),
-        z.object(regularAndRelationFields).strict(),
+        z.object(uncheckedVariantFields).strict(),
+        z.object(checkedVariantFields).strict(),
         ...canBeArray ? [
-          z.array(z.object(regularAndFkFields).strict())
+          z.array(z.object(uncheckedVariantFields).strict())
         ] : [],
         ...canBeArray ? [
-          z.array(z.object(regularAndRelationFields).strict())
+          z.array(z.object(checkedVariantFields).strict())
         ] : []
       ]);
     }
@@ -4479,7 +4558,7 @@ var InputValidator = class {
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return z.object(fields).strict().refine((v) => Object.keys(v).length > 0, "At least one action is required");
+    return z.object(fields).strict();
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4556,8 +4635,8 @@ var InputValidator = class {
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateDataSchema(model, withoutFields = [], withoutRelationFields = false) {
-    const regularAndFkFields = {};
-    const regularAndRelationFields = {};
+    const uncheckedVariantFields = {};
+    const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
     const hasRelation = Object.entries(modelDef.fields).some(([key, value]) => value.relation && !withoutFields.includes(key));
     Object.keys(modelDef.fields).forEach((field) => {
@@ -4582,7 +4661,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).optional();
         if (this.isNumericField(fieldDef)) {
@@ -4609,18 +4691,18 @@ 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 z.object(regularAndFkFields).strict();
+      return z.object(uncheckedVariantFields).strict();
     } else {
       return z.union([
-        z.object(regularAndFkFields).strict(),
-        z.object(regularAndRelationFields).strict()
+        z.object(uncheckedVariantFields).strict(),
+        z.object(checkedVariantFields).strict()
       ]);
     }
   }
@@ -4914,8 +4996,9 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode3, SelectionNode as SelectionNode4, SingleConnectionProvider, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
+import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode3, SelectionNode as SelectionNode4, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
 import { nanoid as nanoid2 } from "nanoid";
+import { inspect as inspect2 } from "util";
 import { match as match15 } from "ts-pattern";
 
 // src/client/executor/name-mapper.ts
@@ -4925,11 +5008,11 @@ var QueryNameMapper = class extends OperationNodeTransformer2 {
     __name(this, "QueryNameMapper");
   }
   schema;
-  modelToTableMap;
-  fieldToColumnMap;
-  modelStack;
+  modelToTableMap = /* @__PURE__ */ new Map();
+  fieldToColumnMap = /* @__PURE__ */ new Map();
+  modelStack = [];
   constructor(schema) {
-    super(), this.schema = schema, this.modelToTableMap = /* @__PURE__ */ new Map(), this.fieldToColumnMap = /* @__PURE__ */ new Map(), this.modelStack = [];
+    super(), this.schema = schema;
     for (const [modelName, modelDef] of Object.entries(schema.models)) {
       const mappedName = this.getMappedName(modelDef);
       if (mappedName) {
@@ -5150,7 +5233,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       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 ((InsertQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode)) && mutationInterceptionInfo?.loadAfterMutationEntity) {
         queryNode = {
@@ -5160,19 +5245,19 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
           ])
         };
       }
-      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;
@@ -5182,20 +5267,30 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
           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 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) => inspect2(p)).join("\n")}`;
+      }
+      throw new QueryError(message, err);
     }
   }
   isMutationNode(queryNode) {
@@ -5223,24 +5318,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
     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);
@@ -5282,14 +5362,13 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
             queryNode
           });
           result.intercept ||= filterResult.intercept;
-          result.useTransactionForMutation ||= filterResult.useTransactionForMutation;
           result.loadBeforeMutationEntity ||= filterResult.loadBeforeMutationEntity;
           result.loadAfterMutationEntity ||= filterResult.loadAfterMutationEntity;
         }
       }
       let beforeMutationEntities;
       if (result.loadBeforeMutationEntity && (UpdateQueryNode2.is(queryNode) || DeleteQueryNode2.is(queryNode))) {
-        beforeMutationEntities = await this.loadEntities(this.kysely, mutationModel, where);
+        beforeMutationEntities = await this.loadEntities(mutationModel, where);
       }
       return {
         ...result,
@@ -5302,15 +5381,14 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       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,
@@ -5331,12 +5409,12 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
           let afterMutationEntities = void 0;
           if (mutationInterceptionInfo.loadAfterMutationEntity) {
             if (UpdateQueryNode2.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,
@@ -5347,17 +5425,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
       }
     }
   }
-  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-${nanoid2()}`
     });
-    const result = await kysely.executeQuery(compiled);
     return result.rows;
   }
   andNodes(condition1, condition2) {
@@ -5386,8 +5464,8 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
+import { invariant as invariant9, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { sql as sql8, ValueNode as ValueNode4 } from "kysely";
-import invariant8 from "tiny-invariant";
 import { match as match16 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
@@ -5493,8 +5571,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  invariant8(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = match16(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => `${result.charAt(0).toUpperCase() + result.slice(1)}`).with("uncapitalize", () => `${result.charAt(0).toLowerCase() + result.slice(1)}`).otherwise(() => {
+  invariant9(ValueNode4.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = match16(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -5502,8 +5580,8 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
+import { invariant as invariant10 } from "@zenstackhq/common-helpers";
 import { sql as sql9 } from "kysely";
-import invariant9 from "tiny-invariant";
 import { match as match17 } from "ts-pattern";
 var SchemaDbPusher = class {
   static {
@@ -5535,7 +5613,7 @@ var SchemaDbPusher = class {
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
       if (fieldDef.relation) {
         table = this.addForeignKeyConstraint(table, model, fieldName, fieldDef);
-      } else {
+      } else if (!this.isComputedField(fieldDef)) {
         table = this.createModelField(table, fieldName, fieldDef, modelDef);
       }
     }
@@ -5543,6 +5621,9 @@ var SchemaDbPusher = class {
     table = this.addUniqueConstraint(table, modelDef);
     return table;
   }
+  isComputedField(fieldDef) {
+    return fieldDef.attributes?.some((a) => a.name === "@computed");
+  }
   addPrimaryKeyConstraint(table, model, modelDef) {
     if (modelDef.idFields.length === 1) {
       if (Object.values(modelDef.fields).some((f) => f.id)) {
@@ -5556,7 +5637,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      invariant9(typeof value === "object", "expecting an object");
+      invariant10(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -5602,7 +5683,7 @@ var SchemaDbPusher = class {
       return "serial";
     }
     const type = fieldDef.type;
-    const result = match17(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 = match17(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) {
@@ -5615,7 +5696,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    invariant9(fieldDef.relation, "field must be a relation");
+    invariant10(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -5636,11 +5717,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);
     }
@@ -5655,10 +5736,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;
@@ -5669,8 +5751,8 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
+import { invariant as invariant11 } from "@zenstackhq/common-helpers";
 import Decimal2 from "decimal.js";
-import invariant10 from "tiny-invariant";
 import { match as match18 } from "ts-pattern";
 var ResultProcessor = class {
   static {
@@ -5744,20 +5826,20 @@ var ResultProcessor = class {
     return this.doProcessResult(relationData, fieldDef.type);
   }
   transformScalar(value, type) {
-    return match18(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 match18(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 Decimal2) {
       return value;
     }
-    invariant10(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
+    invariant11(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
     return new Decimal2(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    invariant10(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    invariant11(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -5776,6 +5858,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();
     }
@@ -5789,13 +5874,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 match18(this.schema.provider.type).with("sqlite", () => {
+      invariant11(typeof value === "string", "Expected string, got " + typeof value);
+      return JSON.parse(value);
+    }).otherwise(() => value);
+  }
 };
 
 // src/client/client-impl.ts
@@ -5814,7 +5905,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;
@@ -5826,16 +5917,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 DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
+      this.auth = baseClient.auth;
     } else {
       const dialect = this.getKyselyDialect();
       const driver = new ZenStackDriver(dialect.createDriver(), new Log(this.$options.log ?? []));
       const compiler = dialect.createQueryCompiler();
       const adapter = dialect.createAdapter();
       const connectionProvider = new DefaultConnectionProvider(driver);
-      const executor = new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider);
       this.kyselyProps = {
         config: {
           dialect,
@@ -5843,7 +5934,7 @@ var ClientImpl = class _ClientImpl {
         },
         dialect,
         driver,
-        executor
+        executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
       this.kyselyRaw = new Kysely({
         ...this.kyselyProps,
@@ -5859,31 +5950,67 @@ 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 match19(this.schema.provider.type).with("sqlite", () => this.makeSqliteKyselyDialect()).with("postgresql", () => this.makePostgresKyselyDialect()).exhaustive();
   }
   makePostgresKyselyDialect() {
-    const { dialectConfigProvider } = this.schema.provider;
-    const mergedConfig = {
-      ...dialectConfigProvider(),
-      ...this.options?.dialectConfig
-    };
-    return new PostgresDialect(mergedConfig);
+    return new PostgresDialect(this.options.dialectConfig);
   }
   makeSqliteKyselyDialect() {
-    const { dialectConfigProvider } = this.schema.provider;
-    const mergedConfig = {
-      ...dialectConfigProvider(),
-      ...this.options?.dialectConfig
-    };
-    return new SqliteDialect(mergedConfig);
+    return new SqliteDialect(this.options.dialectConfig);
+  }
+  // implementation
+  async $transaction(input, options) {
+    invariant12(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 $transaction(callback) {
-    return this.kysely.transaction().execute((tx) => {
-      const txClient = new _ClientImpl(this.schema, this.$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) => {
@@ -5914,12 +6041,19 @@ var ClientImpl = class _ClientImpl {
     const newOptions = {
       ...this.options,
       plugins: [
-        ...this.options?.plugins ?? [],
+        ...this.options.plugins ?? [],
         plugin
       ]
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }
+  $unuse(pluginId) {
+    const newOptions = {
+      ...this.options,
+      plugins: this.options.plugins?.filter((p) => p.id !== pluginId)
+    };
+    return new _ClientImpl(this.schema, newOptions, this);
+  }
   $unuseAll() {
     const newOptions = {
       ...this.options,
@@ -5938,6 +6072,39 @@ var ClientImpl = class _ClientImpl {
   get $auth() {
     return this.auth;
   }
+  $executeRaw(query, ...values) {
+    return createZenStackPromise(async () => {
+      const result = await sql10(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 sql10(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 = CompiledQuery.raw(query, values);
+    return {
+      ...q,
+      $raw: true
+    };
+  }
 };
 function createClientProxy(client) {
   const inputValidator = new InputValidator(client.$schema);
@@ -5960,9 +6127,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);
@@ -5975,22 +6142,31 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
         }
         return result;
       }, "proceed");
-      const context = {
-        client,
-        model,
-        operation,
-        queryArgs: args
-      };
       const plugins = [
         ...client.$options.plugins ?? []
       ];
       for (const plugin of plugins) {
-        if (plugin.onQuery) {
-          const _proceed = proceed;
-          proceed = /* @__PURE__ */ __name(() => plugin.onQuery({
-            ...context,
-            proceed: _proceed
-          }), "proceed");
+        if (plugin.onQuery && typeof plugin.onQuery === "object") {
+          for (const [_model, modelHooks] of Object.entries(plugin.onQuery)) {
+            if (_model === lowerCaseFirst2(model) || _model === "$allModels") {
+              if (modelHooks && typeof modelHooks === "object") {
+                for (const [op, opHooks] of Object.entries(modelHooks)) {
+                  if (op === operation || op === "$allOperations") {
+                    if (typeof opHooks === "function") {
+                      const _proceed = proceed;
+                      proceed = /* @__PURE__ */ __name(() => opHooks({
+                        client,
+                        model,
+                        operation,
+                        args,
+                        query: _proceed
+                      }), "proceed");
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
       return proceed(args);
@@ -6046,12 +6222,23 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return createPromise("aggregate", args, new AggregateOperationHandler(client, model, inputValidator), false);
     }, "aggregate"),
     groupBy: /* @__PURE__ */ __name((args) => {
-      return createPromise("groupBy", args, new GroupByeOperationHandler(client, model, inputValidator));
+      return createPromise("groupBy", args, new GroupByOperationHandler(client, model, inputValidator));
     }, "groupBy")
   };
 }
 __name(createModelCrudHandler, "createModelCrudHandler");
+
+// src/client/plugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+__name(definePlugin, "definePlugin");
 export {
-  ZenStackClient
+  InputValidationError,
+  InternalError,
+  NotFoundError,
+  QueryError,
+  ZenStackClient,
+  definePlugin
 };
 //# sourceMappingURL=index.js.map