@zenstackhq/orm 3.3.0-beta.2 → 3.3.0-beta.3

package/dist/index.cjs

@@ -40,7 +40,7 @@ __export(src_exports, {
   CRUD: () => CRUD,
   CRUD_EXT: () => CRUD_EXT,
   CoreCreateOperations: () => CoreCreateOperations,
-  CoreCrudOperations: () => CoreCrudOperations,
+  CoreCrudOperations: () => CoreCrudOperations2,
   CoreDeleteOperations: () => CoreDeleteOperations,
   CoreReadOperations: () => CoreReadOperations,
   CoreUpdateOperations: () => CoreUpdateOperations,
@@ -64,11 +64,11 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
-var import_kysely10 = require("kysely");
+var import_common_helpers14 = require("@zenstackhq/common-helpers");
+var import_kysely11 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
-var import_ts_pattern7 = require("ts-pattern");
+var import_ts_pattern8 = require("ts-pattern");
 
 // src/client/query-utils.ts
 var query_utils_exports = {};
@@ -89,6 +89,7 @@ __export(query_utils_exports, {
   getIdValues: () => getIdValues,
   getManyToManyRelation: () => getManyToManyRelation,
   getModel: () => getModel,
+  getModelFields: () => getModelFields,
   getRelationForeignKeyFieldPairs: () => getRelationForeignKeyFieldPairs,
   getTypeDef: () => getTypeDef,
   getUniqueFields: () => getUniqueFields,
@@ -203,13 +204,13 @@ function createInvalidInputError(message, model, options) {
   return error;
 }
 __name(createInvalidInputError, "createInvalidInputError");
-function createDBQueryError(message, dbError, sql8, parameters) {
+function createDBQueryError(message, dbError, sql9, parameters) {
   const error = new ORMError("db-query-error", message, {
     cause: dbError
   });
   error.dbErrorCode = getDbErrorCode(dbError);
   error.dbErrorMessage = dbError instanceof Error ? dbError.message : void 0;
-  error.sql = sql8;
+  error.sql = sql9;
   error.sqlParams = parameters;
   return error;
 }
@@ -286,6 +287,22 @@ function requireField(schema, modelOrType, field) {
   throw createInternalError(`Model or type "${modelOrType}" not found in schema`, modelOrType);
 }
 __name(requireField, "requireField");
+function getModelFields(schema, model, options) {
+  const modelDef = requireModel(schema, model);
+  return Object.values(modelDef.fields).filter((f) => {
+    if (f.relation && !options?.relations) {
+      return false;
+    }
+    if (f.computed && !options?.computed) {
+      return false;
+    }
+    if (f.originModel && !options?.inherited) {
+      return false;
+    }
+    return true;
+  });
+}
+__name(getModelFields, "getModelFields");
 function getIdFields(schema, model) {
   const modelDef = getModel(schema, model);
   return modelDef?.idFields;
@@ -606,11 +623,11 @@ __name(extractFieldName, "extractFieldName");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
-var import_common_helpers5 = require("@zenstackhq/common-helpers");
+var import_common_helpers7 = require("@zenstackhq/common-helpers");
 var import_cuid = __toESM(require("cuid"), 1);
-var import_kysely5 = require("kysely");
+var import_kysely6 = require("kysely");
 var import_nanoid = require("nanoid");
-var import_ts_pattern6 = require("ts-pattern");
+var import_ts_pattern7 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
 
@@ -656,15 +673,13 @@ var CRUD_EXT = [
 ];
 
 // src/client/crud/dialects/index.ts
-var import_ts_pattern5 = require("ts-pattern");
+var import_ts_pattern6 = require("ts-pattern");
 
-// src/client/crud/dialects/postgresql.ts
-var import_common_helpers3 = require("@zenstackhq/common-helpers");
+// src/client/crud/dialects/mysql.ts
+var import_common_helpers4 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_kysely3 = require("kysely");
-var import_postgres_array = require("postgres-array");
 var import_ts_pattern3 = require("ts-pattern");
-var import_zod = __toESM(require("zod"), 1);
 
 // src/common-types.ts
 var DbNullClass = class {
@@ -692,6 +707,9 @@ var AnyNullClass = class {
 };
 var AnyNull = new AnyNullClass();
 
+// src/client/crud/dialects/lateral-join-dialect-base.ts
+var import_common_helpers3 = require("@zenstackhq/common-helpers");
+
 // src/client/crud/dialects/base-dialect.ts
 var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_kysely2 = require("kysely");
@@ -707,12 +725,21 @@ var BaseCrudDialect = class {
     this.schema = schema;
     this.options = options;
   }
-  transformPrimitive(value, _type, _forArrayField) {
+  // #endregion
+  // #region value transformation
+  /**
+   * Transforms input value before sending to database.
+   */
+  transformInput(value, _type, _forArrayField) {
     return value;
   }
+  /**
+   * Transforms output value received from database.
+   */
   transformOutput(value, _type, _array) {
     return value;
   }
+  // #endregion
   // #region common query builders
   buildSelectModel(model, modelAlias) {
     const modelDef = requireModel(this.schema, model);
@@ -737,7 +764,7 @@ var BaseCrudDialect = class {
       take = -take;
     }
     result = this.buildSkipTake(result, skip, take);
-    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, negateOrderBy);
+    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, negateOrderBy, take);
     if ("distinct" in args && args.distinct) {
       const distinct = ensureArray(args.distinct);
       if (this.supportsDistinctOn) {
@@ -901,17 +928,21 @@ var BaseCrudDialect = class {
       if (!subPayload) {
         continue;
       }
+      const countSelect = /* @__PURE__ */ __name((negate) => {
+        const filter = this.buildFilter(relationModel, relationFilterSelectAlias, subPayload);
+        return this.eb.selectFrom(this.buildSelectModel(relationModel, relationFilterSelectAlias).select(() => this.eb.fn.count(this.eb.lit(1)).as("$count")).where(buildPkFkWhereRefs(this.eb)).where(() => negate ? this.eb.not(filter) : filter).as("$sub")).select("$count");
+      }, "countSelect");
       switch (key) {
         case "some": {
-          result = this.and(result, this.eb(this.buildSelectModel(relationModel, relationFilterSelectAlias).select(() => this.eb.fn.count(this.eb.lit(1)).as("$count")).where(buildPkFkWhereRefs(this.eb)).where(() => this.buildFilter(relationModel, relationFilterSelectAlias, subPayload)), ">", 0));
+          result = this.and(result, this.eb(countSelect(false), ">", 0));
           break;
         }
         case "every": {
-          result = this.and(result, this.eb(this.buildSelectModel(relationModel, relationFilterSelectAlias).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(this.eb)).where(() => this.eb.not(this.buildFilter(relationModel, relationFilterSelectAlias, subPayload))), "=", 0));
+          result = this.and(result, this.eb(countSelect(true), "=", 0));
           break;
         }
         case "none": {
-          result = this.and(result, this.eb(this.buildSelectModel(relationModel, relationFilterSelectAlias).select(() => this.eb.fn.count(this.eb.lit(1)).as("$count")).where(buildPkFkWhereRefs(this.eb)).where(() => this.buildFilter(relationModel, relationFilterSelectAlias, subPayload)), "=", 0));
+          result = this.and(result, this.eb(countSelect(false), "=", 0));
           break;
         }
       }
@@ -925,7 +956,7 @@ var BaseCrudDialect = class {
       if (_value === void 0) {
         continue;
       }
-      const value = this.transformPrimitive(_value, fieldType, !!fieldDef.array);
+      const value = this.transformInput(_value, fieldType, !!fieldDef.array);
       switch (key) {
         case "equals": {
           clauses.push(this.buildLiteralFilter(fieldRef, fieldType, this.eb.val(value)));
@@ -994,7 +1025,7 @@ var BaseCrudDialect = class {
     const clauses = [];
     const path = filter.path;
     const jsonReceiver = this.buildJsonPathSelection(receiver, path);
-    const stringReceiver = this.eb.cast(jsonReceiver, "text");
+    const stringReceiver = this.castText(jsonReceiver);
     const mode = filter.mode ?? "default";
     (0, import_common_helpers2.invariant)(mode === "default" || mode === "insensitive", "Invalid JSON filter mode");
     for (const [key, value] of Object.entries(filter)) {
@@ -1078,7 +1109,7 @@ var BaseCrudDialect = class {
   buildTypeJsonNonArrayFilter(receiver, filter, typeDefName) {
     const clauses = [];
     if (filter === null) {
-      return this.eb(receiver, "=", "null");
+      return this.eb(receiver, "=", this.transformInput(null, "Json", false));
     }
     (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Typed JSON filter payload must be an object");
     if ("is" in filter || "isNot" in filter) {
@@ -1102,10 +1133,7 @@ var BaseCrudDialect = class {
           } else {
             let _receiver = fieldReceiver;
             if (fieldDef.type === "String") {
-              _receiver = this.eb.fn("trim", [
-                this.eb.cast(fieldReceiver, "text"),
-                import_kysely2.sql.lit('"')
-              ]);
+              _receiver = this.trimTextQuotes(this.castText(fieldReceiver));
             }
             clauses.push(this.buildPrimitiveFilter(_receiver, fieldDef, value));
           }
@@ -1119,20 +1147,23 @@ var BaseCrudDialect = class {
       return this.eb(lhs, "is", null);
     } else if (value instanceof JsonNullClass) {
       return this.eb.and([
-        this.eb(lhs, "=", "null"),
+        this.eb(lhs, "=", this.transformInput(null, "Json", false)),
         this.eb(lhs, "is not", null)
       ]);
     } else if (value instanceof AnyNullClass) {
       return this.eb.or([
         this.eb(lhs, "is", null),
-        this.eb(lhs, "=", "null")
+        this.eb(lhs, "=", this.transformInput(null, "Json", false))
       ]);
     } else {
-      return this.buildLiteralFilter(lhs, "Json", value);
+      return this.buildJsonEqualityFilter(lhs, value);
     }
   }
+  buildJsonEqualityFilter(lhs, rhs) {
+    return this.buildLiteralFilter(lhs, "Json", rhs);
+  }
   buildLiteralFilter(lhs, type, rhs) {
-    return this.eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type, false) : rhs);
+    return this.eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformInput(rhs, type, false) : rhs);
   }
   buildStandardFilter(type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
     if (payload === null || !(0, import_common_helpers2.isPlainObject)(payload)) {
@@ -1232,7 +1263,7 @@ var BaseCrudDialect = class {
   buildStringLike(receiver, pattern, insensitive) {
     const { supportsILike } = this.getStringCasingBehavior();
     const op = insensitive && supportsILike ? "ilike" : "like";
-    return import_kysely2.sql`${receiver} ${import_kysely2.sql.raw(op)} ${import_kysely2.sql.val(pattern)} escape '\\'`;
+    return import_kysely2.sql`${receiver} ${import_kysely2.sql.raw(op)} ${import_kysely2.sql.val(pattern)} escape ${import_kysely2.sql.val("\\")}`;
   }
   prepStringCasing(eb, value, mode) {
     if (!mode || mode === "default") {
@@ -1249,22 +1280,22 @@ var BaseCrudDialect = class {
     }
   }
   buildNumberFilter(fieldRef, type, payload) {
-    const { conditions } = this.buildStandardFilter(type, payload, fieldRef, (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(fieldRef, type, value));
+    const { conditions } = this.buildStandardFilter(type, payload, fieldRef, (value) => this.transformInput(value, type, false), (value) => this.buildNumberFilter(fieldRef, type, value));
     return this.and(...conditions);
   }
   buildBooleanFilter(fieldRef, payload) {
-    const { conditions } = this.buildStandardFilter("Boolean", payload, fieldRef, (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(fieldRef, value), true, [
+    const { conditions } = this.buildStandardFilter("Boolean", payload, fieldRef, (value) => this.transformInput(value, "Boolean", false), (value) => this.buildBooleanFilter(fieldRef, value), true, [
       "equals",
       "not"
     ]);
     return this.and(...conditions);
   }
   buildDateTimeFilter(fieldRef, payload) {
-    const { conditions } = this.buildStandardFilter("DateTime", payload, fieldRef, (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(fieldRef, value), true);
+    const { conditions } = this.buildStandardFilter("DateTime", payload, fieldRef, (value) => this.transformInput(value, "DateTime", false), (value) => this.buildDateTimeFilter(fieldRef, value), true);
     return this.and(...conditions);
   }
   buildBytesFilter(fieldRef, payload) {
-    const conditions = this.buildStandardFilter("Bytes", payload, fieldRef, (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(fieldRef, value), true, [
+    const conditions = this.buildStandardFilter("Bytes", payload, fieldRef, (value) => this.transformInput(value, "Bytes", false), (value) => this.buildBytesFilter(fieldRef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -1281,7 +1312,7 @@ var BaseCrudDialect = class {
     ]);
     return this.and(...conditions.conditions);
   }
-  buildOrderBy(query, model, modelAlias, orderBy, negated) {
+  buildOrderBy(query, model, modelAlias, orderBy, negated, take) {
     if (!orderBy) {
       return query;
     }
@@ -1302,37 +1333,20 @@ var BaseCrudDialect = class {
           "_min",
           "_max"
         ].includes(field)) {
-          (0, import_common_helpers2.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
+          (0, import_common_helpers2.invariant)(typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             (0, import_common_helpers2.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
             result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
           }
           continue;
         }
-        switch (field) {
-          case "_count": {
-            (0, import_common_helpers2.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
-            for (const [k, v] of Object.entries(value)) {
-              (0, import_common_helpers2.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), this.negateSort(v, negated));
-            }
-            continue;
-          }
-          default:
-            break;
-        }
         const fieldDef = requireField(this.schema, model, field);
         if (!fieldDef.relation) {
           const fieldRef = buildFieldRef(model, field, modelAlias);
           if (value === "asc" || value === "desc") {
             result = result.orderBy(fieldRef, this.negateSort(value, negated));
-          } else if (value && typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
-            result = result.orderBy(fieldRef, (ob) => {
-              const dir = this.negateSort(value.sort, negated);
-              ob = dir === "asc" ? ob.asc() : ob.desc();
-              ob = value.nulls === "first" ? ob.nullsFirst() : ob.nullsLast();
-              return ob;
-            });
+          } else if (typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
+            result = this.buildOrderByField(result, fieldRef, this.negateSort(value.sort, negated), value.nulls);
           }
         } else {
           const relationModel = fieldDef.type;
@@ -1358,7 +1372,7 @@ var BaseCrudDialect = class {
               const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, joinAlias);
               return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
             });
-            result = this.buildOrderBy(result, relationModel, joinAlias, value, negated);
+            result = this.buildOrderBy(result, relationModel, joinAlias, value, negated, take);
           }
         }
       }
@@ -1463,10 +1477,10 @@ var BaseCrudDialect = class {
     return negated ? sort === "asc" ? "desc" : "asc" : sort;
   }
   true() {
-    return this.eb.lit(this.transformPrimitive(true, "Boolean", false));
+    return this.eb.lit(this.transformInput(true, "Boolean", false));
   }
   false() {
-    return this.eb.lit(this.transformPrimitive(false, "Boolean", false));
+    return this.eb.lit(this.transformInput(false, "Boolean", false));
   }
   isTrue(expression) {
     const node = expression.toOperationNode();
@@ -1540,120 +1554,10 @@ var BaseCrudDialect = class {
   }
 };
 
-// src/client/crud/dialects/postgresql.ts
-var PostgresCrudDialect = class extends BaseCrudDialect {
+// src/client/crud/dialects/lateral-join-dialect-base.ts
+var LateralJoinDialectBase = class extends BaseCrudDialect {
   static {
-    __name(this, "PostgresCrudDialect");
-  }
-  isoDateSchema = import_zod.default.iso.datetime({
-    local: true,
-    offset: true
-  });
-  constructor(schema, options) {
-    super(schema, options);
-  }
-  get provider() {
-    return "postgresql";
-  }
-  transformPrimitive(value, type, forArrayField) {
-    if (value === void 0) {
-      return value;
-    }
-    if (value instanceof JsonNullClass) {
-      return "null";
-    } else if (value instanceof DbNullClass) {
-      return null;
-    } else if (value instanceof AnyNullClass) {
-      (0, import_common_helpers3.invariant)(false, "should not reach here: AnyNull is not a valid input value");
-    }
-    if (isTypeDef(this.schema, type)) {
-      if (typeof value !== "string") {
-        return JSON.stringify(value);
-      } else {
-        return value;
-      }
-    } else if (Array.isArray(value)) {
-      if (type === "Json" && !forArrayField) {
-        return JSON.stringify(value);
-      }
-      if (isEnum(this.schema, type)) {
-        return this.eb.cast(import_kysely3.sql`ARRAY[${import_kysely3.sql.join(value.map((v) => this.transformPrimitive(v, type, false)), import_kysely3.sql.raw(","))}]`, this.createSchemaQualifiedEnumType(type, true));
-      } else {
-        return value.map((v) => this.transformPrimitive(v, type, false));
-      }
-    } else {
-      return (0, import_ts_pattern3.match)(type).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value !== null ? value.toString() : value).with("Json", () => {
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-          return JSON.stringify(value);
-        } else {
-          return value;
-        }
-      }).otherwise(() => value);
-    }
-  }
-  createSchemaQualifiedEnumType(type, array) {
-    let qualified = type;
-    const enumDef = getEnum(this.schema, type);
-    if (enumDef) {
-      const schemaAttr = enumDef.attributes?.find((attr) => attr.name === "@@schema");
-      if (schemaAttr) {
-        const mapArg = schemaAttr.args?.find((arg) => arg.name === "map");
-        if (mapArg && mapArg.value.kind === "literal") {
-          const schemaName = mapArg.value.value;
-          qualified = `"${schemaName}"."${type}"`;
-        }
-      } else {
-        const defaultSchema = this.schema.provider.defaultSchema ?? "public";
-        qualified = `"${defaultSchema}"."${type}"`;
-      }
-    }
-    return array ? import_kysely3.sql.raw(`${qualified}[]`) : import_kysely3.sql.raw(qualified);
-  }
-  transformOutput(value, type, array) {
-    if (value === null || value === void 0) {
-      return value;
-    }
-    return (0, import_ts_pattern3.match)(type).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).when((type2) => isEnum(this.schema, type2), () => this.transformOutputEnum(value, array)).otherwise(() => super.transformOutput(value, type, array));
-  }
-  transformOutputBigInt(value) {
-    if (typeof value === "bigint") {
-      return value;
-    }
-    (0, import_common_helpers3.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
-    return BigInt(value);
-  }
-  transformDecimal(value) {
-    if (value instanceof import_decimal.default) {
-      return value;
-    }
-    (0, import_common_helpers3.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal.default, `Expected string, number or Decimal, got ${typeof value}`);
-    return new import_decimal.default(value);
-  }
-  transformOutputDate(value) {
-    if (typeof value === "string") {
-      if (this.isoDateSchema.safeParse(value).success) {
-        const hasOffset = value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
-        return new Date(hasOffset ? value : `${value}Z`);
-      } else {
-        return value;
-      }
-    } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
-      return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
-    } else {
-      return value;
-    }
-  }
-  transformOutputBytes(value) {
-    return Buffer.isBuffer(value) ? Uint8Array.from(value) : typeof value === "string" && value.startsWith("\\x") ? Uint8Array.from(Buffer.from(value.slice(2), "hex")) : value;
-  }
-  transformOutputEnum(value, array) {
-    if (array && typeof value === "string") {
-      try {
-        return (0, import_postgres_array.parse)(value);
-      } catch {
-      }
-    }
-    return value;
+    __name(this, "LateralJoinDialectBase");
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     const relationResultName = `${parentAlias}$${relationField}`;
@@ -1674,6 +1578,9 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         tbl = eb.selectFrom(() => {
           let subQuery = this.buildModelSelect(relationModel, `${relationSelectName}$t`, payload, true);
           subQuery = this.buildRelationJoinFilter(subQuery, model, relationField, relationModel, `${relationSelectName}$t`, parentAlias);
+          if (typeof payload !== "object" || payload.take === void 0) {
+            subQuery = subQuery.limit(Number.MAX_SAFE_INTEGER);
+          }
           return subQuery.as(relationSelectName);
         });
       }
@@ -1700,53 +1607,47 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     qb = qb.select((eb) => {
       const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName);
       if (relationFieldDef.array) {
-        return eb.fn.coalesce(import_kysely3.sql`jsonb_agg(jsonb_build_object(${import_kysely3.sql.join(objArgs)}))`, import_kysely3.sql`'[]'::jsonb`).as("$data");
+        return this.buildArrayAgg(this.buildJsonObject(objArgs)).as("$data");
       } else {
-        return import_kysely3.sql`jsonb_build_object(${import_kysely3.sql.join(objArgs)})`.as("$data");
+        return this.buildJsonObject(objArgs).as("$data");
       }
     });
     return qb;
   }
   buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName) {
     const relationModelDef = requireModel(this.schema, relationModel);
-    const objArgs = [];
+    const objArgs = {};
     const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
     if (descendantModels.length > 0) {
-      objArgs.push(...descendantModels.map((subModel) => [
-        import_kysely3.sql.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
-        eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
-      ]).flatMap((v) => v));
+      Object.assign(objArgs, ...descendantModels.map((subModel) => ({
+        [`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`]: eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+      })));
     }
     if (payload === true || !payload.select) {
       const omit = typeof payload === "object" ? payload.omit : void 0;
-      objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !this.shouldOmitField(omit, relationModel, name)).map(([field]) => [
-        import_kysely3.sql.lit(field),
-        this.fieldRef(relationModel, field, relationModelAlias, false)
-      ]).flatMap((v) => v));
+      Object.assign(objArgs, ...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !this.shouldOmitField(omit, relationModel, name)).map(([field]) => ({
+        [field]: this.fieldRef(relationModel, field, relationModelAlias, false)
+      })));
     } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
+      Object.assign(objArgs, ...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
         if (field === "_count") {
           const subJson = this.buildCountJson(relationModel, eb, relationModelAlias, value);
-          return [
-            import_kysely3.sql.lit(field),
-            subJson
-          ];
+          return {
+            [field]: subJson
+          };
         } else {
           const fieldDef = requireField(this.schema, relationModel, field);
           const fieldValue = fieldDef.relation ? eb.ref(`${parentResultName}$${field}.$data`) : this.fieldRef(relationModel, field, relationModelAlias, false);
-          return [
-            import_kysely3.sql.lit(field),
-            fieldValue
-          ];
+          return {
+            [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_kysely3.sql.lit(field),
-        // reference the synthesized JSON field
-        eb.ref(`${parentResultName}$${field}.$data`)
-      ]).flatMap((v) => v));
+      Object.assign(objArgs, ...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => ({
+        [field]: eb.ref(`${parentResultName}$${field}.$data`)
+      })));
     }
     return objArgs;
   }
@@ -1762,45 +1663,170 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     }
     return result;
   }
+};
+
+// src/client/crud/dialects/mysql.ts
+var MySqlCrudDialect = class extends LateralJoinDialectBase {
+  static {
+    __name(this, "MySqlCrudDialect");
+  }
+  constructor(schema, options) {
+    super(schema, options);
+  }
+  get provider() {
+    return "mysql";
+  }
+  // #region capabilities
+  get supportsUpdateWithLimit() {
+    return true;
+  }
+  get supportsDeleteWithLimit() {
+    return true;
+  }
+  get supportsDistinctOn() {
+    return false;
+  }
+  get supportsReturning() {
+    return false;
+  }
+  get supportsInsertDefaultValues() {
+    return false;
+  }
+  get supportsDefaultAsFieldValue() {
+    return true;
+  }
+  get insertIgnoreMethod() {
+    return "ignore";
+  }
+  // #endregion
+  // #region value transformation
+  transformInput(value, type, forArrayField) {
+    if (value === void 0) {
+      return value;
+    }
+    if (value instanceof JsonNullClass) {
+      return this.eb.cast(import_kysely3.sql.lit("null"), "json");
+    } else if (value instanceof DbNullClass) {
+      return null;
+    } else if (value instanceof AnyNullClass) {
+      (0, import_common_helpers4.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+    }
+    if (isTypeDef(this.schema, type)) {
+      if (typeof value !== "string") {
+        return this.transformInput(value, "Json", forArrayField);
+      } else {
+        return value;
+      }
+    } else if (Array.isArray(value)) {
+      if (type === "Json") {
+        return JSON.stringify(value);
+      } else {
+        throw createNotSupportedError(`MySQL does not support array literals`);
+      }
+    } else {
+      return (0, import_ts_pattern3.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => {
+        if (value instanceof Date) {
+          return value.toISOString().replace("Z", "+00:00");
+        } else if (typeof value === "string") {
+          return new Date(value).toISOString().replace("Z", "+00:00");
+        } else {
+          return value;
+        }
+      }).with("Decimal", () => value !== null ? value.toString() : value).with("Json", () => {
+        return this.eb.cast(this.eb.val(JSON.stringify(value)), "json");
+      }).with("Bytes", () => Buffer.isBuffer(value) ? value : value instanceof Uint8Array ? Buffer.from(value) : value).otherwise(() => value);
+    }
+  }
+  transformOutput(value, type, array) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    return (0, import_ts_pattern3.match)(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).otherwise(() => super.transformOutput(value, type, array));
+  }
+  transformOutputBoolean(value) {
+    return !!value;
+  }
+  transformOutputBigInt(value) {
+    if (typeof value === "bigint") {
+      return value;
+    }
+    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    return BigInt(value);
+  }
+  transformDecimal(value) {
+    if (value instanceof import_decimal.default) {
+      return value;
+    }
+    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal.default, `Expected string, number or Decimal, got ${typeof value}`);
+    return new import_decimal.default(value);
+  }
+  transformOutputDate(value) {
+    if (typeof value === "string") {
+      return new Date(!value.endsWith("Z") ? value + "Z" : value);
+    } else if (value instanceof Date) {
+      return value;
+    } else {
+      return value;
+    }
+  }
+  transformOutputBytes(value) {
+    return Buffer.isBuffer(value) ? Uint8Array.from(value) : value;
+  }
+  // #endregion
+  // #region other overrides
+  buildArrayAgg(arg) {
+    return this.eb.fn.coalesce(import_kysely3.sql`JSON_ARRAYAGG(${arg})`, import_kysely3.sql`JSON_ARRAY()`);
+  }
   buildSkipTake(query, skip, take) {
     if (take !== void 0) {
       query = query.limit(take);
     }
     if (skip !== void 0) {
       query = query.offset(skip);
+      if (take === void 0) {
+        query = query.limit(Number.MAX_SAFE_INTEGER);
+      }
     }
     return query;
   }
   buildJsonObject(value) {
-    return this.eb.fn("jsonb_build_object", Object.entries(value).flatMap(([key, value2]) => [
+    return this.eb.fn("JSON_OBJECT", Object.entries(value).flatMap(([key, value2]) => [
       import_kysely3.sql.lit(key),
       value2
     ]));
   }
-  get supportsUpdateWithLimit() {
-    return false;
+  castInt(expression) {
+    return this.eb.cast(expression, import_kysely3.sql.raw("unsigned"));
   }
-  get supportsDeleteWithLimit() {
-    return false;
+  castText(expression) {
+    return import_kysely3.sql`CAST(${expression} AS CHAR CHARACTER SET utf8mb4)`;
   }
-  get supportsDistinctOn() {
-    return true;
+  trimTextQuotes(expression) {
+    return import_kysely3.sql`TRIM(BOTH ${import_kysely3.sql.lit('"')} FROM ${expression})`;
   }
   buildArrayLength(array) {
-    return this.eb.fn("array_length", [
+    return this.eb.fn("JSON_LENGTH", [
       array
     ]);
   }
-  buildArrayLiteralSQL(values) {
-    if (values.length === 0) {
-      return "{}";
-    } else {
-      return `ARRAY[${values.map((v) => typeof v === "string" ? `'${v}'` : v)}]`;
-    }
+  buildArrayLiteralSQL(_values) {
+    throw new Error("MySQL does not support array literals");
+  }
+  buildJsonEqualityFilter(lhs, rhs) {
+    return this.eb.and([
+      this.eb.fn("JSON_CONTAINS", [
+        lhs,
+        this.eb.val(JSON.stringify(rhs))
+      ]),
+      this.eb.fn("JSON_CONTAINS", [
+        this.eb.val(JSON.stringify(rhs)),
+        lhs
+      ])
+    ]);
   }
   buildJsonPathSelection(receiver, path) {
     if (path) {
-      return this.eb.fn("jsonb_path_query_first", [
+      return this.eb.fn("JSON_EXTRACT", [
         receiver,
         this.eb.val(path)
       ]);
@@ -1813,23 +1839,281 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       const v = Array.isArray(value) ? value : [
         value
       ];
-      return import_kysely3.sql`${lhs} @> ${import_kysely3.sql.val(JSON.stringify(v))}::jsonb`;
-    }).with("array_starts_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
-      lhs,
-      this.eb.val("0")
-    ]), "=", this.transformPrimitive(value, "Json", false))).with("array_ends_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
+      return import_kysely3.sql`JSON_CONTAINS(${lhs}, ${import_kysely3.sql.val(JSON.stringify(v))})`;
+    }).with("array_starts_with", () => this.eb(this.eb.fn("JSON_EXTRACT", [
       lhs,
-      import_kysely3.sql`(jsonb_array_length(${lhs}) - 1)::text`
-    ]), "=", this.transformPrimitive(value, "Json", false))).exhaustive();
+      this.eb.val("$[0]")
+    ]), "=", this.transformInput(value, "Json", false))).with("array_ends_with", () => this.eb(import_kysely3.sql`JSON_EXTRACT(${lhs}, CONCAT('$[', JSON_LENGTH(${lhs}) - 1, ']'))`, "=", this.transformInput(value, "Json", false))).exhaustive();
+  }
+  buildJsonArrayExistsPredicate(receiver, buildFilter) {
+    return this.eb.exists(this.eb.selectFrom(import_kysely3.sql`JSON_TABLE(${receiver}, '$[*]' COLUMNS(value JSON PATH '$'))`.as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
+  }
+  getFieldSqlType(fieldDef) {
+    if (fieldDef.relation) {
+      throw createInternalError("Cannot get SQL type of a relation field");
+    }
+    let result;
+    if (this.schema.enums?.[fieldDef.type]) {
+      result = "varchar(255)";
+    } else {
+      result = (0, import_ts_pattern3.match)(fieldDef.type).with("String", () => "varchar(255)").with("Boolean", () => "tinyint(1)").with("Int", () => "int").with("BigInt", () => "bigint").with("Float", () => "double").with("Decimal", () => "decimal").with("DateTime", () => "datetime").with("Bytes", () => "blob").with("Json", () => "json").otherwise(() => "text");
+    }
+    if (fieldDef.array) {
+      result = "json";
+    }
+    return result;
+  }
+  getStringCasingBehavior() {
+    return {
+      supportsILike: false,
+      likeCaseSensitive: false
+    };
+  }
+  buildValuesTableSelect(fields, rows) {
+    const cols = rows[0]?.length ?? 0;
+    if (fields.length !== cols) {
+      throw createInvalidInputError("Number of fields must match number of columns in each row");
+    }
+    for (const row of rows) {
+      if (row.length !== cols) {
+        throw createInvalidInputError("All rows must have the same number of columns");
+      }
+    }
+    const aliasWithColumns = `$values(${fields.map((f) => f.name).join(", ")})`;
+    const eb = (0, import_kysely3.expressionBuilder)();
+    return eb.selectFrom(import_kysely3.sql`(VALUES ${import_kysely3.sql.join(rows.map((row) => import_kysely3.sql`ROW(${import_kysely3.sql.join(row.map((v) => import_kysely3.sql.val(v)))})`), import_kysely3.sql.raw(", "))}) as ${import_kysely3.sql.raw(aliasWithColumns)}`).selectAll();
+  }
+  buildOrderByField(query, field, sort, nulls) {
+    let result = query;
+    if (nulls === "first") {
+      result = result.orderBy(import_kysely3.sql`${field} IS NULL`, "desc");
+      result = result.orderBy(field, sort);
+    } else {
+      result = result.orderBy(import_kysely3.sql`${field} IS NULL`, "asc");
+      result = result.orderBy(field, sort);
+    }
+    return result;
+  }
+};
+
+// src/client/crud/dialects/postgresql.ts
+var import_common_helpers5 = require("@zenstackhq/common-helpers");
+var import_decimal2 = __toESM(require("decimal.js"), 1);
+var import_kysely4 = require("kysely");
+var import_postgres_array = require("postgres-array");
+var import_ts_pattern4 = require("ts-pattern");
+var import_zod = __toESM(require("zod"), 1);
+var PostgresCrudDialect = class extends LateralJoinDialectBase {
+  static {
+    __name(this, "PostgresCrudDialect");
+  }
+  isoDateSchema = import_zod.default.iso.datetime({
+    local: true,
+    offset: true
+  });
+  constructor(schema, options) {
+    super(schema, options);
+  }
+  get provider() {
+    return "postgresql";
+  }
+  // #region capabilities
+  get supportsUpdateWithLimit() {
+    return false;
+  }
+  get supportsDeleteWithLimit() {
+    return false;
+  }
+  get supportsDistinctOn() {
+    return true;
+  }
+  get supportsReturning() {
+    return true;
+  }
+  get supportsDefaultAsFieldValue() {
+    return true;
+  }
+  get supportsInsertDefaultValues() {
+    return true;
+  }
+  get insertIgnoreMethod() {
+    return "onConflict";
+  }
+  // #endregion
+  // #region value transformation
+  transformInput(value, type, forArrayField) {
+    if (value === void 0) {
+      return value;
+    }
+    if (value instanceof JsonNullClass) {
+      return "null";
+    } else if (value instanceof DbNullClass) {
+      return null;
+    } else if (value instanceof AnyNullClass) {
+      (0, import_common_helpers5.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+    }
+    if (isTypeDef(this.schema, type)) {
+      if (typeof value !== "string") {
+        return JSON.stringify(value);
+      } else {
+        return value;
+      }
+    } else if (Array.isArray(value)) {
+      if (type === "Json" && !forArrayField) {
+        return JSON.stringify(value);
+      }
+      if (isEnum(this.schema, type)) {
+        return this.eb.cast(import_kysely4.sql`ARRAY[${import_kysely4.sql.join(value.map((v) => this.transformInput(v, type, false)), import_kysely4.sql.raw(","))}]`, this.createSchemaQualifiedEnumType(type, true));
+      } else {
+        return value.map((v) => this.transformInput(v, type, false));
+      }
+    } else {
+      return (0, import_ts_pattern4.match)(type).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value !== null ? value.toString() : value).with("Json", () => {
+        if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          return JSON.stringify(value);
+        } else {
+          return value;
+        }
+      }).otherwise(() => value);
+    }
+  }
+  createSchemaQualifiedEnumType(type, array) {
+    let qualified = type;
+    const enumDef = getEnum(this.schema, type);
+    if (enumDef) {
+      const schemaAttr = enumDef.attributes?.find((attr) => attr.name === "@@schema");
+      if (schemaAttr) {
+        const mapArg = schemaAttr.args?.find((arg) => arg.name === "map");
+        if (mapArg && mapArg.value.kind === "literal") {
+          const schemaName = mapArg.value.value;
+          qualified = `"${schemaName}"."${type}"`;
+        }
+      } else {
+        const defaultSchema = this.schema.provider.defaultSchema ?? "public";
+        qualified = `"${defaultSchema}"."${type}"`;
+      }
+    }
+    return array ? import_kysely4.sql.raw(`${qualified}[]`) : import_kysely4.sql.raw(qualified);
+  }
+  transformOutput(value, type, array) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    return (0, import_ts_pattern4.match)(type).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).when((type2) => isEnum(this.schema, type2), () => this.transformOutputEnum(value, array)).otherwise(() => super.transformOutput(value, type, array));
+  }
+  transformOutputBigInt(value) {
+    if (typeof value === "bigint") {
+      return value;
+    }
+    (0, import_common_helpers5.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    return BigInt(value);
+  }
+  transformDecimal(value) {
+    if (value instanceof import_decimal2.default) {
+      return value;
+    }
+    (0, import_common_helpers5.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);
+  }
+  transformOutputDate(value) {
+    if (typeof value === "string") {
+      if (this.isoDateSchema.safeParse(value).success) {
+        const hasOffset = value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
+        return new Date(hasOffset ? value : `${value}Z`);
+      } else {
+        return value;
+      }
+    } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
+      return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
+    } else {
+      return value;
+    }
+  }
+  transformOutputBytes(value) {
+    return Buffer.isBuffer(value) ? Uint8Array.from(value) : typeof value === "string" && value.startsWith("\\x") ? Uint8Array.from(Buffer.from(value.slice(2), "hex")) : value;
+  }
+  transformOutputEnum(value, array) {
+    if (array && typeof value === "string") {
+      try {
+        return (0, import_postgres_array.parse)(value);
+      } catch {
+      }
+    }
+    return value;
+  }
+  // #endregion
+  // #region other overrides
+  buildArrayAgg(arg) {
+    return this.eb.fn.coalesce(import_kysely4.sql`jsonb_agg(${arg})`, import_kysely4.sql`'[]'::jsonb`);
+  }
+  buildSkipTake(query, skip, take) {
+    if (take !== void 0) {
+      query = query.limit(take);
+    }
+    if (skip !== void 0) {
+      query = query.offset(skip);
+    }
+    return query;
+  }
+  buildJsonObject(value) {
+    return this.eb.fn("jsonb_build_object", Object.entries(value).flatMap(([key, value2]) => [
+      import_kysely4.sql.lit(key),
+      value2
+    ]));
+  }
+  castInt(expression) {
+    return this.eb.cast(expression, "integer");
+  }
+  castText(expression) {
+    return this.eb.cast(expression, "text");
+  }
+  trimTextQuotes(expression) {
+    return this.eb.fn("trim", [
+      expression,
+      import_kysely4.sql.lit('"')
+    ]);
+  }
+  buildArrayLength(array) {
+    return this.eb.fn("array_length", [
+      array
+    ]);
+  }
+  buildArrayLiteralSQL(values) {
+    if (values.length === 0) {
+      return import_kysely4.sql`{}`;
+    } else {
+      return import_kysely4.sql`ARRAY[${import_kysely4.sql.join(values.map((v) => import_kysely4.sql.val(v)), import_kysely4.sql.raw(","))}]`;
+    }
+  }
+  buildJsonPathSelection(receiver, path) {
+    if (path) {
+      return this.eb.fn("jsonb_path_query_first", [
+        receiver,
+        this.eb.val(path)
+      ]);
+    } else {
+      return receiver;
+    }
+  }
+  buildJsonArrayFilter(lhs, operation, value) {
+    return (0, import_ts_pattern4.match)(operation).with("array_contains", () => {
+      const v = Array.isArray(value) ? value : [
+        value
+      ];
+      return import_kysely4.sql`${lhs} @> ${import_kysely4.sql.val(JSON.stringify(v))}::jsonb`;
+    }).with("array_starts_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
+      lhs,
+      this.eb.val("0")
+    ]), "=", this.transformInput(value, "Json", false))).with("array_ends_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
+      lhs,
+      import_kysely4.sql`(jsonb_array_length(${lhs}) - 1)::text`
+    ]), "=", this.transformInput(value, "Json", false))).exhaustive();
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(this.eb.fn("jsonb_array_elements", [
       receiver
     ]).as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  get supportInsertWithDefault() {
-    return true;
-  }
   getFieldSqlType(fieldDef) {
     if (fieldDef.relation) {
       throw createInternalError("Cannot get SQL type of a relation field");
@@ -1838,7 +2122,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     if (this.schema.enums?.[fieldDef.type]) {
       result = "text";
     } else {
-      result = (0, import_ts_pattern3.match)(fieldDef.type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
+      result = (0, import_ts_pattern4.match)(fieldDef.type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
     }
     if (fieldDef.array) {
       result += "[]";
@@ -1851,13 +2135,36 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       likeCaseSensitive: true
     };
   }
+  buildValuesTableSelect(fields, rows) {
+    if (rows.length === 0) {
+      throw createInvalidInputError("At least one row is required to build values table");
+    }
+    const rowLength = rows[0].length;
+    if (fields.length !== rowLength) {
+      throw createInvalidInputError("Number of fields must match number of columns in each row");
+    }
+    for (const row of rows) {
+      if (row.length !== rowLength) {
+        throw createInvalidInputError("All rows must have the same number of columns");
+      }
+    }
+    const eb = (0, import_kysely4.expressionBuilder)();
+    return eb.selectFrom(import_kysely4.sql`(VALUES ${import_kysely4.sql.join(rows.map((row) => import_kysely4.sql`(${import_kysely4.sql.join(row.map((v) => import_kysely4.sql.val(v)))})`), import_kysely4.sql.raw(", "))})`.as("$values")).select(fields.map((f, i) => import_kysely4.sql`CAST(${import_kysely4.sql.ref(`$values.column${i + 1}`)} AS ${import_kysely4.sql.raw(this.getFieldSqlType(f))})`.as(f.name)));
+  }
+  buildOrderByField(query, field, sort, nulls) {
+    return query.orderBy(field, (ob) => {
+      ob = sort === "asc" ? ob.asc() : ob.desc();
+      ob = nulls === "first" ? ob.nullsFirst() : ob.nullsLast();
+      return ob;
+    });
+  }
 };
 
 // src/client/crud/dialects/sqlite.ts
-var import_common_helpers4 = require("@zenstackhq/common-helpers");
-var import_decimal2 = __toESM(require("decimal.js"), 1);
-var import_kysely4 = require("kysely");
-var import_ts_pattern4 = require("ts-pattern");
+var import_common_helpers6 = require("@zenstackhq/common-helpers");
+var import_decimal3 = __toESM(require("decimal.js"), 1);
+var import_kysely5 = require("kysely");
+var import_ts_pattern5 = require("ts-pattern");
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -1865,7 +2172,31 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "sqlite";
   }
-  transformPrimitive(value, type, _forArrayField) {
+  // #region capabilities
+  get supportsUpdateWithLimit() {
+    return false;
+  }
+  get supportsDeleteWithLimit() {
+    return false;
+  }
+  get supportsDistinctOn() {
+    return false;
+  }
+  get supportsReturning() {
+    return true;
+  }
+  get supportsDefaultAsFieldValue() {
+    return false;
+  }
+  get supportsInsertDefaultValues() {
+    return true;
+  }
+  get insertIgnoreMethod() {
+    return "onConflict";
+  }
+  // #endregion
+  // #region value transformation
+  transformInput(value, type, _forArrayField) {
     if (value === void 0) {
       return value;
     }
@@ -1874,15 +2205,15 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     } else if (value instanceof DbNullClass) {
       return null;
     } else if (value instanceof AnyNullClass) {
-      (0, import_common_helpers4.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+      (0, import_common_helpers6.invariant)(false, "should not reach here: AnyNull is not a valid input value");
     }
     if (type === "Json" || this.schema.typeDefs && type in this.schema.typeDefs) {
       return JSON.stringify(value);
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type, false));
+      return value.map((v) => this.transformInput(v, type, false));
     } else {
-      return (0, import_ts_pattern4.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
+      return (0, import_ts_pattern5.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
     }
   }
   transformOutput(value, type, array) {
@@ -1891,21 +2222,21 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     } else if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.transformOutputJson(value);
     } else {
-      return (0, import_ts_pattern4.match)(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("Decimal", () => this.transformOutputDecimal(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Json", () => this.transformOutputJson(value)).otherwise(() => super.transformOutput(value, type, array));
+      return (0, import_ts_pattern5.match)(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("Decimal", () => this.transformOutputDecimal(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Json", () => this.transformOutputJson(value)).otherwise(() => super.transformOutput(value, type, array));
     }
   }
   transformOutputDecimal(value) {
-    if (value instanceof import_decimal2.default) {
+    if (value instanceof import_decimal3.default) {
       return value;
     }
-    (0, import_common_helpers4.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);
+    (0, import_common_helpers6.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal3.default, `Expected string, number or Decimal, got ${typeof value}`);
+    return new import_decimal3.default(value);
   }
   transformOutputBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers6.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformOutputBoolean(value) {
@@ -1935,6 +2266,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     }
     return value;
   }
+  // #endregion
+  // #region other overrides
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     return query.select((eb) => this.buildRelationJSON(model, eb, relationField, parentAlias, payload).as(relationField));
   }
@@ -1960,14 +2293,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
       if (descendantModels.length > 0) {
         objArgs.push(...descendantModels.map((subModel) => [
-          import_kysely4.sql.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+          import_kysely5.sql.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
           eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
         ]).flatMap((v) => v));
       }
       if (payload === true || !payload.select) {
         const omit = typeof payload === "object" ? payload.omit : void 0;
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !this.shouldOmitField(omit, relationModel, name)).map(([field]) => [
-          import_kysely4.sql.lit(field),
+          import_kysely5.sql.lit(field),
           this.fieldRef(relationModel, field, subQueryName, false)
         ]).flatMap((v) => v));
       } else if (payload.select) {
@@ -1975,7 +2308,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
           if (field === "_count") {
             const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
             return [
-              import_kysely4.sql.lit(field),
+              import_kysely5.sql.lit(field),
               subJson
             ];
           } else {
@@ -1983,12 +2316,12 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
             if (fieldDef.relation) {
               const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
               return [
-                import_kysely4.sql.lit(field),
+                import_kysely5.sql.lit(field),
                 subJson
               ];
             } else {
               return [
-                import_kysely4.sql.lit(field),
+                import_kysely5.sql.lit(field),
                 this.fieldRef(relationModel, field, subQueryName, false)
               ];
             }
@@ -1999,15 +2332,15 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
           const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
           return [
-            import_kysely4.sql.lit(field),
+            import_kysely5.sql.lit(field),
             subJson
           ];
         }).flatMap((v) => v));
       }
       if (relationFieldDef.array) {
-        return eb.fn.coalesce(import_kysely4.sql`json_group_array(json_object(${import_kysely4.sql.join(objArgs)}))`, import_kysely4.sql`json_array()`).as("$data");
+        return eb.fn.coalesce(import_kysely5.sql`json_group_array(json_object(${import_kysely5.sql.join(objArgs)}))`, import_kysely5.sql`json_array()`).as("$data");
       } else {
-        return import_kysely4.sql`json_object(${import_kysely4.sql.join(objArgs)})`.as("$data");
+        return import_kysely5.sql`json_object(${import_kysely5.sql.join(objArgs)})`.as("$data");
       }
     });
     return tbl;
@@ -2019,8 +2352,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (m2m) {
       const parentIds = requireIdFields(this.schema, model);
       const relationIds = requireIdFields(this.schema, relationModel);
-      (0, import_common_helpers4.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-      (0, import_common_helpers4.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers6.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers6.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
       selectModelQuery = selectModelQuery.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
     } else {
       const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
@@ -2048,7 +2381,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   }
   buildJsonObject(value) {
     return this.eb.fn("json_object", Object.entries(value).flatMap(([key, value2]) => [
-      import_kysely4.sql.lit(key),
+      import_kysely5.sql.lit(key),
       value2
     ]));
   }
@@ -2056,35 +2389,26 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (!path) {
       return receiver;
     } else {
-      return import_kysely4.sql`${receiver} -> ${this.eb.val(path)}`;
+      return import_kysely5.sql`${receiver} -> ${this.eb.val(path)}`;
     }
   }
   buildJsonArrayFilter(lhs, operation, value) {
-    return (0, import_ts_pattern4.match)(operation).with("array_contains", () => {
+    return (0, import_ts_pattern5.match)(operation).with("array_contains", () => {
       if (Array.isArray(value)) {
         throw createNotSupportedError('SQLite "array_contains" only supports checking for a single value, not an array of values');
       } else {
-        return import_kysely4.sql`EXISTS (SELECT 1 FROM json_each(${lhs}) WHERE value = ${value})`;
+        return import_kysely5.sql`EXISTS (SELECT 1 FROM json_each(${lhs}) WHERE value = ${value})`;
       }
     }).with("array_starts_with", () => this.eb(this.eb.fn("json_extract", [
       lhs,
       this.eb.val("$[0]")
-    ]), "=", value)).with("array_ends_with", () => this.eb(import_kysely4.sql`json_extract(${lhs}, '$[' || (json_array_length(${lhs}) - 1) || ']')`, "=", value)).exhaustive();
+    ]), "=", value)).with("array_ends_with", () => this.eb(import_kysely5.sql`json_extract(${lhs}, '$[' || (json_array_length(${lhs}) - 1) || ']')`, "=", value)).exhaustive();
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(this.eb.fn("json_each", [
       receiver
     ]).as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  get supportsUpdateWithLimit() {
-    return false;
-  }
-  get supportsDeleteWithLimit() {
-    return false;
-  }
-  get supportsDistinctOn() {
-    return false;
-  }
   buildArrayLength(array) {
     return this.eb.fn("json_array_length", [
       array
@@ -2093,8 +2417,17 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   buildArrayLiteralSQL(_values) {
     throw new Error("SQLite does not support array literals");
   }
-  get supportInsertWithDefault() {
-    return false;
+  castInt(expression) {
+    return expression;
+  }
+  castText(expression) {
+    return this.eb.cast(expression, "text");
+  }
+  trimTextQuotes(expression) {
+    return this.eb.fn("trim", [
+      expression,
+      import_kysely5.sql.lit('"')
+    ]);
   }
   getFieldSqlType(fieldDef) {
     if (fieldDef.relation) {
@@ -2106,7 +2439,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (this.schema.enums?.[fieldDef.type]) {
       return "text";
     }
-    return (0, import_ts_pattern4.match)(fieldDef.type).with("String", () => "text").with("Boolean", () => "integer").with("Int", () => "integer").with("BigInt", () => "integer").with("Float", () => "real").with("Decimal", () => "decimal").with("DateTime", () => "numeric").with("Bytes", () => "blob").with("Json", () => "jsonb").otherwise(() => "text");
+    return (0, import_ts_pattern5.match)(fieldDef.type).with("String", () => "text").with("Boolean", () => "integer").with("Int", () => "integer").with("BigInt", () => "integer").with("Float", () => "real").with("Decimal", () => "decimal").with("DateTime", () => "numeric").with("Bytes", () => "blob").with("Json", () => "jsonb").otherwise(() => "text");
   }
   getStringCasingBehavior() {
     return {
@@ -2114,16 +2447,39 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       likeCaseSensitive: false
     };
   }
+  buildValuesTableSelect(fields, rows) {
+    if (rows.length === 0) {
+      throw createInvalidInputError("At least one row is required to build values table");
+    }
+    const rowLength = rows[0].length;
+    if (fields.length !== rowLength) {
+      throw createInvalidInputError("Number of fields must match number of columns in each row");
+    }
+    for (const row of rows) {
+      if (row.length !== rowLength) {
+        throw createInvalidInputError("All rows must have the same number of columns");
+      }
+    }
+    const eb = (0, import_kysely5.expressionBuilder)();
+    return eb.selectFrom(import_kysely5.sql`(VALUES ${import_kysely5.sql.join(rows.map((row) => import_kysely5.sql`(${import_kysely5.sql.join(row.map((v) => import_kysely5.sql.val(v)))})`), import_kysely5.sql.raw(", "))})`.as("$values")).select(fields.map((f, i) => eb.ref(`$values.column${i + 1}`).as(f.name)));
+  }
+  buildOrderByField(query, field, sort, nulls) {
+    return query.orderBy(field, (ob) => {
+      ob = sort === "asc" ? ob.asc() : ob.desc();
+      ob = nulls === "first" ? ob.nullsFirst() : ob.nullsLast();
+      return ob;
+    });
+  }
 };
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return (0, import_ts_pattern5.match)(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
+  return (0, import_ts_pattern6.match)(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).with("mysql", () => new MySqlCrudDialect(schema, options)).exhaustive();
 }
 __name(getCrudDialect, "getCrudDialect");
 
 // src/client/crud/operations/base.ts
-var CoreCrudOperations = [
+var CoreCrudOperations2 = [
   "findMany",
   "findUnique",
   "findFirst",
@@ -2178,7 +2534,7 @@ var CoreDeleteOperations = [
   "deleteMany"
 ];
 var AllCrudOperations = [
-  ...CoreCrudOperations,
+  ...CoreCrudOperations2,
   "findUniqueOrThrow",
   "findFirstOrThrow"
 ];
@@ -2236,12 +2592,12 @@ var BaseOperationHandler = class {
     });
   }
   async existsNonUnique(kysely, model, filter) {
-    const query = kysely.selectNoFrom((eb) => eb.exists(this.dialect.buildSelectModel(model, model).select(import_kysely5.sql.lit(1).as("$t")).where(() => this.dialect.buildFilter(model, model, filter))).as("exists")).modifyEnd(this.makeContextComment({
+    const query = kysely.selectNoFrom((eb) => eb.exists(this.dialect.buildSelectModel(model, model).select(import_kysely6.sql.lit(1).as("$t")).where(() => this.dialect.buildFilter(model, model, filter))).as("exists")).modifyEnd(this.makeContextComment({
       model,
       operation: "read"
     }));
     let result = [];
-    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), (0, import_kysely5.createQueryId)());
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), (0, import_kysely6.createQueryId)());
     try {
       const r = await kysely.getExecutor().executeQuery(compiled);
       result = r.rows;
@@ -2268,7 +2624,7 @@ var BaseOperationHandler = class {
       operation: "read"
     }));
     let result = [];
-    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), (0, import_kysely5.createQueryId)());
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), (0, import_kysely6.createQueryId)());
     try {
       const r = await kysely.getExecutor().executeQuery(compiled);
       result = r.rows;
@@ -2342,9 +2698,9 @@ 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, true);
+          createFields[field] = this.dialect.transformInput(value.set, fieldDef.type, true);
         } else {
-          createFields[field] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
+          createFields[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
         }
       } else {
         const subM2M = getManyToManyRelation(this.schema, model, field);
@@ -2367,11 +2723,37 @@ var BaseOperationHandler = class {
     }
     const updatedData = this.fillGeneratedAndDefaultValues(modelDef, createFields);
     returnFields = returnFields ?? requireIdFields(this.schema, model);
-    const query = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.defaultValues()).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).returning(returnFields).modifyEnd(this.makeContextComment({
-      model,
-      operation: "create"
-    }));
-    const createdEntity = await this.executeQueryTakeFirst(kysely, query, "create");
+    let createdEntity;
+    if (this.dialect.supportsReturning) {
+      const query = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.$if(this.dialect.supportsInsertDefaultValues, () => qb.defaultValues()).$if(!this.dialect.supportsInsertDefaultValues, () => qb.values({}))).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).returning(returnFields).modifyEnd(this.makeContextComment({
+        model,
+        operation: "create"
+      }));
+      createdEntity = await this.executeQueryTakeFirst(kysely, query, "create");
+    } else {
+      const insertQuery = kysely.insertInto(model).$if(Object.keys(updatedData).length === 0, (qb) => qb.$if(this.dialect.supportsInsertDefaultValues, () => qb.defaultValues()).$if(!this.dialect.supportsInsertDefaultValues, () => qb.values({}))).$if(Object.keys(updatedData).length > 0, (qb) => qb.values(updatedData)).modifyEnd(this.makeContextComment({
+        model,
+        operation: "create"
+      }));
+      const insertResult = await this.executeQuery(kysely, insertQuery, "create");
+      const idFields = requireIdFields(this.schema, model);
+      const idValues = {};
+      for (const idField of idFields) {
+        if (insertResult.insertId !== void 0 && insertResult.insertId !== null) {
+          const fieldDef = this.requireField(model, idField);
+          if (this.isAutoIncrementField(fieldDef)) {
+            idValues[idField] = insertResult.insertId;
+            continue;
+          }
+        }
+        if (updatedData[idField] !== void 0) {
+          idValues[idField] = updatedData[idField];
+        } else {
+          throw createInternalError(`Cannot determine ID field "${idField}" value for created model "${model}"`);
+        }
+      }
+      createdEntity = idValues;
+    }
     if (Object.keys(postCreateRelations).length > 0) {
       for (const [field, subPayload] of Object.entries(postCreateRelations)) {
         await this.processNoneOwnedRelationForCreate(kysely, model, field, subPayload, createdEntity);
@@ -2385,6 +2767,9 @@ var BaseOperationHandler = class {
     }
     return createdEntity;
   }
+  isAutoIncrementField(fieldDef) {
+    return fieldDef.default && schema_exports.ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
+  }
   async processBaseModelCreate(kysely, model, createFields, forModel) {
     const thisCreateFields = {};
     const remainingFields = {};
@@ -2397,7 +2782,7 @@ var BaseOperationHandler = class {
       }
     });
     const discriminatorField = getDiscriminatorField(this.schema, model);
-    (0, import_common_helpers5.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    (0, import_common_helpers7.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
     thisCreateFields[discriminatorField] = forModel;
     const baseEntity = await this.create(kysely, model, thisCreateFields, void 0, true);
     const idValues = extractIdFields(baseEntity, this.schema, model);
@@ -2409,8 +2794,8 @@ var BaseOperationHandler = class {
   }
   async buildFkAssignments(kysely, model, relationField, entity) {
     const parentFkFields = {};
-    (0, import_common_helpers5.invariant)(relationField, "parentField must be defined if parentModel is defined");
-    (0, import_common_helpers5.invariant)(entity, "parentEntity must be defined if parentModel is defined");
+    (0, import_common_helpers7.invariant)(relationField, "parentField must be defined if parentModel is defined");
+    (0, import_common_helpers7.invariant)(entity, "parentEntity must be defined if parentModel is defined");
     const { keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
     for (const pair of keyPairs) {
       if (!(pair.pk in entity)) {
@@ -2452,29 +2837,29 @@ var BaseOperationHandler = class {
     ));
     const firstIds = requireIdFields(this.schema, sortedRecords[0].model);
     const secondIds = requireIdFields(this.schema, sortedRecords[1].model);
-    (0, import_common_helpers5.invariant)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
-    (0, import_common_helpers5.invariant)(secondIds.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers7.invariant)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers7.invariant)(secondIds.length === 1, "many-to-many relation must have exactly one id field");
     if (action === "connect") {
       const result = await kysely.insertInto(joinTable).values({
         A: sortedRecords[0].entity[firstIds[0]],
         B: sortedRecords[1].entity[secondIds[0]]
-      }).onConflict((oc) => oc.columns([
+      }).$if(this.dialect.insertIgnoreMethod === "onConflict", (qb) => qb.onConflict((oc) => oc.columns([
         "A",
         "B"
-      ]).doNothing()).execute();
+      ]).doNothing())).$if(this.dialect.insertIgnoreMethod === "ignore", (qb) => qb.ignore()).execute();
       return result[0];
     } else {
-      const eb = (0, import_kysely5.expressionBuilder)();
+      const eb = (0, import_kysely6.expressionBuilder)();
       const result = await kysely.deleteFrom(joinTable).where(eb(`${joinTable}.A`, "=", sortedRecords[0].entity[firstIds[0]])).where(eb(`${joinTable}.B`, "=", sortedRecords[1].entity[secondIds[0]])).execute();
       return result[0];
     }
   }
   resetManyToManyRelation(kysely, model, field, parentIds) {
-    (0, import_common_helpers5.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
+    (0, import_common_helpers7.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
     const parentId = Object.values(parentIds)[0];
     const m2m = getManyToManyRelation(this.schema, model, field);
-    (0, import_common_helpers5.invariant)(m2m, "not a many-to-many relation");
-    const eb = (0, import_kysely5.expressionBuilder)();
+    (0, import_common_helpers7.invariant)(m2m, "not a many-to-many relation");
+    const eb = (0, import_kysely6.expressionBuilder)();
     return kysely.deleteFrom(m2m.joinTable).where(eb(`${m2m.joinTable}.${m2m.parentFkName}`, "=", parentId)).execute();
   }
   async processOwnedRelationForCreate(kysely, relationField, payload) {
@@ -2495,7 +2880,7 @@ var BaseOperationHandler = class {
         }
         case "connect": {
           const referencedPkFields = relationField.relation.references;
-          (0, import_common_helpers5.invariant)(referencedPkFields, "relation must have fields info");
+          (0, import_common_helpers7.invariant)(referencedPkFields, "relation must have fields info");
           const extractedFks = extractFields(subPayload, referencedPkFields);
           if (Object.keys(extractedFks).length === referencedPkFields.length) {
             result = extractedFks;
@@ -2542,13 +2927,13 @@ var BaseOperationHandler = class {
       }
       switch (action) {
         case "create": {
-          for (const item of (0, import_common_helpers5.enumerate)(subPayload)) {
+          for (const item of (0, import_common_helpers7.enumerate)(subPayload)) {
             await this.create(kysely, relationModel, item, fromRelationContext);
           }
           break;
         }
         case "createMany": {
-          (0, import_common_helpers5.invariant)(relationFieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers7.invariant)(relationFieldDef.array, "relation must be an array for createMany");
           await this.createMany(kysely, relationModel, subPayload, false, fromRelationContext);
           break;
         }
@@ -2557,7 +2942,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "connectOrCreate": {
-          for (const item of (0, import_common_helpers5.enumerate)(subPayload)) {
+          for (const item of (0, import_common_helpers7.enumerate)(subPayload)) {
             const found = await this.exists(kysely, relationModel, item.where);
             if (!found) {
               await this.create(kysely, relationModel, item.create, fromRelationContext);
@@ -2579,20 +2964,20 @@ var BaseOperationHandler = class {
       };
     }
     const modelDef = this.requireModel(model);
-    let relationKeyPairs = [];
+    const relationKeyPairs = [];
     if (fromRelation) {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
         throw createInvalidInputError("incorrect relation hierarchy for createMany", model);
       }
-      relationKeyPairs = keyPairs;
+      relationKeyPairs.push(...keyPairs);
     }
-    let createData = (0, import_common_helpers5.enumerate)(input.data).map((item) => {
+    let createData = (0, import_common_helpers7.enumerate)(input.data).map((item) => {
       const newItem = {};
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
-        (0, import_common_helpers5.invariant)(!fieldDef.relation, "createMany does not support relations");
-        newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
+        (0, import_common_helpers7.invariant)(!fieldDef.relation, "createMany does not support relations");
+        newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
       }
       if (fromRelation) {
         for (const { fk, pk } of relationKeyPairs) {
@@ -2601,7 +2986,7 @@ var BaseOperationHandler = class {
       }
       return this.fillGeneratedAndDefaultValues(modelDef, newItem);
     });
-    if (!this.dialect.supportInsertWithDefault) {
+    if (!this.dialect.supportsDefaultAsFieldValue) {
       const allPassedFields = createData.reduce((acc, item) => {
         Object.keys(item).forEach((field) => {
           if (!acc.includes(field)) {
@@ -2618,7 +3003,7 @@ var BaseOperationHandler = class {
           if (!(field in item)) {
             const fieldDef = this.requireField(model, field);
             if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") {
-              item[field] = this.dialect.transformPrimitive(fieldDef.default, fieldDef.type, !!fieldDef.array);
+              item[field] = this.dialect.transformInput(fieldDef.default, fieldDef.type, !!fieldDef.array);
             }
           }
         }
@@ -2631,7 +3016,7 @@ var BaseOperationHandler = class {
       const baseCreateResult = await this.processBaseModelCreateMany(kysely, modelDef.baseModel, createData, !!input.skipDuplicates, model);
       createData = baseCreateResult.remainingFieldRows;
     }
-    const query = kysely.insertInto(model).values(createData).$if(!!input.skipDuplicates, (qb) => qb.onConflict((oc) => oc.doNothing())).modifyEnd(this.makeContextComment({
+    const query = kysely.insertInto(model).values(createData).$if(!!input.skipDuplicates, (qb) => qb.$if(this.dialect.insertIgnoreMethod === "onConflict", () => qb.onConflict((oc) => oc.doNothing())).$if(this.dialect.insertIgnoreMethod === "ignore", () => qb.ignore())).modifyEnd(this.makeContextComment({
       model,
       operation: "create"
     }));
@@ -2642,15 +3027,19 @@ var BaseOperationHandler = class {
       };
     } else {
       fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
-      const result = await query.returning(fieldsToReturn).execute();
-      return result;
+      if (this.dialect.supportsReturning) {
+        const result = await query.returning(fieldsToReturn).execute();
+        return result;
+      } else {
+        throw createNotSupportedError(`\`createManyAndReturn\` is not supported for ${this.dialect.provider}. Use multiple \`create\` calls or query the records after insertion.`);
+      }
     }
   }
   async processBaseModelCreateMany(kysely, model, createRows, skipDuplicates, forModel) {
     const thisCreateRows = [];
     const remainingFieldRows = [];
     const discriminatorField = getDiscriminatorField(this.schema, model);
-    (0, import_common_helpers5.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    (0, import_common_helpers7.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
     for (const createFields of createRows) {
       const thisCreateFields = {};
       const remainingFields = {};
@@ -2666,10 +3055,18 @@ var BaseOperationHandler = class {
       thisCreateRows.push(thisCreateFields);
       remainingFieldRows.push(remainingFields);
     }
-    const baseEntities = await this.createMany(kysely, model, {
-      data: thisCreateRows,
-      skipDuplicates
-    }, true);
+    let baseEntities;
+    if (this.dialect.supportsReturning) {
+      baseEntities = await this.createMany(kysely, model, {
+        data: thisCreateRows,
+        skipDuplicates
+      }, true);
+    } else {
+      baseEntities = [];
+      for (const row of thisCreateRows) {
+        baseEntities.push(await this.create(kysely, model, row, void 0, true));
+      }
+    }
     for (let i = 0; i < baseEntities.length; i++) {
       const idValues = extractIdFields(baseEntities[i], this.schema, model);
       Object.assign(remainingFieldRows[i], idValues);
@@ -2681,7 +3078,7 @@ var BaseOperationHandler = class {
   }
   fillGeneratedAndDefaultValues(modelDef, data) {
     const fields = modelDef.fields;
-    const values = (0, import_common_helpers5.clone)(data);
+    const values = (0, import_common_helpers7.clone)(data);
     for (const [field, fieldDef] of Object.entries(fields)) {
       if (fieldDef.originModel) {
         continue;
@@ -2690,10 +3087,10 @@ var BaseOperationHandler = class {
         if (typeof fieldDef?.default === "object" && "kind" in fieldDef.default) {
           const generated = this.evalGenerator(fieldDef.default);
           if (generated !== void 0) {
-            values[field] = this.dialect.transformPrimitive(generated, fieldDef.type, !!fieldDef.array);
+            values[field] = this.dialect.transformInput(generated, fieldDef.type, !!fieldDef.array);
           }
         } else if (fieldDef?.updatedAt) {
-          values[field] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
+          values[field] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
         } else if (fieldDef?.default !== void 0) {
           let value = fieldDef.default;
           if (fieldDef.type === "Json") {
@@ -2703,7 +3100,7 @@ var BaseOperationHandler = class {
               value = JSON.parse(value);
             }
           }
-          values[field] = this.dialect.transformPrimitive(value, fieldDef.type, !!fieldDef.array);
+          values[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
         }
       }
     }
@@ -2712,7 +3109,7 @@ var BaseOperationHandler = class {
   evalGenerator(defaultValue) {
     if (schema_exports.ExpressionUtils.isCall(defaultValue)) {
       const firstArgVal = defaultValue.args?.[0] && schema_exports.ExpressionUtils.isLiteral(defaultValue.args[0]) ? defaultValue.args[0].value : void 0;
-      return (0, import_ts_pattern6.match)(defaultValue.function).with("cuid", () => {
+      return (0, import_ts_pattern7.match)(defaultValue.function).with("cuid", () => {
         const version = firstArgVal;
         const generated = version === 2 ? (0, import_cuid2.createId)() : (0, import_cuid.default)();
         return this.formatGeneratedValue(generated, defaultValue.args?.[1]);
@@ -2745,32 +3142,7 @@ var BaseOperationHandler = class {
     if (!data || typeof data !== "object") {
       throw createInvalidInputError("data must be an object");
     }
-    const parentWhere = {};
-    let m2m = void 0;
-    if (fromRelation) {
-      m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
-      if (!m2m) {
-        const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
-        if (ownedByModel) {
-          const fromEntity = await this.readUnique(kysely, fromRelation.model, {
-            where: fromRelation.ids
-          });
-          for (const { fk, pk } of keyPairs) {
-            parentWhere[pk] = fromEntity[fk];
-          }
-        } else {
-          for (const { fk, pk } of keyPairs) {
-            parentWhere[fk] = fromRelation.ids[pk];
-          }
-        }
-      } else {
-        const fromRelationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_common_helpers5.invariant)(fromRelationFieldDef.relation?.opposite);
-        parentWhere[fromRelationFieldDef.relation.opposite] = {
-          some: fromRelation.ids
-        };
-      }
-    }
+    const parentWhere = await this.buildUpdateParentRelationFilter(kysely, fromRelation);
     let combinedWhere = where ?? {};
     if (Object.keys(parentWhere).length > 0) {
       combinedWhere = Object.keys(combinedWhere).length > 0 ? {
@@ -2784,11 +3156,11 @@ var BaseOperationHandler = class {
     let finalData = data;
     const autoUpdatedFields = [];
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
-      if (fieldDef.updatedAt) {
+      if (fieldDef.updatedAt && finalData[fieldName] === void 0) {
         if (finalData === data) {
-          finalData = (0, import_common_helpers5.clone)(data);
+          finalData = (0, import_common_helpers7.clone)(data);
         }
-        finalData[fieldName] = this.dialect.transformPrimitive(/* @__PURE__ */ new Date(), "DateTime", false);
+        finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
         autoUpdatedFields.push(fieldName);
       }
     }
@@ -2804,8 +3176,13 @@ var BaseOperationHandler = class {
       return thisEntity;
     }
     let needIdRead = false;
-    if (modelDef.baseModel && !this.isIdFilter(model, combinedWhere)) {
-      needIdRead = true;
+    if (!this.isIdFilter(model, combinedWhere)) {
+      if (modelDef.baseModel) {
+        needIdRead = true;
+      }
+      if (!this.dialect.supportsReturning) {
+        needIdRead = true;
+      }
     }
     if (needIdRead) {
       const readResult = await this.readUnique(kysely, model, {
@@ -2852,20 +3229,84 @@ var BaseOperationHandler = class {
       return thisEntity;
     } else {
       fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
-      const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).returning(fieldsToReturn).modifyEnd(this.makeContextComment({
-        model,
-        operation: "update"
-      }));
-      const updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
+      let updatedEntity;
+      if (this.dialect.supportsReturning) {
+        const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).returning(fieldsToReturn).modifyEnd(this.makeContextComment({
+          model,
+          operation: "update"
+        }));
+        updatedEntity = await this.executeQueryTakeFirst(kysely, query, "update");
+      } else {
+        const updateQuery = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).modifyEnd(this.makeContextComment({
+          model,
+          operation: "update"
+        }));
+        const updateResult = await this.executeQuery(kysely, updateQuery, "update");
+        if (!updateResult.numAffectedRows) {
+          updatedEntity = null;
+        } else {
+          const idFields = requireIdFields(this.schema, model);
+          const filterIdValues = {};
+          for (const key of idFields) {
+            if (combinedWhere[key] !== void 0 && typeof combinedWhere[key] !== "object") {
+              filterIdValues[key] = combinedWhere[key];
+            }
+          }
+          const updatingIdFields = idFields.some((idField) => idField in updateFields);
+          if (Object.keys(filterIdValues).length === idFields.length && !updatingIdFields) {
+            updatedEntity = filterIdValues;
+          } else {
+            const readFilter = {
+              ...combinedWhere
+            };
+            for (const idField of idFields) {
+              if (idField in updateFields && updateFields[idField] !== void 0) {
+                readFilter[idField] = updateFields[idField];
+              }
+            }
+            const selectQuery = kysely.selectFrom(model).select(fieldsToReturn).where(() => this.dialect.buildFilter(model, model, readFilter));
+            updatedEntity = await this.executeQueryTakeFirst(kysely, selectQuery, "update");
+          }
+        }
+      }
       if (!updatedEntity) {
         if (throwIfNotFound) {
           throw createNotFoundError(model);
         } else {
-          return null;
+          return null;
+        }
+      }
+      return updatedEntity;
+    }
+  }
+  async buildUpdateParentRelationFilter(kysely, fromRelation) {
+    const parentWhere = {};
+    let m2m = void 0;
+    if (fromRelation) {
+      m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
+      if (!m2m) {
+        const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
+        if (ownedByModel) {
+          const fromEntity = await this.readUnique(kysely, fromRelation.model, {
+            where: fromRelation.ids
+          });
+          for (const { fk, pk } of keyPairs) {
+            parentWhere[pk] = fromEntity[fk];
+          }
+        } else {
+          for (const { fk, pk } of keyPairs) {
+            parentWhere[fk] = fromRelation.ids[pk];
+          }
         }
+      } else {
+        const fromRelationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
+        (0, import_common_helpers7.invariant)(fromRelationFieldDef.relation?.opposite);
+        parentWhere[fromRelationFieldDef.relation.opposite] = {
+          some: fromRelation.ids
+        };
       }
-      return updatedEntity;
     }
+    return parentWhere;
   }
   processScalarFieldUpdateData(model, field, data) {
     const fieldDef = this.requireField(model, field);
@@ -2875,7 +3316,7 @@ var BaseOperationHandler = class {
     if (fieldDef.array && typeof data[field] === "object" && !Array.isArray(data[field]) && data[field]) {
       return this.transformScalarListUpdate(model, field, fieldDef, data[field]);
     }
-    return this.dialect.transformPrimitive(data[field], fieldDef.type, !!fieldDef.array);
+    return this.dialect.transformInput(data[field], fieldDef.type, !!fieldDef.array);
   }
   isNumericIncrementalUpdate(fieldDef, value) {
     if (!this.isNumericField(fieldDef)) {
@@ -2917,22 +3358,22 @@ var BaseOperationHandler = class {
     };
   }
   transformIncrementalUpdate(model, field, fieldDef, payload) {
-    (0, import_common_helpers5.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
+    (0, import_common_helpers7.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, false);
-    const eb = (0, import_kysely5.expressionBuilder)();
+    const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
+    const eb = (0, import_kysely6.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field);
-    return (0, import_ts_pattern6.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(() => {
+    return (0, import_ts_pattern7.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(() => {
       throw createInvalidInputError(`Invalid incremental update operation: ${key}`);
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
-    (0, import_common_helpers5.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
+    (0, import_common_helpers7.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, true);
-    const eb = (0, import_kysely5.expressionBuilder)();
+    const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
+    const eb = (0, import_kysely6.expressionBuilder)();
     const fieldRef = this.dialect.fieldRef(model, field);
-    return (0, import_ts_pattern6.match)(key).with("set", () => value).with("push", () => {
+    return (0, import_ts_pattern7.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
       throw createInvalidInputError(`Invalid array update operation: ${key}`);
@@ -2942,9 +3383,9 @@ var BaseOperationHandler = class {
     return NUMERIC_FIELD_TYPES.includes(fieldDef.type) && !fieldDef.array;
   }
   makeContextComment(_context) {
-    return import_kysely5.sql``;
+    return import_kysely6.sql``;
   }
-  async updateMany(kysely, model, where, data, limit, returnData, filterModel, fieldsToReturn) {
+  async updateMany(kysely, model, where, data, limit, returnData, filterModel, fromRelation, fieldsToReturn) {
     if (typeof data !== "object") {
       throw createInvalidInputError("data must be an object");
     }
@@ -2957,6 +3398,16 @@ var BaseOperationHandler = class {
     if (modelDef.baseModel && limit !== void 0) {
       throw createNotSupportedError("Updating with a limit is not supported for polymorphic models");
     }
+    const parentWhere = await this.buildUpdateParentRelationFilter(kysely, fromRelation);
+    let combinedWhere = where ?? {};
+    if (Object.keys(parentWhere).length > 0) {
+      combinedWhere = Object.keys(combinedWhere).length > 0 ? {
+        AND: [
+          parentWhere,
+          combinedWhere
+        ]
+      } : parentWhere;
+    }
     filterModel ??= model;
     let updateFields = {};
     for (const field in data) {
@@ -2965,16 +3416,9 @@ var BaseOperationHandler = class {
       }
       updateFields[field] = this.processScalarFieldUpdateData(model, field, data);
     }
-    let shouldFallbackToIdFilter = false;
-    if (limit !== void 0 && !this.dialect.supportsUpdateWithLimit) {
-      shouldFallbackToIdFilter = true;
-    }
-    if (modelDef.isDelegate || modelDef.baseModel) {
-      shouldFallbackToIdFilter = true;
-    }
     let resultFromBaseModel = void 0;
     if (modelDef.baseModel) {
-      const baseResult = await this.processBaseModelUpdateMany(kysely, modelDef.baseModel, where, updateFields, filterModel);
+      const baseResult = await this.processBaseModelUpdateMany(kysely, modelDef.baseModel, combinedWhere, updateFields, filterModel);
       updateFields = baseResult.remainingFields;
       resultFromBaseModel = baseResult.baseResult;
     }
@@ -2983,13 +3427,25 @@ var BaseOperationHandler = class {
         count: 0
       });
     }
+    let shouldFallbackToIdFilter = false;
+    if (limit !== void 0 && !this.dialect.supportsUpdateWithLimit) {
+      shouldFallbackToIdFilter = true;
+    }
+    if (modelDef.isDelegate || modelDef.baseModel) {
+      shouldFallbackToIdFilter = true;
+    }
     let query = kysely.updateTable(model).set(updateFields);
     if (!shouldFallbackToIdFilter) {
-      query = query.where(() => this.dialect.buildFilter(model, model, where)).$if(limit !== void 0, (qb) => qb.limit(limit));
+      query = query.where(() => this.dialect.buildFilter(model, model, combinedWhere)).$if(limit !== void 0, (qb) => qb.limit(limit));
     } else {
-      query = query.where((eb) => eb(eb.refTuple(
-        ...this.buildIdFieldRefs(kysely, model)
-      ), "in", this.dialect.buildSelectModel(filterModel, filterModel).where(this.dialect.buildFilter(filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
+      query = query.where((eb) => eb(
+        eb.refTuple(
+          ...this.buildIdFieldRefs(kysely, model)
+        ),
+        "in",
+        // the outer "select *" is needed to isolate the sub query (as needed for dialects like mysql)
+        eb.selectFrom(this.dialect.buildSelectModel(filterModel, filterModel).where(this.dialect.buildFilter(filterModel, filterModel, combinedWhere)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit)).as("$sub")).selectAll()
+      ));
     }
     query = query.modifyEnd(this.makeContextComment({
       model,
@@ -3002,9 +3458,42 @@ var BaseOperationHandler = class {
       };
     } else {
       fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
-      const finalQuery = query.returning(fieldsToReturn);
-      const result = await this.executeQuery(kysely, finalQuery, "update");
-      return result.rows;
+      if (this.dialect.supportsReturning) {
+        const finalQuery = query.returning(fieldsToReturn);
+        const result = await this.executeQuery(kysely, finalQuery, "update");
+        return result.rows;
+      } else {
+        let selectQuery = kysely.selectFrom(model).selectAll();
+        if (!shouldFallbackToIdFilter) {
+          selectQuery = selectQuery.where(() => this.dialect.buildFilter(model, model, combinedWhere)).$if(limit !== void 0, (qb) => qb.limit(limit));
+        } else {
+          selectQuery = selectQuery.where((eb) => eb(eb.refTuple(
+            ...this.buildIdFieldRefs(kysely, model)
+          ), "in", this.dialect.buildSelectModel(filterModel, filterModel).where(this.dialect.buildFilter(filterModel, filterModel, combinedWhere)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
+        }
+        const recordsToUpdate = await this.executeQuery(kysely, selectQuery, "update");
+        await this.executeQuery(kysely, query, "update");
+        if (recordsToUpdate.rows.length === 0) {
+          return [];
+        }
+        const idFields = requireIdFields(this.schema, model);
+        const updatedIds = recordsToUpdate.rows.map((row) => {
+          const id = {};
+          for (const idField of idFields) {
+            id[idField] = row[idField];
+          }
+          return id;
+        });
+        const resultQuery = kysely.selectFrom(model).selectAll().where((eb) => {
+          const conditions = updatedIds.map((id) => {
+            const idConditions = Object.entries(id).map(([field, value]) => eb.eb(field, "=", value));
+            return eb.and(idConditions);
+          });
+          return eb.or(conditions);
+        });
+        const result = await this.executeQuery(kysely, resultQuery, "update");
+        return result.rows;
+      }
     }
   }
   async processBaseModelUpdateMany(kysely, model, where, updateFields, filterModel) {
@@ -3039,14 +3528,14 @@ var BaseOperationHandler = class {
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
         case "create": {
-          (0, import_common_helpers5.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
-          for (const item of (0, import_common_helpers5.enumerate)(value)) {
+          (0, import_common_helpers7.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
+          for (const item of (0, import_common_helpers7.enumerate)(value)) {
             await this.create(kysely, fieldModel, item, fromRelationContext);
           }
           break;
         }
         case "createMany": {
-          (0, import_common_helpers5.invariant)(fieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers7.invariant)(fieldDef.array, "relation must be an array for createMany");
           await this.createMany(kysely, fieldModel, value, false, fromRelationContext);
           break;
         }
@@ -3063,12 +3552,12 @@ var BaseOperationHandler = class {
           break;
         }
         case "set": {
-          (0, import_common_helpers5.invariant)(fieldDef.array, "relation must be an array");
+          (0, import_common_helpers7.invariant)(fieldDef.array, "relation must be an array");
           await this.setRelation(kysely, fieldModel, value, fromRelationContext);
           break;
         }
         case "update": {
-          for (const _item of (0, import_common_helpers5.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
             const item = _item;
             let where;
             let data;
@@ -3085,7 +3574,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "upsert": {
-          for (const _item of (0, import_common_helpers5.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
             const item = _item;
             const updated = await this.update(kysely, fieldModel, item.where, item.update, fromRelationContext, true, false);
             if (!updated) {
@@ -3095,9 +3584,9 @@ var BaseOperationHandler = class {
           break;
         }
         case "updateMany": {
-          for (const _item of (0, import_common_helpers5.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
             const item = _item;
-            await this.update(kysely, fieldModel, item.where, item.data, fromRelationContext, false, false);
+            await this.updateMany(kysely, fieldModel, item.where, item.data, item.limit, false, fieldModel, fromRelationContext);
           }
           break;
         }
@@ -3139,7 +3628,7 @@ var BaseOperationHandler = class {
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
-        (0, import_common_helpers5.invariant)(_data.length === 1, "only one entity can be connected");
+        (0, import_common_helpers7.invariant)(_data.length === 1, "only one entity can be connected");
         const target = await this.readUnique(kysely, model, {
           where: _data[0]
         });
@@ -3176,7 +3665,7 @@ var BaseOperationHandler = class {
     }
   }
   async connectOrCreateRelation(kysely, model, data, fromRelation) {
-    const _data = (0, import_common_helpers5.enumerate)(data);
+    const _data = (0, import_common_helpers7.enumerate)(data);
     if (_data.length === 0) {
       return;
     }
@@ -3221,9 +3710,9 @@ var BaseOperationHandler = class {
       }
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
-      const eb = (0, import_kysely5.expressionBuilder)();
+      const eb = (0, import_kysely6.expressionBuilder)();
       if (ownedByModel) {
-        (0, import_common_helpers5.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
+        (0, import_common_helpers7.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
         const condition = disconnectConditions[0];
         if (condition === true) {
           for (const { fk } of keyPairs) {
@@ -3355,7 +3844,7 @@ var BaseOperationHandler = class {
     if (m2m) {
       deleteFromModel = model;
       const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-      (0, import_common_helpers5.invariant)(fieldDef.relation?.opposite);
+      (0, import_common_helpers7.invariant)(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
         AND: [
           {
@@ -3379,7 +3868,7 @@ var BaseOperationHandler = class {
           throw createNotFoundError(fromRelation.model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_common_helpers5.invariant)(fieldDef.relation?.opposite);
+        (0, import_common_helpers7.invariant)(fieldDef.relation?.opposite);
         deleteResult = await this.delete(kysely, model, {
           AND: [
             // filter for parent
@@ -3407,12 +3896,12 @@ var BaseOperationHandler = class {
         });
       }
     }
-    if (throwForNotFound && expectedDeleteCount > deleteResult.rows.length) {
+    if (throwForNotFound && expectedDeleteCount > (deleteResult.numAffectedRows ?? 0)) {
       throw createNotFoundError(deleteFromModel);
     }
   }
   normalizeRelationManipulationInput(model, data) {
-    return (0, import_common_helpers5.enumerate)(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
+    return (0, import_common_helpers7.enumerate)(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
   }
   // #endregion
   async delete(kysely, model, where, limit, filterModel, fieldsToReturn) {
@@ -3425,7 +3914,6 @@ var BaseOperationHandler = class {
       return this.processBaseModelDelete(kysely, modelDef.baseModel, where, limit, filterModel);
     }
     fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
-    let query = kysely.deleteFrom(model).returning(fieldsToReturn);
     let needIdFilter = false;
     if (limit !== void 0 && !this.dialect.supportsDeleteWithLimit) {
       needIdFilter = true;
@@ -3433,15 +3921,16 @@ var BaseOperationHandler = class {
     if (modelDef.isDelegate || modelDef.baseModel) {
       needIdFilter = true;
     }
-    if (!needIdFilter) {
-      query = query.where(() => this.dialect.buildFilter(model, model, where));
-    } else {
-      query = query.where((eb) => eb(eb.refTuple(
+    const deleteFilter = needIdFilter ? (eb) => eb(
+      eb.refTuple(
         ...this.buildIdFieldRefs(kysely, model)
-      ), "in", this.dialect.buildSelectModel(filterModel, filterModel).where(() => this.dialect.buildFilter(filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
-    }
+      ),
+      "in",
+      // the outer "select *" is needed to isolate the sub query (as needed for dialects like mysql)
+      eb.selectFrom(this.dialect.buildSelectModel(filterModel, filterModel).where(() => this.dialect.buildFilter(filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit)).as("$sub")).selectAll()
+    ) : () => this.dialect.buildFilter(model, model, where);
     await this.processDelegateRelationDelete(kysely, modelDef, where, limit);
-    query = query.modifyEnd(this.makeContextComment({
+    const query = kysely.deleteFrom(model).where(deleteFilter).$if(this.dialect.supportsReturning, (qb) => qb.returning(fieldsToReturn)).$if(limit !== void 0 && this.dialect.supportsDeleteWithLimit, (qb) => qb.limit(limit)).modifyEnd(this.makeContextComment({
       model,
       operation: "delete"
     }));
@@ -3517,7 +4006,7 @@ var BaseOperationHandler = class {
     if (!args) {
       return;
     }
-    const newArgs = (0, import_common_helpers5.clone)(args);
+    const newArgs = (0, import_common_helpers7.clone)(args);
     this.doNormalizeArgs(newArgs);
     return newArgs;
   }
@@ -3526,7 +4015,7 @@ var BaseOperationHandler = class {
       for (const [key, value] of Object.entries(args)) {
         if (value === void 0) {
           delete args[key];
-        } else if (value && (0, import_common_helpers5.isPlainObject)(value)) {
+        } else if (value && (0, import_common_helpers7.isPlainObject)(value)) {
           this.doNormalizeArgs(value);
         }
       }
@@ -3553,6 +4042,12 @@ var BaseOperationHandler = class {
         selectedFields: void 0
       };
     }
+    if (!this.dialect.supportsReturning) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
     if (args.include && typeof args.include === "object" && Object.keys(args.include).length > 0) {
       return {
         needReadBack: true,
@@ -3622,21 +4117,21 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
         take = -take;
       }
       subQuery = this.dialect.buildSkipTake(subQuery, skip, take);
-      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, negateOrderBy);
+      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, negateOrderBy, take);
       return subQuery.as("$sub");
     });
     for (const [key, value] of Object.entries(parsedArgs)) {
       switch (key) {
         case "_count": {
           if (value === true) {
-            query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("_count"));
+            query = query.select((eb) => this.dialect.castInt(eb.fn.countAll()).as("_count"));
           } else {
             Object.entries(value).forEach(([field, val]) => {
               if (val === true) {
                 if (field === "_all") {
-                  query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as(`_count._all`));
+                  query = query.select((eb) => this.dialect.castInt(eb.fn.countAll()).as(`_count._all`));
                 } else {
-                  query = query.select((eb) => eb.cast(eb.fn.count(eb.ref(`$sub.${field}`)), "integer").as(`${key}.${field}`));
+                  query = query.select((eb) => this.dialect.castInt(eb.fn.count(eb.ref(`$sub.${field}`))).as(`${key}.${field}`));
                 }
               }
             });
@@ -3650,7 +4145,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
               query = query.select((eb) => {
-                const fn = (0, import_ts_pattern7.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
+                const fn = (0, import_ts_pattern8.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
                 return fn(eb.ref(`$sub.${field}`)).as(`${key}.${field}`);
               });
             }
@@ -3683,7 +4178,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern7.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern8.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -3721,11 +4216,11 @@ var CountOperationHandler = class extends BaseOperationHandler {
       return subQuery.as(subQueryName);
     });
     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(eb.ref(`${subQueryName}.${key}`)), "integer").as(key)));
+      query = query.select((eb) => Object.keys(parsedArgs.select).map((key) => key === "_all" ? this.dialect.castInt(eb.fn.countAll()).as("_all") : this.dialect.castInt(eb.fn.count(eb.ref(`${subQueryName}.${key}`))).as(key)));
       const result = await this.executeQuery(this.kysely, query, "count");
       return result.rows[0];
     } else {
-      query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("count"));
+      query = query.select((eb) => this.dialect.castInt(eb.fn.countAll()).as("count"));
       const result = await this.executeQuery(this.kysely, query, "count");
       return result.rows[0].count;
     }
@@ -3733,14 +4228,14 @@ var CountOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/create.ts
-var import_ts_pattern8 = require("ts-pattern");
+var import_ts_pattern9 = require("ts-pattern");
 var CreateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "CreateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern8.match)(operation).with("create", () => this.runCreate(this.inputValidator.validateCreateArgs(this.model, normalizedArgs))).with("createMany", () => {
+    return (0, import_ts_pattern9.match)(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, normalizedArgs));
@@ -3772,7 +4267,7 @@ var CreateOperationHandler = class extends BaseOperationHandler {
         count: 0
       };
     }
-    return this.createMany(this.kysely, this.model, args, false);
+    return this.safeTransaction((tx) => this.createMany(tx, this.model, args, false));
   }
   async runCreateManyAndReturn(args) {
     if (args === void 0) {
@@ -3797,14 +4292,14 @@ var CreateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/delete.ts
-var import_ts_pattern9 = require("ts-pattern");
+var import_ts_pattern10 = require("ts-pattern");
 var DeleteOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "DeleteOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern9.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern10.match)(operation).with("delete", () => this.runDelete(this.inputValidator.validateDeleteArgs(this.model, normalizedArgs))).with("deleteMany", () => this.runDeleteMany(this.inputValidator.validateDeleteManyArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runDelete(args) {
     const { needReadBack, selectedFields } = this.mutationNeedsReadBack(this.model, args);
@@ -3819,7 +4314,7 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
         });
       }
       const deleteResult = await this.delete(tx, this.model, args.where, void 0, void 0, selectedFields);
-      if (deleteResult.rows.length === 0) {
+      if (!deleteResult.numAffectedRows) {
         throw createNotFoundError(this.model);
       }
       return needReadBack ? preDeleteRead : deleteResult.rows[0];
@@ -3833,7 +4328,7 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
     return await this.safeTransaction(async (tx) => {
       const result = await this.delete(tx, this.model, args?.where, args?.limit);
       return {
-        count: result.rows.length
+        count: Number(result.numAffectedRows ?? 0)
       };
     });
   }
@@ -3871,7 +4366,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/group-by.ts
-var import_ts_pattern10 = require("ts-pattern");
+var import_ts_pattern11 = require("ts-pattern");
 var GroupByOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "GroupByOperationHandler");
@@ -3893,7 +4388,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
       take = -take;
     }
     query = this.dialect.buildSkipTake(query, skip, take);
-    query = this.dialect.buildOrderBy(query, this.model, this.model, parsedArgs.orderBy, negateOrderBy);
+    query = this.dialect.buildOrderBy(query, this.model, this.model, parsedArgs.orderBy, negateOrderBy, take);
     if (parsedArgs.having) {
       query = query.having(() => this.dialect.buildFilter(this.model, this.model, parsedArgs.having));
     }
@@ -3904,14 +4399,14 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
       switch (key) {
         case "_count": {
           if (value === true) {
-            query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as("_count"));
+            query = query.select((eb) => this.dialect.castInt(eb.fn.countAll()).as("_count"));
           } else {
             Object.entries(value).forEach(([field, val]) => {
               if (val === true) {
                 if (field === "_all") {
-                  query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as(`_count._all`));
+                  query = query.select((eb) => this.dialect.castInt(eb.fn.countAll()).as(`_count._all`));
                 } else {
-                  query = query.select((eb) => eb.cast(eb.fn.count(fieldRef(field)), "integer").as(`${key}.${field}`));
+                  query = query.select((eb) => this.dialect.castInt(eb.fn.count(fieldRef(field))).as(`${key}.${field}`));
                 }
               }
             });
@@ -3959,7 +4454,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
             val = parseFloat(val);
           } else {
             if (op === "_sum" || op === "_min" || op === "_max") {
-              val = (0, import_ts_pattern10.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
+              val = (0, import_ts_pattern11.match)(type).with("Int", () => parseInt(value, 10)).with("BigInt", () => BigInt(value)).with("Float", () => parseFloat(value)).with("Decimal", () => parseFloat(value)).otherwise(() => value);
             }
           }
         }
@@ -3974,14 +4469,14 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/operations/update.ts
-var import_ts_pattern11 = require("ts-pattern");
+var import_ts_pattern12 = require("ts-pattern");
 var UpdateOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "UpdateOperationHandler");
   }
   async handle(operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
-    return (0, import_ts_pattern11.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
+    return (0, import_ts_pattern12.match)(operation).with("update", () => this.runUpdate(this.inputValidator.validateUpdateArgs(this.model, normalizedArgs))).with("updateMany", () => this.runUpdateMany(this.inputValidator.validateUpdateManyArgs(this.model, normalizedArgs))).with("updateManyAndReturn", () => this.runUpdateManyAndReturn(this.inputValidator.validateUpdateManyAndReturnArgs(this.model, normalizedArgs))).with("upsert", () => this.runUpsert(this.inputValidator.validateUpsertArgs(this.model, normalizedArgs))).exhaustive();
   }
   async runUpdate(args) {
     const { needReadBack, selectedFields } = this.needReadBack(args);
@@ -4022,7 +4517,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     }
     const { needReadBack, selectedFields } = this.needReadBack(args);
     const { readBackResult, updateResult } = await this.safeTransaction(async (tx) => {
-      const updateResult2 = await this.updateMany(tx, this.model, args.where, args.data, args.limit, true, void 0, selectedFields);
+      const updateResult2 = await this.updateMany(tx, this.model, args.where, args.data, args.limit, true, void 0, void 0, selectedFields);
       if (needReadBack) {
         const readBackResult2 = await this.read(tx, this.model, {
           select: args.select,
@@ -4075,6 +4570,12 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
     if (baseResult.needReadBack) {
       return baseResult;
     }
+    if (!this.dialect.supportsReturning) {
+      return {
+        needReadBack: true,
+        selectedFields: void 0
+      };
+    }
     const modelDef = this.requireModel(this.model);
     const nonRelationFields = Object.entries(modelDef.fields).filter(([_, def]) => !def.relation).map(([name, _]) => name);
     if (args.data && !Object.keys(args.data).some((field) => nonRelationFields.includes(field))) {
@@ -4094,10 +4595,9 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator/index.ts
-var import_common_helpers7 = require("@zenstackhq/common-helpers");
-var import_decimal4 = __toESM(require("decimal.js"), 1);
-var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
-var import_ts_pattern13 = require("ts-pattern");
+var import_common_helpers9 = require("@zenstackhq/common-helpers");
+var import_decimal5 = __toESM(require("decimal.js"), 1);
+var import_ts_pattern14 = require("ts-pattern");
 var import_zod3 = require("zod");
 
 // src/utils/zod-utils.ts
@@ -4107,10 +4607,42 @@ function formatError(error) {
 }
 __name(formatError, "formatError");
 
+// src/client/crud/validator/cache-decorator.ts
+var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
+function cache() {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      const cacheKeyObj = {
+        $call: propertyKey,
+        $args: args.map((arg) => {
+          if (Array.isArray(arg)) {
+            return [
+              ...arg
+            ].sort();
+          } else {
+            return arg;
+          }
+        })
+      };
+      const cacheKey = (0, import_json_stable_stringify.default)(cacheKeyObj);
+      const cached = this.getCache(cacheKey);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const result = originalMethod.apply(this, args);
+      this.setCache(cacheKey, result);
+      return result;
+    };
+    return descriptor;
+  };
+}
+__name(cache, "cache");
+
 // src/client/crud/validator/utils.ts
-var import_common_helpers6 = require("@zenstackhq/common-helpers");
-var import_decimal3 = __toESM(require("decimal.js"), 1);
-var import_ts_pattern12 = require("ts-pattern");
+var import_common_helpers8 = require("@zenstackhq/common-helpers");
+var import_decimal4 = __toESM(require("decimal.js"), 1);
+var import_ts_pattern13 = require("ts-pattern");
 var import_zod2 = require("zod");
 var import_v3 = require("zod/v3");
 function getArgValue(expr) {
@@ -4126,7 +4658,7 @@ function addStringValidation(schema, attributes) {
   }
   let result = schema;
   for (const attr of attributes) {
-    (0, import_ts_pattern12.match)(attr.name).with("@length", () => {
+    (0, import_ts_pattern13.match)(attr.name).with("@length", () => {
       const min = getArgValue(attr.args?.[0]?.value);
       if (min !== void 0) {
         result = result.min(min);
@@ -4182,7 +4714,7 @@ function addNumberValidation(schema, attributes) {
     if (val === void 0) {
       continue;
     }
-    (0, import_ts_pattern12.match)(attr.name).with("@gt", () => {
+    (0, import_ts_pattern13.match)(attr.name).with("@gt", () => {
       result = result.gt(val);
     }).with("@gte", () => {
       result = result.gte(val);
@@ -4205,7 +4737,7 @@ function addBigIntValidation(schema, attributes) {
     if (val === void 0) {
       continue;
     }
-    (0, import_ts_pattern12.match)(attr.name).with("@gt", () => {
+    (0, import_ts_pattern13.match)(attr.name).with("@gt", () => {
       result = result.gt(BigInt(val));
     }).with("@gte", () => {
       result = result.gte(BigInt(val));
@@ -4223,14 +4755,14 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   if (schema instanceof import_zod2.z.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
-        new import_decimal3.default(v);
+        new import_decimal4.default(v);
       } catch (err) {
         ctx.addIssue({
           code: import_zod2.z.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
-    }).transform((val) => new import_decimal3.default(val));
+    }).transform((val) => new import_decimal4.default(val));
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
@@ -4266,7 +4798,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
       if (val === void 0) {
         continue;
       }
-      (0, import_ts_pattern12.match)(attr.name).with("@gt", () => {
+      (0, import_ts_pattern13.match)(attr.name).with("@gt", () => {
         result = refine(result, "gt", val);
       }).with("@gte", () => {
         result = refine(result, "gte", val);
@@ -4286,7 +4818,7 @@ function addListValidation(schema, attributes) {
   }
   let result = schema;
   for (const attr of attributes) {
-    (0, import_ts_pattern12.match)(attr.name).with("@length", () => {
+    (0, import_ts_pattern13.match)(attr.name).with("@length", () => {
       const min = getArgValue(attr.args?.[0]?.value);
       if (min !== void 0) {
         result = result.min(min);
@@ -4335,7 +4867,7 @@ function applyValidation(schema, expr, message, path) {
 }
 __name(applyValidation, "applyValidation");
 function evalExpression(data, expr) {
-  return (0, import_ts_pattern12.match)(expr).with({
+  return (0, import_ts_pattern13.match)(expr).with({
     kind: "literal"
   }, (e) => e.value).with({
     kind: "array"
@@ -4353,7 +4885,11 @@ function evalExpression(data, expr) {
     kind: "this"
   }, () => data ?? null).with({
     kind: "null"
-  }, () => null).exhaustive();
+  }, () => null).with({
+    kind: "binding"
+  }, () => {
+    throw new Error("Binding expression is not supported in validation expressions");
+  }).exhaustive();
 }
 __name(evalExpression, "evalExpression");
 function evalField(data, e) {
@@ -4373,7 +4909,7 @@ __name(evalUnary, "evalUnary");
 function evalBinary(data, expr) {
   const left = evalExpression(data, expr.left);
   const right = evalExpression(data, expr.right);
-  return (0, import_ts_pattern12.match)(expr.op).with("&&", () => Boolean(left) && Boolean(right)).with("||", () => Boolean(left) || Boolean(right)).with("==", () => left == right).with("!=", () => left != right).with("<", () => left < right).with("<=", () => left <= right).with(">", () => left > right).with(">=", () => left >= right).with("?", () => {
+  return (0, import_ts_pattern13.match)(expr.op).with("&&", () => Boolean(left) && Boolean(right)).with("||", () => Boolean(left) || Boolean(right)).with("==", () => left == right).with("!=", () => left != right).with("<", () => left < right).with("<=", () => left <= right).with(">", () => left > right).with(">=", () => left >= right).with("?", () => {
     if (!Array.isArray(left)) {
       return false;
     }
@@ -4409,49 +4945,49 @@ function evalMember(data, expr) {
 __name(evalMember, "evalMember");
 function evalCall(data, expr) {
   const fieldArg = expr.args?.[0] ? evalExpression(data, expr.args[0]) : void 0;
-  return (0, import_ts_pattern12.match)(expr.function).with("length", (f) => {
+  return (0, import_ts_pattern13.match)(expr.function).with("length", (f) => {
     if (fieldArg === void 0 || fieldArg === null) {
       return false;
     }
-    (0, import_common_helpers6.invariant)(typeof fieldArg === "string" || Array.isArray(fieldArg), `"${f}" first argument must be a string or a list`);
+    (0, import_common_helpers8.invariant)(typeof fieldArg === "string" || Array.isArray(fieldArg), `"${f}" first argument must be a string or a list`);
     return fieldArg.length;
-  }).with(import_ts_pattern12.P.union("startsWith", "endsWith", "contains"), (f) => {
+  }).with(import_ts_pattern13.P.union("startsWith", "endsWith", "contains"), (f) => {
     if (fieldArg === void 0 || fieldArg === null) {
       return false;
     }
-    (0, import_common_helpers6.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
-    (0, import_common_helpers6.invariant)(expr.args?.[1], `"${f}" requires a search argument`);
+    (0, import_common_helpers8.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
+    (0, import_common_helpers8.invariant)(expr.args?.[1], `"${f}" requires a search argument`);
     const search2 = getArgValue(expr.args?.[1]);
     const caseInsensitive = getArgValue(expr.args?.[2]) ?? false;
-    const matcher = /* @__PURE__ */ __name((x, y) => (0, import_ts_pattern12.match)(f).with("startsWith", () => x.startsWith(y)).with("endsWith", () => x.endsWith(y)).with("contains", () => x.includes(y)).exhaustive(), "matcher");
+    const matcher = /* @__PURE__ */ __name((x, y) => (0, import_ts_pattern13.match)(f).with("startsWith", () => x.startsWith(y)).with("endsWith", () => x.endsWith(y)).with("contains", () => x.includes(y)).exhaustive(), "matcher");
     return caseInsensitive ? matcher(fieldArg.toLowerCase(), search2.toLowerCase()) : matcher(fieldArg, search2);
   }).with("regex", (f) => {
     if (fieldArg === void 0 || fieldArg === null) {
       return false;
     }
-    (0, import_common_helpers6.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
+    (0, import_common_helpers8.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const pattern = getArgValue(expr.args?.[1]);
-    (0, import_common_helpers6.invariant)(pattern !== void 0, `"${f}" requires a pattern argument`);
+    (0, import_common_helpers8.invariant)(pattern !== void 0, `"${f}" requires a pattern argument`);
     return new RegExp(pattern).test(fieldArg);
-  }).with(import_ts_pattern12.P.union("isEmail", "isUrl", "isDateTime"), (f) => {
+  }).with(import_ts_pattern13.P.union("isEmail", "isUrl", "isDateTime"), (f) => {
     if (fieldArg === void 0 || fieldArg === null) {
       return false;
     }
-    (0, import_common_helpers6.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
-    const fn = (0, import_ts_pattern12.match)(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
+    (0, import_common_helpers8.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
+    const fn = (0, import_ts_pattern13.match)(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
     return import_zod2.z.string()[fn]().safeParse(fieldArg).success;
-  }).with(import_ts_pattern12.P.union("has", "hasEvery", "hasSome"), (f) => {
-    (0, import_common_helpers6.invariant)(expr.args?.[1], `${f} requires a search argument`);
+  }).with(import_ts_pattern13.P.union("has", "hasEvery", "hasSome"), (f) => {
+    (0, import_common_helpers8.invariant)(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
       return false;
     }
-    (0, import_common_helpers6.invariant)(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
+    (0, import_common_helpers8.invariant)(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
     const search2 = evalExpression(data, expr.args?.[1]);
-    const matcher = /* @__PURE__ */ __name((x, y) => (0, import_ts_pattern12.match)(f).with("has", () => x.some((item) => item === y)).with("hasEvery", () => {
-      (0, import_common_helpers6.invariant)(Array.isArray(y), "hasEvery second argument must be an array");
+    const matcher = /* @__PURE__ */ __name((x, y) => (0, import_ts_pattern13.match)(f).with("has", () => x.some((item) => item === y)).with("hasEvery", () => {
+      (0, import_common_helpers8.invariant)(Array.isArray(y), "hasEvery second argument must be an array");
       return y.every((v) => x.some((item) => item === v));
     }).with("hasSome", () => {
-      (0, import_common_helpers6.invariant)(Array.isArray(y), "hasSome second argument must be an array");
+      (0, import_common_helpers8.invariant)(Array.isArray(y), "hasSome second argument must be an array");
       return y.some((v) => x.some((item) => item === v));
     }).exhaustive(), "matcher");
     return matcher(fieldArg, search2);
@@ -4459,7 +4995,7 @@ function evalCall(data, expr) {
     if (fieldArg === void 0 || fieldArg === null) {
       return false;
     }
-    (0, import_common_helpers6.invariant)(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
+    (0, import_common_helpers8.invariant)(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
     return fieldArg.length === 0;
   }).otherwise(() => {
     throw createNotSupportedError(`Unsupported function "${expr.function}"`);
@@ -4468,6 +5004,17 @@ function evalCall(data, expr) {
 __name(evalCall, "evalCall");
 
 // src/client/crud/validator/index.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
 var InputValidator = class {
   static {
     __name(this, "InputValidator");
@@ -4486,9 +5033,53 @@ var InputValidator = class {
   get extraValidationsEnabled() {
     return this.client.$options.validateInput !== false;
   }
+  // #region Entry points
+  validateFindArgs(model, args, operation) {
+    return this.validate(model, operation, (model2) => this.makeFindSchema(model2, operation), args);
+  }
+  validateExistsArgs(model, args) {
+    return this.validate(model, "exists", (model2) => this.makeExistsSchema(model2), args);
+  }
+  validateCreateArgs(model, args) {
+    return this.validate(model, "create", (model2) => this.makeCreateSchema(model2), args);
+  }
+  validateCreateManyArgs(model, args) {
+    return this.validate(model, "createMany", (model2) => this.makeCreateManySchema(model2), args);
+  }
+  validateCreateManyAndReturnArgs(model, args) {
+    return this.validate(model, "createManyAndReturn", (model2) => this.makeCreateManyAndReturnSchema(model2), args);
+  }
+  validateUpdateArgs(model, args) {
+    return this.validate(model, "update", (model2) => this.makeUpdateSchema(model2), args);
+  }
+  validateUpdateManyArgs(model, args) {
+    return this.validate(model, "updateMany", (model2) => this.makeUpdateManySchema(model2), args);
+  }
+  validateUpdateManyAndReturnArgs(model, args) {
+    return this.validate(model, "updateManyAndReturn", (model2) => this.makeUpdateManyAndReturnSchema(model2), args);
+  }
+  validateUpsertArgs(model, args) {
+    return this.validate(model, "upsert", (model2) => this.makeUpsertSchema(model2), args);
+  }
+  validateDeleteArgs(model, args) {
+    return this.validate(model, "delete", (model2) => this.makeDeleteSchema(model2), args);
+  }
+  validateDeleteManyArgs(model, args) {
+    return this.validate(model, "deleteMany", (model2) => this.makeDeleteManySchema(model2), args);
+  }
+  validateCountArgs(model, args) {
+    return this.validate(model, "count", (model2) => this.makeCountSchema(model2), args);
+  }
+  validateAggregateArgs(model, args) {
+    return this.validate(model, "aggregate", (model2) => this.makeAggregateSchema(model2), args);
+  }
+  validateGroupByArgs(model, args) {
+    return this.validate(model, "groupBy", (model2) => this.makeGroupBySchema(model2), args);
+  }
+  // TODO: turn it into a Zod schema and cache
   validateProcedureInput(proc, input) {
     const procDef = (this.schema.procedures ?? {})[proc];
-    (0, import_common_helpers7.invariant)(procDef, `Procedure "${proc}" not found in schema`);
+    (0, import_common_helpers9.invariant)(procDef, `Procedure "${proc}" not found in schema`);
     const params = Object.values(procDef.params ?? {});
     if (typeof input === "undefined") {
       if (params.length === 0) {
@@ -4499,7 +5090,7 @@ var InputValidator = class {
       }
       throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
     }
-    if (typeof input !== "object") {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
       throw createInvalidInputError("Procedure input must be an object", `$procs.${proc}`);
     }
     const envelope = input;
@@ -4548,88 +5139,10 @@ var InputValidator = class {
     }
     return input;
   }
-  makeProcedureParamSchema(param) {
-    let schema;
-    if (isTypeDef(this.schema, param.type)) {
-      schema = this.makeTypeDefSchema(param.type);
-    } else if (isEnum(this.schema, param.type)) {
-      schema = this.makeEnumSchema(param.type);
-    } else if (param.type in (this.schema.models ?? {})) {
-      schema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown());
-    } else {
-      schema = this.makeScalarSchema(param.type);
-      if (schema instanceof import_zod3.z.ZodUnknown) {
-        throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
-      }
-    }
-    if (param.array) {
-      schema = schema.array();
-    }
-    if (param.optional) {
-      schema = schema.optional();
-    }
-    return schema;
-  }
-  validateFindArgs(model, args, operation) {
-    return this.validate(model, operation, (model2) => this.makeFindSchema(model2, operation), args);
-  }
-  validateExistsArgs(model, args) {
-    return this.validate(model, "exists", (model2) => this.makeExistsSchema(model2), args);
-  }
-  validateCreateArgs(model, args) {
-    return this.validate(model, "create", (model2) => this.makeCreateSchema(model2), args);
-  }
-  validateCreateManyArgs(model, args) {
-    return this.validate(model, "createMany", (model2) => this.makeCreateManySchema(model2), args);
-  }
-  validateCreateManyAndReturnArgs(model, args) {
-    return this.validate(model, "createManyAndReturn", (model2) => this.makeCreateManyAndReturnSchema(model2), args);
-  }
-  validateUpdateArgs(model, args) {
-    return this.validate(model, "update", (model2) => this.makeUpdateSchema(model2), args);
-  }
-  validateUpdateManyArgs(model, args) {
-    return this.validate(model, "updateMany", (model2) => this.makeUpdateManySchema(model2), args);
-  }
-  validateUpdateManyAndReturnArgs(model, args) {
-    return this.validate(model, "updateManyAndReturn", (model2) => this.makeUpdateManyAndReturnSchema(model2), args);
-  }
-  validateUpsertArgs(model, args) {
-    return this.validate(model, "upsert", (model2) => this.makeUpsertSchema(model2), args);
-  }
-  validateDeleteArgs(model, args) {
-    return this.validate(model, "delete", (model2) => this.makeDeleteSchema(model2), args);
-  }
-  validateDeleteManyArgs(model, args) {
-    return this.validate(model, "deleteMany", (model2) => this.makeDeleteManySchema(model2), args);
-  }
-  validateCountArgs(model, args) {
-    return this.validate(model, "count", (model2) => this.makeCountSchema(model2), args);
-  }
-  validateAggregateArgs(model, args) {
-    return this.validate(model, "aggregate", (model2) => this.makeAggregateSchema(model2), args);
-  }
-  validateGroupByArgs(model, args) {
-    return this.validate(model, "groupBy", (model2) => this.makeGroupBySchema(model2), args);
-  }
-  getSchemaCache(cacheKey) {
-    return this.schemaCache.get(cacheKey);
-  }
-  setSchemaCache(cacheKey, schema) {
-    return this.schemaCache.set(cacheKey, schema);
-  }
+  // #endregion
+  // #region Validation helpers
   validate(model, operation, getSchema, args) {
-    const cacheKey = (0, import_json_stable_stringify.default)({
-      type: "model",
-      model,
-      operation,
-      extraValidationsEnabled: this.extraValidationsEnabled
-    });
-    let schema = this.getSchemaCache(cacheKey);
-    if (!schema) {
-      schema = getSchema(model);
-      this.setSchemaCache(cacheKey, schema);
-    }
+    const schema = getSchema(model);
     const { error, data } = schema.safeParse(args);
     if (error) {
       throw createInvalidInputError(`Invalid ${operation} args for model "${model}": ${formatError(error)}`, model, {
@@ -4661,8 +5174,8 @@ var InputValidator = class {
       const createSchema = "$create" in plugin.queryArgs && plugin.queryArgs["$create"] ? plugin.queryArgs["$create"] : void 0;
       const updateSchema = "$update" in plugin.queryArgs && plugin.queryArgs["$update"] ? plugin.queryArgs["$update"] : void 0;
       if (createSchema && updateSchema) {
-        (0, import_common_helpers7.invariant)(createSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
-        (0, import_common_helpers7.invariant)(updateSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(createSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(updateSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
         result = createSchema.extend(updateSchema.shape);
       } else if (createSchema) {
         result = createSchema;
@@ -4683,9 +5196,10 @@ var InputValidator = class {
     } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
       result = plugin.queryArgs["$all"];
     }
-    (0, import_common_helpers7.invariant)(result === void 0 || result instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+    (0, import_common_helpers9.invariant)(result === void 0 || result instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
     return result;
   }
+  // #endregion
   // #region Find
   makeFindSchema(model, operation) {
     const fields = {};
@@ -4732,13 +5246,13 @@ var InputValidator = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod3.z.string(), attributes) : import_zod3.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number()).with("Boolean", () => import_zod3.z.boolean()).with("BigInt", () => import_zod3.z.union([
+      return (0, import_ts_pattern14.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod3.z.string(), attributes) : import_zod3.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number()).with("Boolean", () => import_zod3.z.boolean()).with("BigInt", () => import_zod3.z.union([
         this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int(),
         this.extraValidationsEnabled ? addBigIntValidation(import_zod3.z.bigint(), attributes) : import_zod3.z.bigint()
       ])).with("Decimal", () => {
         return import_zod3.z.union([
           this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number(),
-          addDecimalValidation(import_zod3.z.instanceof(import_decimal4.default), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(import_zod3.z.instanceof(import_decimal5.default), attributes, this.extraValidationsEnabled),
           addDecimalValidation(import_zod3.z.string(), attributes, this.extraValidationsEnabled)
         ]);
       }).with("DateTime", () => import_zod3.z.union([
@@ -4748,33 +5262,14 @@ var InputValidator = class {
     }
   }
   makeEnumSchema(type) {
-    const key = (0, import_json_stable_stringify.default)({
-      type: "enum",
-      name: type
-    });
-    let schema = this.getSchemaCache(key);
-    if (schema) {
-      return schema;
-    }
     const enumDef = getEnum(this.schema, type);
-    (0, import_common_helpers7.invariant)(enumDef, `Enum "${type}" not found in schema`);
-    schema = import_zod3.z.enum(Object.keys(enumDef.values));
-    this.setSchemaCache(key, schema);
-    return schema;
+    (0, import_common_helpers9.invariant)(enumDef, `Enum "${type}" not found in schema`);
+    return import_zod3.z.enum(Object.keys(enumDef.values));
   }
   makeTypeDefSchema(type) {
-    const key = (0, import_json_stable_stringify.default)({
-      type: "typedef",
-      name: type,
-      extraValidationsEnabled: this.extraValidationsEnabled
-    });
-    let schema = this.getSchemaCache(key);
-    if (schema) {
-      return schema;
-    }
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
-    schema = import_zod3.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    const schema = import_zod3.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makeScalarSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -4793,7 +5288,6 @@ var InputValidator = class {
         parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
       }
     });
-    this.setSchemaCache(key, finalSchema);
     return finalSchema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
@@ -4830,7 +5324,7 @@ var InputValidator = class {
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
           if (Object.keys(enumDef.values).length > 0) {
-            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, withAggregations, !!fieldDef.array);
+            fieldSchema = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations, !!fieldDef.array);
           }
         } else if (fieldDef.array) {
           fieldSchema = this.makeArrayFilterSchema(fieldDef.type);
@@ -4849,12 +5343,12 @@ var InputValidator = class {
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
           fields[uniqueField.name] = import_zod3.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
-            (0, import_common_helpers7.invariant)(!def.relation, "unique field cannot be a relation");
+            (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.values).length > 0) {
-                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false, false);
+                fieldSchema = this.makeEnumFilterSchema(def.type, !!def.optional, false, false);
               } else {
                 fieldSchema = import_zod3.z.never();
               }
@@ -4896,7 +5390,7 @@ var InputValidator = class {
   }
   makeTypedJsonFilterSchema(type, optional, array) {
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
     if (!array) {
       const fieldSchemas = {};
@@ -4906,7 +5400,7 @@ var InputValidator = class {
         } else {
           const enumDef = getEnum(this.schema, fieldDef.type);
           if (enumDef) {
-            fieldSchemas[fieldName] = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, false, !!fieldDef.array).optional();
+            fieldSchemas[fieldName] = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, false, !!fieldDef.array).optional();
           } else if (fieldDef.array) {
             fieldSchemas[fieldName] = this.makeArrayFilterSchema(fieldDef.type).optional();
           } else {
@@ -4938,12 +5432,14 @@ var InputValidator = class {
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
   }
-  makeEnumFilterSchema(enumDef, optional, withAggregations, array) {
+  makeEnumFilterSchema(enumName, optional, withAggregations, array) {
+    const enumDef = getEnum(this.schema, enumName);
+    (0, import_common_helpers9.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
     const baseSchema = import_zod3.z.enum(Object.keys(enumDef.values));
     if (array) {
       return this.internalMakeArrayFilterSchema(baseSchema);
     }
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations, array)), [
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
       "equals",
       "in",
       "notIn",
@@ -4971,7 +5467,7 @@ var InputValidator = class {
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
-    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => this.makeJsonFilterSchema(optional)).with("Unsupported", () => import_zod3.z.never()).exhaustive();
+    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => this.makeJsonFilterSchema(optional)).with("Unsupported", () => import_zod3.z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
@@ -5142,18 +5638,19 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
+        fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
       } else {
         fields[field] = import_zod3.z.boolean().optional();
       }
     }
-    const _countSchema = this.makeCountSelectionSchema(modelDef);
-    if (_countSchema) {
+    const _countSchema = this.makeCountSelectionSchema(model);
+    if (!(_countSchema instanceof import_zod3.z.ZodNever)) {
       fields["_count"] = _countSchema;
     }
     return import_zod3.z.strictObject(fields);
   }
-  makeCountSelectionSchema(modelDef) {
+  makeCountSelectionSchema(model) {
+    const modelDef = requireModel(this.schema, model);
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
       return import_zod3.z.union([
@@ -5171,10 +5668,11 @@ var InputValidator = class {
         })
       ]).optional();
     } else {
-      return void 0;
+      return import_zod3.z.never();
     }
   }
-  makeRelationSelectIncludeSchema(fieldDef) {
+  makeRelationSelectIncludeSchema(model, field) {
+    const fieldDef = requireField(this.schema, model, field);
     let objSchema = import_zod3.z.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
@@ -5220,11 +5718,11 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
+        fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
       }
     }
-    const _countSchema = this.makeCountSelectionSchema(modelDef);
-    if (_countSchema) {
+    const _countSchema = this.makeCountSelectionSchema(model);
+    if (!(_countSchema instanceof import_zod3.z.ZodNever)) {
       fields["_count"] = _countSchema;
     }
     return import_zod3.z.strictObject(fields);
@@ -5345,7 +5843,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
+        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -5421,7 +5919,8 @@ var InputValidator = class {
     const discriminatorField = getDiscriminatorField(this.schema, fieldDef.originModel);
     return discriminatorField === fieldDef.name;
   }
-  makeRelationManipulationSchema(fieldDef, withoutFields, mode) {
+  makeRelationManipulationSchema(model, field, withoutFields, mode) {
+    const fieldDef = requireField(this.schema, model, field);
     const fieldType = fieldDef.type;
     const array = !!fieldDef.array;
     const fields = {
@@ -5571,7 +6070,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
+        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -5771,7 +6270,7 @@ var InputValidator = class {
         continue;
       }
       if (LOGICAL_COMBINATORS.includes(key)) {
-        if ((0, import_common_helpers7.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
+        if ((0, import_common_helpers9.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
           continue;
         }
       }
@@ -5783,6 +6282,47 @@ var InputValidator = class {
     return this.makeWhereSchema(model, false, true, true);
   }
   // #endregion
+  // #region Procedures
+  makeProcedureParamSchema(param) {
+    let schema;
+    if (isTypeDef(this.schema, param.type)) {
+      schema = this.makeTypeDefSchema(param.type);
+    } else if (isEnum(this.schema, param.type)) {
+      schema = this.makeEnumSchema(param.type);
+    } else if (param.type in (this.schema.models ?? {})) {
+      schema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown());
+    } else {
+      schema = this.makeScalarSchema(param.type);
+      if (schema instanceof import_zod3.z.ZodUnknown) {
+        throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
+      }
+    }
+    if (param.array) {
+      schema = schema.array();
+    }
+    if (param.optional) {
+      schema = schema.optional();
+    }
+    return schema;
+  }
+  // #endregion
+  // #region Cache Management
+  getCache(cacheKey) {
+    return this.schemaCache.get(cacheKey);
+  }
+  setCache(cacheKey, schema) {
+    return this.schemaCache.set(cacheKey, schema);
+  }
+  // @ts-ignore
+  printCacheStats(detailed = false) {
+    console.log("Schema cache size:", this.schemaCache.size);
+    if (detailed) {
+      for (const key of this.schemaCache.keys()) {
+        console.log(`	${key}`);
+      }
+    }
+  }
+  // #endregion
   // #region Helpers
   makeSkipSchema() {
     return import_zod3.z.number().int().nonnegative();
@@ -5812,6 +6352,411 @@ var InputValidator = class {
     return this.schema.provider.type === "postgresql";
   }
 };
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    typeof CoreCrudOperations === "undefined" ? Object : CoreCrudOperations
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeFindSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeExistsSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeEnumSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", typeof import_zod3.z === "undefined" || typeof import_zod3.z.ZodType === "undefined" ? Object : import_zod3.z.ZodType)
+], InputValidator.prototype, "makeTypeDefSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    void 0,
+    void 0
+  ]),
+  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+], InputValidator.prototype, "makeWhereSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeTypedJsonFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeEnumFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof BuiltinType === "undefined" ? Object : BuiltinType
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeArrayFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof BuiltinType === "undefined" ? Object : BuiltinType,
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makePrimitiveFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeJsonFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+], InputValidator.prototype, "makeDateTimeFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+], InputValidator.prototype, "makeBooleanFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+], InputValidator.prototype, "makeBytesFilterSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeSelectSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCountSelectionSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeRelationSelectIncludeSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeOmitSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeIncludeSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeOrderBySchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeDistinctSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCreateSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCreateManySchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCreateManyAndReturnSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    Array,
+    void 0
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCreateDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    String,
+    Array,
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeRelationManipulationSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeSetDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeConnectDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeDisconnectDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    Boolean
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeDeleteRelationDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Boolean,
+    Array
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeConnectOrCreateDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Array
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCreateManyDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeUpdateSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeUpdateManySchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeUpdateManyAndReturnSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeUpsertSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String,
+    Array,
+    void 0
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeUpdateDataSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeDeleteSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeDeleteManySchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCountSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeCountAggregateInputSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeAggregateSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeSumAvgInputSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeMinMaxInputSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeGroupBySchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata("design:returntype", typeof import_zod3.z === "undefined" || typeof import_zod3.z.ZodType === "undefined" ? Object : import_zod3.z.ZodType)
+], InputValidator.prototype, "makeProcedureParamSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeSkipSchema", null);
+_ts_decorate([
+  cache(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], InputValidator.prototype, "makeTakeSchema", null);
 
 // src/client/executor/zenstack-driver.ts
 var ZenStackDriver = class {
@@ -5997,24 +6942,26 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-var import_common_helpers9 = require("@zenstackhq/common-helpers");
-var import_kysely7 = require("kysely");
-var import_ts_pattern14 = require("ts-pattern");
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_kysely8 = require("kysely");
+var import_ts_pattern15 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
-var import_common_helpers8 = require("@zenstackhq/common-helpers");
-var import_kysely6 = require("kysely");
-var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
+var import_kysely7 = require("kysely");
+var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   static {
     __name(this, "QueryNameMapper");
   }
-  schema;
+  client;
   modelToTableMap = /* @__PURE__ */ new Map();
   fieldToColumnMap = /* @__PURE__ */ new Map();
   scopes = [];
-  constructor(schema) {
-    super(), this.schema = schema;
-    for (const [modelName, modelDef] of Object.entries(schema.models)) {
+  dialect;
+  constructor(client) {
+    super(), this.client = client;
+    this.dialect = getCrudDialect(client.$schema, client.$options);
+    for (const [modelName, modelDef] of Object.entries(client.$schema.models)) {
       const mappedName = this.getMappedName(modelDef);
       if (mappedName) {
         this.modelToTableMap.set(modelName, mappedName);
@@ -6027,6 +6974,9 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       }
     }
   }
+  get schema() {
+    return this.client.$schema;
+  }
   // #region overrides
   transformSelectQuery(node) {
     if (!node.from?.froms) {
@@ -6052,7 +7002,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       const baseResult = super.transformSelectQuery(node);
       return {
         ...baseResult,
-        from: import_kysely6.FromNode.create(processedFroms.map((f) => f.node)),
+        from: import_kysely7.FromNode.create(processedFroms.map((f) => f.node)),
         joins,
         selections
       };
@@ -6063,7 +7013,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       return super.transformInsertQuery(node);
     }
     const model = extractModelName(node.into);
-    (0, import_common_helpers8.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
+    (0, import_common_helpers10.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
     return this.withScope({
       model
     }, () => {
@@ -6091,7 +7041,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     };
   }
   transformReference(node) {
-    if (!import_kysely6.ColumnNode.is(node.column)) {
+    if (!import_kysely7.ColumnNode.is(node.column)) {
       return super.transformReference(node);
     }
     const scope = this.resolveFieldFromScopes(node.column.column.name, node.table?.table.identifier.name);
@@ -6099,12 +7049,12 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       const mappedFieldName = this.mapFieldName(scope.model, node.column.column.name);
       let mappedTableName = node.table?.table.identifier.name;
       if (mappedTableName) {
-        if (scope.alias && import_kysely6.IdentifierNode.is(scope.alias) && scope.alias.name === mappedTableName) {
+        if (scope.alias && import_kysely7.IdentifierNode.is(scope.alias) && scope.alias.name === mappedTableName) {
         } else if (scope.model === mappedTableName) {
           mappedTableName = this.mapTableName(scope.model);
         }
       }
-      return import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(mappedFieldName), mappedTableName ? this.createTableNode(mappedTableName, void 0) : void 0);
+      return import_kysely7.ReferenceNode.create(import_kysely7.ColumnNode.create(mappedFieldName), mappedTableName ? this.createTableNode(mappedTableName, void 0) : void 0);
     } else {
       return node;
     }
@@ -6115,19 +7065,19 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       return super.transformColumn(node);
     }
     const mappedName = this.mapFieldName(scope.model, node.column.name);
-    return import_kysely6.ColumnNode.create(mappedName);
+    return import_kysely7.ColumnNode.create(mappedName);
   }
   transformBinaryOperation(node) {
-    if (import_kysely6.ReferenceNode.is(node.leftOperand) && import_kysely6.ColumnNode.is(node.leftOperand.column) && (import_kysely6.ValueNode.is(node.rightOperand) || import_kysely6.PrimitiveValueListNode.is(node.rightOperand))) {
+    if (import_kysely7.ReferenceNode.is(node.leftOperand) && import_kysely7.ColumnNode.is(node.leftOperand.column) && (import_kysely7.ValueNode.is(node.rightOperand) || import_kysely7.PrimitiveValueListNode.is(node.rightOperand))) {
       const columnNode = node.leftOperand.column;
       const resolvedScope = this.resolveFieldFromScopes(columnNode.column.name, node.leftOperand.table?.table.identifier.name);
       if (resolvedScope?.model) {
         const valueNode = node.rightOperand;
         let resultValue = valueNode;
-        if (import_kysely6.ValueNode.is(valueNode)) {
+        if (import_kysely7.ValueNode.is(valueNode)) {
           resultValue = this.processEnumMappingForValue(resolvedScope.model, columnNode, valueNode);
-        } else if (import_kysely6.PrimitiveValueListNode.is(valueNode)) {
-          resultValue = import_kysely6.PrimitiveValueListNode.create(this.processEnumMappingForValues(resolvedScope.model, valueNode.values.map(() => columnNode), valueNode.values));
+        } else if (import_kysely7.PrimitiveValueListNode.is(valueNode)) {
+          resultValue = import_kysely7.PrimitiveValueListNode.create(this.processEnumMappingForValues(resolvedScope.model, valueNode.values.map(() => columnNode), valueNode.values));
         }
         return super.transformBinaryOperation({
           ...node,
@@ -6142,20 +7092,20 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       return super.transformUpdateQuery(node);
     }
     const { alias, node: innerTable } = stripAlias(node.table);
-    if (!innerTable || !import_kysely6.TableNode.is(innerTable)) {
+    if (!innerTable || !import_kysely7.TableNode.is(innerTable)) {
       return super.transformUpdateQuery(node);
     }
     const model = extractModelName(innerTable);
-    (0, import_common_helpers8.invariant)(model, 'UpdateQueryNode must have a model name in the "table" clause');
+    (0, import_common_helpers10.invariant)(model, 'UpdateQueryNode must have a model name in the "table" clause');
     return this.withScope({
       model,
       alias
     }, () => {
       const baseResult = super.transformUpdateQuery(node);
       const updates = baseResult.updates?.map((update, i) => {
-        if (import_kysely6.ColumnNode.is(update.column)) {
+        if (import_kysely7.ColumnNode.is(update.column)) {
           const origColumn = node.updates[i].column;
-          return import_kysely6.ColumnUpdateNode.create(update.column, this.processEnumMappingForValue(model, origColumn, update.value));
+          return import_kysely7.ColumnUpdateNode.create(update.column, this.processEnumMappingForValue(model, origColumn, update.value));
         } else {
           return update;
         }
@@ -6179,7 +7129,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     });
     const froms = node.from.froms.map((from) => {
       const { alias, node: innerNode } = stripAlias(from);
-      if (import_kysely6.TableNode.is(innerNode)) {
+      if (import_kysely7.TableNode.is(innerNode)) {
         return this.wrapAlias(this.processTableRef(innerNode), alias);
       } else {
         return super.transformNode(from);
@@ -6188,7 +7138,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     return this.withScopes(scopes, () => {
       return {
         ...super.transformDeleteQuery(node),
-        from: import_kysely6.FromNode.create(froms)
+        from: import_kysely7.FromNode.create(froms)
       };
     });
   }
@@ -6198,7 +7148,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     const selections = [];
     for (const selection of node.selections ?? []) {
       const processedSelections = [];
-      if (import_kysely6.SelectAllNode.is(selection.selection)) {
+      if (import_kysely7.SelectAllNode.is(selection.selection)) {
         const scope = this.requireCurrentScope();
         if (scope?.model && !scope.namesMapped) {
           processedSelections.push(...this.createSelectAllFields(scope.model, scope.alias));
@@ -6208,25 +7158,25 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
             selection: super.transformSelection(selection)
           });
         }
-      } else if (import_kysely6.ReferenceNode.is(selection.selection) || import_kysely6.ColumnNode.is(selection.selection)) {
+      } else if (import_kysely7.ReferenceNode.is(selection.selection) || import_kysely7.ColumnNode.is(selection.selection)) {
         const transformed = this.transformNode(selection.selection);
         const originalField = extractFieldName(selection.selection);
-        if (import_kysely6.AliasNode.is(transformed)) {
+        if (import_kysely7.AliasNode.is(transformed)) {
           processedSelections.push({
             originalField,
-            selection: import_kysely6.SelectionNode.create(transformed)
+            selection: import_kysely7.SelectionNode.create(transformed)
           });
         } else {
           const fieldName = extractFieldName(transformed);
           if (fieldName !== originalField) {
             processedSelections.push({
               originalField,
-              selection: import_kysely6.SelectionNode.create(this.wrapAlias(transformed, originalField ? import_kysely6.IdentifierNode.create(originalField) : void 0))
+              selection: import_kysely7.SelectionNode.create(this.wrapAlias(transformed, originalField ? import_kysely7.IdentifierNode.create(originalField) : void 0))
             });
           } else {
             processedSelections.push({
               originalField,
-              selection: import_kysely6.SelectionNode.create(transformed)
+              selection: import_kysely7.SelectionNode.create(transformed)
             });
           }
         }
@@ -6241,7 +7191,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
         if (!originalField) {
           return selection2;
         } else {
-          return import_kysely6.SelectionNode.create(this.processEnumSelection(selection2.selection, originalField));
+          return import_kysely7.SelectionNode.create(this.processEnumSelection(selection2.selection, originalField));
         }
       });
       selections.push(...enumProcessedSelections);
@@ -6253,7 +7203,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       const scope = this.scopes[i];
       if (qualifier) {
         if (scope.alias) {
-          if (scope.alias && import_kysely6.IdentifierNode.is(scope.alias) && scope.alias.name === qualifier) {
+          if (scope.alias && import_kysely7.IdentifierNode.is(scope.alias) && scope.alias.name === qualifier) {
             return scope;
           } else {
             continue;
@@ -6299,13 +7249,13 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     }
   }
   wrapAlias(node, alias) {
-    return alias ? import_kysely6.AliasNode.create(node, alias) : node;
+    return alias ? import_kysely7.AliasNode.create(node, alias) : node;
   }
   processTableRef(node) {
     if (!node) {
       return node;
     }
-    if (!import_kysely6.TableNode.is(node)) {
+    if (!import_kysely7.TableNode.is(node)) {
       return super.transformNode(node);
     }
     const mappedName = this.mapTableName(node.table.identifier.name);
@@ -6346,15 +7296,15 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
   // convert a "from" node to a nested query if there are columns with name mapping
   processSelectTable(node) {
     const { alias, node: innerNode } = stripAlias(node);
-    if (innerNode && import_kysely6.TableNode.is(innerNode)) {
+    if (innerNode && import_kysely7.TableNode.is(innerNode)) {
       const modelName = innerNode.table.identifier.name;
       const mappedName = this.mapTableName(modelName);
-      const finalAlias = alias ?? (mappedName !== modelName ? import_kysely6.IdentifierNode.create(modelName) : void 0);
+      const finalAlias = alias ?? (mappedName !== modelName ? import_kysely7.IdentifierNode.create(modelName) : void 0);
       const tableSchema = this.getTableSchema(modelName);
       return {
         node: this.wrapAlias(this.createTableNode(mappedName, tableSchema), finalAlias),
         scope: {
-          alias: alias ?? import_kysely6.IdentifierNode.create(modelName),
+          alias: alias ?? import_kysely7.IdentifierNode.create(modelName),
           model: modelName,
           namesMapped: !this.hasMappedColumns(modelName)
         }
@@ -6388,17 +7338,17 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     const modelDef = requireModel(this.schema, model);
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(model, fieldDef.name);
-      const columnRef = import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(columnName), alias && import_kysely6.IdentifierNode.is(alias) ? import_kysely6.TableNode.create(alias.name) : void 0);
+      const columnRef = import_kysely7.ReferenceNode.create(import_kysely7.ColumnNode.create(columnName), alias && import_kysely7.IdentifierNode.is(alias) ? import_kysely7.TableNode.create(alias.name) : void 0);
       if (columnName !== fieldDef.name) {
-        const aliased = import_kysely6.AliasNode.create(columnRef, import_kysely6.IdentifierNode.create(fieldDef.name));
+        const aliased = import_kysely7.AliasNode.create(columnRef, import_kysely7.IdentifierNode.create(fieldDef.name));
         return {
           originalField: fieldDef.name,
-          selection: import_kysely6.SelectionNode.create(aliased)
+          selection: import_kysely7.SelectionNode.create(aliased)
         };
       } else {
         return {
           originalField: fieldDef.name,
-          selection: import_kysely6.SelectionNode.create(columnRef)
+          selection: import_kysely7.SelectionNode.create(columnRef)
         };
       }
     });
@@ -6409,15 +7359,15 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
   processSelections(selections) {
     const result = [];
     selections.forEach((selection) => {
-      if (import_kysely6.SelectAllNode.is(selection.selection)) {
+      if (import_kysely7.SelectAllNode.is(selection.selection)) {
         const processed = this.processSelectAll(selection.selection);
         if (Array.isArray(processed)) {
-          result.push(...processed.map((s) => import_kysely6.SelectionNode.create(s)));
+          result.push(...processed.map((s) => import_kysely7.SelectionNode.create(s)));
         } else {
-          result.push(import_kysely6.SelectionNode.create(processed));
+          result.push(import_kysely7.SelectionNode.create(processed));
         }
       } else {
-        result.push(import_kysely6.SelectionNode.create(this.processSelection(selection.selection)));
+        result.push(import_kysely7.SelectionNode.create(this.processSelection(selection.selection)));
       }
     });
     return result;
@@ -6429,8 +7379,8 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     if (originalField) {
       result = this.processEnumSelection(result, originalField);
     }
-    if (!import_kysely6.AliasNode.is(result)) {
-      const addAlias = alias ?? (originalField ? import_kysely6.IdentifierNode.create(originalField) : void 0);
+    if (!import_kysely7.AliasNode.is(result)) {
+      const addAlias = alias ?? (originalField ? import_kysely7.IdentifierNode.create(originalField) : void 0);
       if (addAlias) {
         result = this.wrapAlias(result, addAlias);
       }
@@ -6445,17 +7395,17 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     const modelDef = requireModel(this.schema, scope.model);
     return this.getModelFields(modelDef).map((fieldDef) => {
       const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
-      const columnRef = import_kysely6.ReferenceNode.create(import_kysely6.ColumnNode.create(columnName));
+      const columnRef = import_kysely7.ReferenceNode.create(import_kysely7.ColumnNode.create(columnName));
       const enumProcessed = this.processEnumSelection(columnRef, fieldDef.name);
-      return columnName !== fieldDef.name && !import_kysely6.AliasNode.is(enumProcessed) ? this.wrapAlias(enumProcessed, import_kysely6.IdentifierNode.create(fieldDef.name)) : enumProcessed;
+      return columnName !== fieldDef.name && !import_kysely7.AliasNode.is(enumProcessed) ? this.wrapAlias(enumProcessed, import_kysely7.IdentifierNode.create(fieldDef.name)) : enumProcessed;
     });
   }
   createTableNode(tableName, schemaName) {
-    return schemaName ? import_kysely6.TableNode.createWithSchema(schemaName, tableName) : import_kysely6.TableNode.create(tableName);
+    return schemaName ? import_kysely7.TableNode.createWithSchema(schemaName, tableName) : import_kysely7.TableNode.create(tableName);
   }
   requireCurrentScope() {
     const scope = this.scopes[this.scopes.length - 1];
-    (0, import_common_helpers8.invariant)(scope, "No scope available");
+    (0, import_common_helpers10.invariant)(scope, "No scope available");
     return scope;
   }
   // #endregion
@@ -6484,16 +7434,16 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     return mapping;
   }
   processEnumMappingForColumns(model, columns, values) {
-    if (import_kysely6.ValuesNode.is(values)) {
-      return import_kysely6.ValuesNode.create(values.values.map((valueItems) => {
-        if (import_kysely6.PrimitiveValueListNode.is(valueItems)) {
-          return import_kysely6.PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+    if (import_kysely7.ValuesNode.is(values)) {
+      return import_kysely7.ValuesNode.create(values.values.map((valueItems) => {
+        if (import_kysely7.PrimitiveValueListNode.is(valueItems)) {
+          return import_kysely7.PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
         } else {
-          return import_kysely6.ValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+          return import_kysely7.ValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
         }
       }));
-    } else if (import_kysely6.PrimitiveValueListNode.is(values)) {
-      return import_kysely6.PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, values.values));
+    } else if (import_kysely7.PrimitiveValueListNode.is(values)) {
+      return import_kysely7.PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, values.values));
     } else {
       return values;
     }
@@ -6523,10 +7473,10 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
       return value;
     }
     const enumValueMapping = this.getEnumValueMapping(enumDef);
-    if (this.isOperationNode(value) && import_kysely6.ValueNode.is(value) && typeof value.value === "string") {
+    if (this.isOperationNode(value) && import_kysely7.ValueNode.is(value) && typeof value.value === "string") {
       const mappedValue = enumValueMapping[value.value];
       if (mappedValue) {
-        return import_kysely6.ValueNode.create(mappedValue);
+        return import_kysely7.ValueNode.create(mappedValue);
       }
     } else if (typeof value === "string") {
       const mappedValue = enumValueMapping[value];
@@ -6542,7 +7492,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     if (!fieldScope || !fieldScope.model) {
       return selection;
     }
-    const aliasName = alias && import_kysely6.IdentifierNode.is(alias) ? alias.name : fieldName;
+    const aliasName = alias && import_kysely7.IdentifierNode.is(alias) ? alias.name : fieldName;
     const fieldDef = getField(this.schema, fieldScope.model, fieldName);
     if (!fieldDef) {
       return selection;
@@ -6555,17 +7505,17 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
     if (Object.keys(enumValueMapping).length === 0) {
       return selection;
     }
-    const eb = (0, import_kysely6.expressionBuilder)();
+    const eb = (0, import_kysely7.expressionBuilder)();
     const caseBuilder = eb.case();
     let caseWhen;
     for (const [key, value] of Object.entries(enumValueMapping)) {
       if (!caseWhen) {
-        caseWhen = caseBuilder.when(new import_kysely6.ExpressionWrapper(node), "=", value).then(key);
+        caseWhen = caseBuilder.when(new import_kysely7.ExpressionWrapper(node), "=", value).then(key);
       } else {
-        caseWhen = caseWhen.when(new import_kysely6.ExpressionWrapper(node), "=", value).then(key);
+        caseWhen = caseWhen.when(new import_kysely7.ExpressionWrapper(node), "=", value).then(key);
       }
     }
-    const finalExpr = caseWhen.else(eb.cast(new import_kysely6.ExpressionWrapper(node), "text")).end();
+    const finalExpr = caseWhen.else(this.dialect.castText(new import_kysely7.ExpressionWrapper(node))).end();
     if (aliasName) {
       return finalExpr.as(aliasName).toOperationNode();
     } else {
@@ -6575,7 +7525,7 @@ var QueryNameMapper = class extends import_kysely6.OperationNodeTransformer {
 };
 
 // src/client/executor/zenstack-query-executor.ts
-var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.DefaultQueryExecutor {
+var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely8.DefaultQueryExecutor {
   static {
     __name(this, "ZenStackQueryExecutor");
   }
@@ -6584,13 +7534,16 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   compiler;
   connectionProvider;
   suppressMutationHooks;
+  // #region constructor, fields and props
   nameMapper;
+  dialect;
   constructor(client, driver, compiler, adapter, connectionProvider, plugins = [], suppressMutationHooks = false) {
     super(compiler, adapter, connectionProvider, plugins), this.client = client, this.driver = driver, this.compiler = compiler, this.connectionProvider = connectionProvider, this.suppressMutationHooks = suppressMutationHooks;
     if (client.$schema.provider.type === "postgresql" || // postgres queries need to be schema-qualified
     this.schemaHasMappedNames(client.$schema)) {
-      this.nameMapper = new QueryNameMapper(client.$schema);
+      this.nameMapper = new QueryNameMapper(client);
     }
+    this.dialect = getCrudDialect(client.$schema, client.$options);
   }
   schemaHasMappedNames(schema) {
     const hasMapAttr = /* @__PURE__ */ __name((decl) => {
@@ -6607,9 +7560,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   get options() {
     return this.client.$options;
   }
-  executeQuery(compiledQuery) {
+  get hasEntityMutationPlugins() {
+    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation);
+  }
+  get hasEntityMutationPluginsWithAfterMutationHooks() {
+    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation?.afterEntityMutation);
+  }
+  // #endregion
+  // #region main entry point
+  async executeQuery(compiledQuery) {
     const queryParams = compiledQuery.$raw ? compiledQuery.parameters : void 0;
-    return this.provideConnection(async (connection) => {
+    const result = await this.provideConnection(async (connection) => {
       let startedTx = false;
       try {
         if (this.isMutationNode(compiledQuery.query) && !this.driver.isTransactionConnection(connection)) {
@@ -6618,11 +7579,11 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
           });
           startedTx = true;
         }
-        const result = await this.proceedQueryWithKyselyInterceptors(connection, compiledQuery.query, queryParams, compiledQuery.queryId);
+        const result2 = await this.proceedQueryWithKyselyInterceptors(connection, compiledQuery.query, queryParams, compiledQuery.queryId);
         if (startedTx) {
           await this.driver.commitTransaction(connection);
         }
-        return result;
+        return result2;
       } catch (err) {
         if (startedTx) {
           await this.driver.rollbackTransaction(connection);
@@ -6634,6 +7595,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
         }
       }
     });
+    return this.ensureProperQueryResult(compiledQuery.query, result);
   }
   async proceedQueryWithKyselyInterceptors(connection, queryNode, parameters, queryId) {
     let proceed = /* @__PURE__ */ __name((q) => this.proceedQuery(connection, q, parameters, queryId), "proceed");
@@ -6659,139 +7621,81 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
     const result = await proceed(queryNode);
     return result;
   }
-  getMutationInfo(queryNode) {
-    const model = this.getMutationModel(queryNode);
-    const { action, where } = (0, import_ts_pattern14.match)(queryNode).when(import_kysely7.InsertQueryNode.is, () => ({
-      action: "create",
-      where: void 0
-    })).when(import_kysely7.UpdateQueryNode.is, (node) => ({
-      action: "update",
-      where: node.where
-    })).when(import_kysely7.DeleteQueryNode.is, (node) => ({
-      action: "delete",
-      where: node.where
-    })).exhaustive();
-    return {
-      model,
-      action,
-      where
-    };
-  }
   async proceedQuery(connection, query, parameters, queryId) {
-    let compiled;
     if (this.suppressMutationHooks || !this.isMutationNode(query) || !this.hasEntityMutationPlugins) {
-      const finalQuery2 = this.processNameMapping(query);
-      compiled = this.compileQuery(finalQuery2, queryId);
-      if (parameters) {
-        compiled = {
-          ...compiled,
-          parameters
+      return this.internalExecuteQuery(query, connection, queryId, parameters);
+    }
+    let preUpdateIds;
+    const mutationModel = this.getMutationModel(query);
+    const needLoadAfterMutationEntities = (import_kysely8.InsertQueryNode.is(query) || import_kysely8.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks;
+    if (needLoadAfterMutationEntities) {
+      if (this.dialect.supportsReturning) {
+        query = {
+          ...query,
+          returning: import_kysely8.ReturningNode.create([
+            import_kysely8.SelectionNode.createSelectAll()
+          ])
         };
+      } else {
+        if (import_kysely8.UpdateQueryNode.is(query)) {
+          preUpdateIds = await this.getPreUpdateIds(mutationModel, query, connection);
+        }
       }
-      return this.internalExecuteQuery(connection, compiled);
-    }
-    if ((import_kysely7.InsertQueryNode.is(query) || import_kysely7.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks) {
-      query = {
-        ...query,
-        returning: import_kysely7.ReturningNode.create([
-          import_kysely7.SelectionNode.createSelectAll()
-        ])
-      };
-    }
-    const finalQuery = this.processNameMapping(query);
-    compiled = this.compileQuery(finalQuery, queryId);
-    if (parameters) {
-      compiled = {
-        ...compiled,
-        parameters
-      };
     }
     const currentlyInTx = this.driver.isTransactionConnection(connection);
     const connectionClient = this.createClientForConnection(connection, currentlyInTx);
-    const mutationInfo = this.getMutationInfo(finalQuery);
+    const mutationInfo = this.getMutationInfo(query);
     let beforeMutationEntities;
     const loadBeforeMutationEntities = /* @__PURE__ */ __name(async () => {
-      if (beforeMutationEntities === void 0 && (import_kysely7.UpdateQueryNode.is(query) || import_kysely7.DeleteQueryNode.is(query))) {
-        beforeMutationEntities = await this.loadEntities(mutationInfo.model, mutationInfo.where, connection);
+      if (beforeMutationEntities === void 0 && (import_kysely8.UpdateQueryNode.is(query) || import_kysely8.DeleteQueryNode.is(query))) {
+        beforeMutationEntities = await this.loadEntities(mutationInfo.model, mutationInfo.where, connection, void 0);
       }
       return beforeMutationEntities;
     }, "loadBeforeMutationEntities");
-    await this.callBeforeMutationHooks(finalQuery, mutationInfo, loadBeforeMutationEntities, connectionClient, queryId);
-    const result = await this.internalExecuteQuery(connection, compiled);
+    await this.callBeforeMutationHooks({
+      queryNode: query,
+      mutationInfo,
+      loadBeforeMutationEntities,
+      client: connectionClient,
+      queryId
+    });
+    const result = await this.internalExecuteQuery(query, connection, queryId, parameters);
+    let afterMutationEntities;
+    if (needLoadAfterMutationEntities) {
+      afterMutationEntities = await this.loadAfterMutationEntities(mutationInfo, query, result, connection, preUpdateIds);
+    }
+    const baseArgs = {
+      queryResult: result,
+      queryNode: query,
+      mutationInfo,
+      filterFor: "all",
+      client: connectionClient,
+      connection,
+      queryId,
+      beforeMutationEntities,
+      afterMutationEntities
+    };
     if (!this.driver.isTransactionConnection(connection)) {
-      await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "all", queryId);
+      await this.callAfterMutationHooks({
+        ...baseArgs,
+        filterFor: "all"
+      });
     } else {
-      await this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "inTx", queryId);
-      this.driver.registerTransactionCommitCallback(connection, () => this.callAfterMutationHooks(result, finalQuery, mutationInfo, connectionClient, "outTx", queryId));
+      await this.callAfterMutationHooks({
+        ...baseArgs,
+        filterFor: "inTx"
+      });
+      this.driver.registerTransactionCommitCallback(connection, () => this.callAfterMutationHooks({
+        ...baseArgs,
+        filterFor: "outTx"
+      }));
     }
     return result;
   }
-  processNameMapping(query) {
-    return this.nameMapper?.transformNode(query) ?? query;
-  }
-  createClientForConnection(connection, inTx) {
-    const innerExecutor = this.withConnectionProvider(new import_kysely7.SingleConnectionProvider(connection));
-    innerExecutor.suppressMutationHooks = true;
-    const innerClient = this.client.withExecutor(innerExecutor);
-    if (inTx) {
-      innerClient.forceTransaction();
-    }
-    return innerClient;
-  }
-  get hasEntityMutationPlugins() {
-    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation);
-  }
-  get hasEntityMutationPluginsWithAfterMutationHooks() {
-    return (this.client.$options.plugins ?? []).some((plugin) => plugin.onEntityMutation?.afterEntityMutation);
-  }
-  isMutationNode(queryNode) {
-    return import_kysely7.InsertQueryNode.is(queryNode) || import_kysely7.UpdateQueryNode.is(queryNode) || import_kysely7.DeleteQueryNode.is(queryNode);
-  }
-  withPlugin(plugin) {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
-      ...this.plugins,
-      plugin
-    ], this.suppressMutationHooks);
-  }
-  withPlugins(plugins) {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
-      ...this.plugins,
-      ...plugins
-    ], this.suppressMutationHooks);
-  }
-  withPluginAtFront(plugin) {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
-      plugin,
-      ...this.plugins
-    ], this.suppressMutationHooks);
-  }
-  withoutPlugins() {
-    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [], this.suppressMutationHooks);
-  }
-  withConnectionProvider(connectionProvider) {
-    const newExecutor = new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider, this.plugins, this.suppressMutationHooks);
-    newExecutor.client = this.client.withExecutor(newExecutor);
-    return newExecutor;
-  }
-  getMutationModel(queryNode) {
-    return (0, import_ts_pattern14.match)(queryNode).when(import_kysely7.InsertQueryNode.is, (node) => {
-      (0, import_common_helpers9.invariant)(node.into, "InsertQueryNode must have an into clause");
-      return node.into.table.identifier.name;
-    }).when(import_kysely7.UpdateQueryNode.is, (node) => {
-      (0, import_common_helpers9.invariant)(node.table, "UpdateQueryNode must have a table");
-      const { node: tableNode } = stripAlias(node.table);
-      (0, import_common_helpers9.invariant)(import_kysely7.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
-      return tableNode.table.identifier.name;
-    }).when(import_kysely7.DeleteQueryNode.is, (node) => {
-      (0, import_common_helpers9.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
-      const { node: tableNode } = stripAlias(node.from.froms[0]);
-      (0, import_common_helpers9.invariant)(import_kysely7.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
-      return tableNode.table.identifier.name;
-    }).otherwise((node) => {
-      throw createInternalError(`Invalid query node: ${node}`);
-    });
-  }
-  async callBeforeMutationHooks(queryNode, mutationInfo, loadBeforeMutationEntities, client, queryId) {
+  // #endregion
+  // #region before and after mutation hooks
+  async callBeforeMutationHooks(args) {
+    const { queryNode, mutationInfo, loadBeforeMutationEntities, client, queryId } = args;
     if (this.options.plugins) {
       for (const plugin of this.options.plugins) {
         const onEntityMutation = plugin.onEntityMutation;
@@ -6809,7 +7713,8 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
       }
     }
   }
-  async callAfterMutationHooks(queryResult, queryNode, mutationInfo, client, filterFor, queryId) {
+  async callAfterMutationHooks(args) {
+    const { queryNode, mutationInfo, client, filterFor, queryId, beforeMutationEntities, afterMutationEntities } = args;
     const hooks = [];
     for (const plugin of this.options.plugins ?? []) {
       const onEntityMutation = plugin.onEntityMutation;
@@ -6827,52 +7732,249 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
     if (hooks.length === 0) {
       return;
     }
-    const mutationModel = this.getMutationModel(queryNode);
-    const loadAfterMutationEntities = /* @__PURE__ */ __name(async () => {
-      if (mutationInfo.action === "delete") {
-        return void 0;
-      } else {
-        return queryResult.rows;
-      }
-    }, "loadAfterMutationEntities");
     for (const hook of hooks) {
       await hook({
-        model: mutationModel,
+        model: mutationInfo.model,
         action: mutationInfo.action,
         queryNode,
-        loadAfterMutationEntities,
+        loadAfterMutationEntities: /* @__PURE__ */ __name(() => Promise.resolve(afterMutationEntities), "loadAfterMutationEntities"),
+        beforeMutationEntities,
         client,
         queryId
       });
     }
   }
-  async loadEntities(model, where, connection) {
-    const selectQuery = this.kysely.selectFrom(model).selectAll();
+  async loadAfterMutationEntities(mutationInfo, queryNode, queryResult, connection, preUpdateIds) {
+    if (mutationInfo.action === "delete") {
+      return void 0;
+    }
+    if (this.dialect.supportsReturning) {
+      return queryResult.rows;
+    } else {
+      const mutatedIds = import_kysely8.InsertQueryNode.is(queryNode) ? this.getInsertIds(mutationInfo.model, queryNode, queryResult) : preUpdateIds;
+      if (mutatedIds) {
+        const idFields = requireIdFields(this.client.$schema, mutationInfo.model);
+        const eb = (0, import_kysely8.expressionBuilder)();
+        const filter = eb(
+          // @ts-ignore
+          eb.refTuple(...idFields),
+          "in",
+          mutatedIds.map((idObj) => eb.tuple(
+            ...idFields.map((idField) => eb.val(idObj[idField]))
+          ))
+        );
+        const entities = await this.loadEntities(mutationInfo.model, import_kysely8.WhereNode.create(filter.toOperationNode()), connection, void 0);
+        return entities;
+      } else {
+        console.warn(`Unable to load after-mutation entities for hooks: model "${mutationInfo.model}", operation "${mutationInfo.action}".
+This happens when the following conditions are met:
+
+1. The database does not support RETURNING clause for INSERT/UPDATE, e.g., MySQL.
+2. The mutation creates or updates multiple entities at once.
+3. For create: the model does not have all ID fields explicitly set in the mutation data.
+4. For update: the mutation modifies ID fields.
+
+In such cases, ZenStack cannot reliably determine the IDs of the mutated entities to reload them.
+`);
+        return [];
+      }
+    }
+  }
+  async getPreUpdateIds(mutationModel, query, connection) {
+    const idFields = requireIdFields(this.client.$schema, mutationModel);
+    if (query.updates) {
+      for (const update of query.updates) {
+        if (import_kysely8.ColumnUpdateNode.is(update)) {
+          const columnNode = update.column;
+          if (import_kysely8.ColumnNode.is(columnNode)) {
+            const columnName = columnNode.column.name;
+            if (idFields.includes(columnName)) {
+              return void 0;
+            }
+          }
+        }
+      }
+    }
+    return await this.loadEntities(this.getMutationModel(query), query.where, connection, idFields);
+  }
+  getInsertIds(mutationModel, query, queryResult) {
+    const idFields = requireIdFields(this.client.$schema, mutationModel);
+    if (import_kysely8.InsertQueryNode.is(query) && queryResult.numAffectedRows === 1n && queryResult.insertId && idFields.length === 1) {
+      return [
+        {
+          [idFields[0]]: queryResult.insertId
+        }
+      ];
+    }
+    const columns = query.columns;
+    if (!columns) {
+      return void 0;
+    }
+    const values = query.values;
+    if (!values || !import_kysely8.ValuesNode.is(values)) {
+      return void 0;
+    }
+    const allIds = [];
+    for (const valuesItem of values.values) {
+      const rowIds = {};
+      if (import_kysely8.PrimitiveValueListNode.is(valuesItem)) {
+        (0, import_common_helpers11.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
+        for (const idField of idFields) {
+          const colIndex = columns.findIndex((col) => col.column.name === idField);
+          if (colIndex === -1) {
+            return void 0;
+          }
+          rowIds[idField] = valuesItem.values[colIndex];
+        }
+      } else {
+        (0, import_common_helpers11.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
+        for (const idField of idFields) {
+          const colIndex = columns.findIndex((col) => col.column.name === idField);
+          if (colIndex === -1) {
+            return void 0;
+          }
+          const valueNode = valuesItem.values[colIndex];
+          if (!valueNode || !import_kysely8.ValueNode.is(valueNode)) {
+            return void 0;
+          }
+          rowIds[idField] = valueNode.value;
+        }
+      }
+      allIds.push(rowIds);
+    }
+    return allIds;
+  }
+  async loadEntities(model, where, connection, fieldsToLoad) {
+    let selectQuery = this.kysely.selectFrom(model);
+    if (fieldsToLoad) {
+      selectQuery = selectQuery.select(fieldsToLoad);
+    } else {
+      selectQuery = selectQuery.selectAll();
+    }
     let selectQueryNode = selectQuery.toOperationNode();
     selectQueryNode = {
       ...selectQueryNode,
       where: this.andNodes(selectQueryNode.where, where)
     };
-    const compiled = this.compileQuery(selectQueryNode, (0, import_kysely7.createQueryId)());
-    const result = await this.internalExecuteQuery(connection, compiled);
+    const result = await this.internalExecuteQuery(selectQueryNode, connection);
     return result.rows;
   }
+  // #endregion
+  // #region utilities
+  getMutationInfo(queryNode) {
+    const model = this.getMutationModel(queryNode);
+    const { action, where } = (0, import_ts_pattern15.match)(queryNode).when(import_kysely8.InsertQueryNode.is, () => ({
+      action: "create",
+      where: void 0
+    })).when(import_kysely8.UpdateQueryNode.is, (node) => ({
+      action: "update",
+      where: node.where
+    })).when(import_kysely8.DeleteQueryNode.is, (node) => ({
+      action: "delete",
+      where: node.where
+    })).exhaustive();
+    return {
+      model,
+      action,
+      where
+    };
+  }
+  isMutationNode(queryNode) {
+    return import_kysely8.InsertQueryNode.is(queryNode) || import_kysely8.UpdateQueryNode.is(queryNode) || import_kysely8.DeleteQueryNode.is(queryNode);
+  }
+  getMutationModel(queryNode) {
+    return (0, import_ts_pattern15.match)(queryNode).when(import_kysely8.InsertQueryNode.is, (node) => {
+      (0, import_common_helpers11.invariant)(node.into, "InsertQueryNode must have an into clause");
+      return node.into.table.identifier.name;
+    }).when(import_kysely8.UpdateQueryNode.is, (node) => {
+      (0, import_common_helpers11.invariant)(node.table, "UpdateQueryNode must have a table");
+      const { node: tableNode } = stripAlias(node.table);
+      (0, import_common_helpers11.invariant)(import_kysely8.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
+      return tableNode.table.identifier.name;
+    }).when(import_kysely8.DeleteQueryNode.is, (node) => {
+      (0, import_common_helpers11.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      const { node: tableNode } = stripAlias(node.from.froms[0]);
+      (0, import_common_helpers11.invariant)(import_kysely8.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
+      return tableNode.table.identifier.name;
+    }).otherwise((node) => {
+      throw createInternalError(`Invalid query node: ${node}`);
+    });
+  }
+  processNameMapping(query) {
+    return this.nameMapper?.transformNode(query) ?? query;
+  }
+  createClientForConnection(connection, inTx) {
+    const innerExecutor = this.withConnectionProvider(new import_kysely8.SingleConnectionProvider(connection));
+    innerExecutor.suppressMutationHooks = true;
+    const innerClient = this.client.withExecutor(innerExecutor);
+    if (inTx) {
+      innerClient.forceTransaction();
+    }
+    return innerClient;
+  }
   andNodes(condition1, condition2) {
     if (condition1 && condition2) {
-      return import_kysely7.WhereNode.create(import_kysely7.AndNode.create(condition1, condition2));
+      return import_kysely8.WhereNode.create(import_kysely8.AndNode.create(condition1, condition2));
     } else if (condition1) {
-      return import_kysely7.WhereNode.create(condition1);
+      return import_kysely8.WhereNode.create(condition1);
     } else {
       return condition2;
     }
   }
-  async internalExecuteQuery(connection, compiledQuery) {
+  async internalExecuteQuery(query, connection, queryId, parameters) {
+    const finalQuery = this.processNameMapping(query);
+    let compiledQuery = this.compileQuery(finalQuery, queryId ?? (0, import_kysely8.createQueryId)());
+    if (parameters) {
+      compiledQuery = {
+        ...compiledQuery,
+        parameters
+      };
+    }
     try {
-      return await connection.executeQuery(compiledQuery);
+      const result = await connection.executeQuery(compiledQuery);
+      return this.ensureProperQueryResult(compiledQuery.query, result);
     } catch (err) {
       throw createDBQueryError(`Failed to execute query: ${err}`, err, compiledQuery.sql, compiledQuery.parameters);
     }
   }
+  ensureProperQueryResult(query, result) {
+    let finalResult = result;
+    if (this.isMutationNode(query)) {
+      finalResult = {
+        ...result,
+        numAffectedRows: result.numAffectedRows ?? BigInt(result.rows.length)
+      };
+    }
+    return finalResult;
+  }
+  // #endregion
+  // #region other overrides
+  withPlugin(plugin) {
+    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
+      ...this.plugins,
+      plugin
+    ], this.suppressMutationHooks);
+  }
+  withPlugins(plugins) {
+    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
+      ...this.plugins,
+      ...plugins
+    ], this.suppressMutationHooks);
+  }
+  withPluginAtFront(plugin) {
+    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [
+      plugin,
+      ...this.plugins
+    ], this.suppressMutationHooks);
+  }
+  withoutPlugins() {
+    return new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, this.connectionProvider, [], this.suppressMutationHooks);
+  }
+  withConnectionProvider(connectionProvider) {
+    const newExecutor = new _ZenStackQueryExecutor(this.client, this.driver, this.compiler, this.adapter, connectionProvider, this.plugins, this.suppressMutationHooks);
+    newExecutor.client = this.client.withExecutor(newExecutor);
+    return newExecutor;
+  }
 };
 
 // src/client/functions.ts
@@ -6890,9 +7992,9 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
-var import_kysely8 = require("kysely");
-var import_ts_pattern15 = require("ts-pattern");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_kysely9 = require("kysely");
+var import_ts_pattern16 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
 var search = /* @__PURE__ */ __name((_eb, _args) => {
   throw new Error(`"search" function is not implemented yet`);
@@ -6929,19 +8031,20 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   } else {
     op = "like";
   }
-  const escapedSearch = import_kysely8.sql`REPLACE(REPLACE(REPLACE(CAST(${searchExpr} as text), '\\', '\\\\'), '%', '\\%'), '_', '\\_')`;
-  searchExpr = (0, import_ts_pattern15.match)(method).with("contains", () => eb.fn("CONCAT", [
-    import_kysely8.sql.lit("%"),
+  searchExpr = eb.fn.coalesce(searchExpr, import_kysely9.sql.lit(""));
+  const escapedSearch = import_kysely9.sql`REPLACE(REPLACE(REPLACE(${dialect.castText(searchExpr)}, ${import_kysely9.sql.val("\\")}, ${import_kysely9.sql.val("\\\\")}), ${import_kysely9.sql.val("%")}, ${import_kysely9.sql.val("\\%")}), ${import_kysely9.sql.val("_")}, ${import_kysely9.sql.val("\\_")})`;
+  searchExpr = (0, import_ts_pattern16.match)(method).with("contains", () => eb.fn("CONCAT", [
+    import_kysely9.sql.lit("%"),
     escapedSearch,
-    import_kysely8.sql.lit("%")
+    import_kysely9.sql.lit("%")
   ])).with("startsWith", () => eb.fn("CONCAT", [
     escapedSearch,
-    import_kysely8.sql.lit("%")
+    import_kysely9.sql.lit("%")
   ])).with("endsWith", () => eb.fn("CONCAT", [
-    import_kysely8.sql.lit("%"),
+    import_kysely9.sql.lit("%"),
     escapedSearch
   ])).exhaustive();
-  return import_kysely8.sql`${fieldExpr} ${import_kysely8.sql.raw(op)} ${searchExpr} escape '\\'`;
+  return import_kysely9.sql`${fieldExpr} ${import_kysely9.sql.raw(op)} ${searchExpr} escape ${import_kysely9.sql.val("\\")}`;
 }, "textMatch");
 var has = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2] = args;
@@ -6980,16 +8083,16 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   if (!field) {
     throw new Error('"field" parameter is required');
   }
-  return eb(dialect.buildArrayLength(field), "=", import_kysely8.sql.lit(0));
+  return eb(dialect.buildArrayLength(field), "=", import_kysely9.sql.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name(() => import_kysely8.sql.raw("CURRENT_TIMESTAMP"), "now");
+var now = /* @__PURE__ */ __name(() => import_kysely9.sql.raw("CURRENT_TIMESTAMP"), "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
   const [casing] = args;
   if (casing) {
     result = processCasing(casing, result, model);
   }
-  return import_kysely8.sql.lit(result);
+  return import_kysely9.sql.lit(result);
 }, "currentModel");
 var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   let result = operation;
@@ -6997,12 +8100,12 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   if (casing) {
     result = processCasing(casing, result, operation);
   }
-  return import_kysely8.sql.lit(result);
+  return import_kysely9.sql.lit(result);
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers10.invariant)(import_kysely8.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern15.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(() => {
+  (0, import_common_helpers12.invariant)(import_kysely9.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_helpers12.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers12.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -7013,16 +8116,16 @@ function readBoolean(expr, defaultValue) {
     return defaultValue;
   }
   const opNode = expr.toOperationNode();
-  (0, import_common_helpers10.invariant)(import_kysely8.ValueNode.is(opNode), "expression must be a literal value");
+  (0, import_common_helpers12.invariant)(import_kysely9.ValueNode.is(opNode), "expression must be a literal value");
   return !!opNode.value;
 }
 __name(readBoolean, "readBoolean");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
-var import_kysely9 = require("kysely");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_kysely10 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
-var import_ts_pattern16 = require("ts-pattern");
+var import_ts_pattern17 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
     __name(this, "SchemaDbPusher");
@@ -7035,7 +8138,7 @@ var SchemaDbPusher = class {
   }
   async push() {
     await this.kysely.transaction().execute(async (tx) => {
-      if (this.schema.enums && this.schema.provider.type === "postgresql") {
+      if (this.schema.enums && this.providerSupportsNativeEnum) {
         for (const [name, enumDef] of Object.entries(this.schema.enums)) {
           let enumValues;
           if (enumDef.fields) {
@@ -7045,7 +8148,7 @@ var SchemaDbPusher = class {
                 return f.name;
               } else {
                 const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
-                (0, import_common_helpers11.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+                (0, import_common_helpers13.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
                 return mappedName;
               }
             });
@@ -7064,6 +8167,11 @@ var SchemaDbPusher = class {
       }
     });
   }
+  get providerSupportsNativeEnum() {
+    return [
+      "postgresql"
+    ].includes(this.schema.provider.type);
+  }
   sortModels(models) {
     const graph = [];
     for (const model of models) {
@@ -7109,7 +8217,7 @@ var SchemaDbPusher = class {
     }
     if (modelDef.baseModel) {
       const baseModelDef = requireModel(this.schema, modelDef.baseModel);
-      table = table.addForeignKeyConstraint(`fk_${modelDef.baseModel}_delegate`, baseModelDef.idFields, modelDef.baseModel, baseModelDef.idFields, (cb) => cb.onDelete("cascade").onUpdate("cascade"));
+      table = table.addForeignKeyConstraint(`fk_${modelDef.baseModel}_${modelDef.name}_delegate`, baseModelDef.idFields, modelDef.baseModel, baseModelDef.idFields, (cb) => cb.onDelete("cascade").onUpdate("cascade"));
     }
     table = this.addPrimaryKeyConstraint(table, modelDef);
     table = this.addUniqueConstraint(table, modelDef);
@@ -7151,7 +8259,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers11.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers13.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -7180,13 +8288,18 @@ var SchemaDbPusher = class {
       if (fieldDef.id && modelDef.idFields.length === 1) {
         col = col.primaryKey();
       }
-      if (fieldDef.default !== void 0) {
+      if (fieldDef.default !== void 0 && this.isDefaultValueSupportedForType(fieldDef.type)) {
         if (typeof fieldDef.default === "object" && "kind" in fieldDef.default) {
           if (schema_exports.ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "now") {
-            col = col.defaultTo(import_kysely9.sql`CURRENT_TIMESTAMP`);
+            col = this.schema.provider.type === "mysql" ? col.defaultTo(import_kysely10.sql`CURRENT_TIMESTAMP(3)`) : col.defaultTo(import_kysely10.sql`CURRENT_TIMESTAMP`);
           }
         } else {
-          col = col.defaultTo(fieldDef.default);
+          if (this.schema.provider.type === "mysql" && fieldDef.type === "DateTime" && typeof fieldDef.default === "string") {
+            const defaultValue = new Date(fieldDef.default).toISOString().replace("Z", "+00:00");
+            col = col.defaultTo(defaultValue);
+          } else {
+            col = col.defaultTo(fieldDef.default);
+          }
         }
       }
       if (fieldDef.unique) {
@@ -7195,28 +8308,56 @@ var SchemaDbPusher = class {
       if (!fieldDef.optional && !fieldDef.array) {
         col = col.notNull();
       }
-      if (this.isAutoIncrement(fieldDef) && this.schema.provider.type === "sqlite") {
+      if (this.isAutoIncrement(fieldDef) && this.columnSupportsAutoIncrement()) {
         col = col.autoIncrement();
       }
       return col;
     });
   }
+  isDefaultValueSupportedForType(type) {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => true).with("sqlite", () => true).with("mysql", () => ![
+      "Json",
+      "Bytes"
+    ].includes(type)).exhaustive();
+  }
   mapFieldType(fieldDef) {
     if (this.schema.enums?.[fieldDef.type]) {
-      return this.schema.provider.type === "postgresql" ? import_kysely9.sql.ref(fieldDef.type) : "text";
+      if (this.schema.provider.type === "postgresql") {
+        return import_kysely10.sql.ref(fieldDef.type);
+      } else if (this.schema.provider.type === "mysql") {
+        const enumDef = this.schema.enums[fieldDef.type];
+        let enumValues;
+        if (enumDef.fields) {
+          enumValues = Object.values(enumDef.fields).map((f) => {
+            const mapAttr = f.attributes?.find((a) => a.name === "@map");
+            if (!mapAttr || !mapAttr.args?.[0]) {
+              return f.name;
+            } else {
+              const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
+              (0, import_common_helpers13.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+              return mappedName;
+            }
+          });
+        } else {
+          enumValues = Object.values(enumDef.values);
+        }
+        return import_kysely10.sql.raw(`enum(${enumValues.map((v) => `'${v}'`).join(", ")})`);
+      } else {
+        return "text";
+      }
     }
     if (this.isAutoIncrement(fieldDef) && this.schema.provider.type === "postgresql") {
       return "serial";
     }
     if (this.isCustomType(fieldDef.type)) {
-      return "jsonb";
+      return this.jsonType;
     }
     const type = fieldDef.type;
-    const result = (0, import_ts_pattern16.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(() => {
+    const result = (0, import_ts_pattern17.match)(type).with("String", () => this.stringType).with("Boolean", () => this.booleanType).with("Int", () => this.intType).with("Float", () => this.floatType).with("BigInt", () => this.bigIntType).with("Decimal", () => this.decimalType).with("DateTime", () => this.dateTimeType).with("Bytes", () => this.bytesType).with("Json", () => this.jsonType).otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
-      return import_kysely9.sql.raw(`${result}[]`);
+      return import_kysely10.sql.raw(`${result}[]`);
     } else {
       return result;
     }
@@ -7228,7 +8369,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && schema_exports.ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers11.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers13.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -7252,7 +8393,41 @@ var SchemaDbPusher = class {
     return table;
   }
   mapCascadeAction(action) {
-    return (0, import_ts_pattern16.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+    return (0, import_ts_pattern17.match)(action).with("SetNull", () => "set null").with("Cascade", () => "cascade").with("Restrict", () => "restrict").with("NoAction", () => "no action").with("SetDefault", () => "set default").exhaustive();
+  }
+  // #region Type mappings and capabilities
+  get jsonType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => "json").otherwise(() => "jsonb");
+  }
+  get bytesType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => "bytea").with("mysql", () => "blob").otherwise(() => "blob");
+  }
+  get stringType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely10.sql.raw("varchar(255)")).otherwise(() => "text");
+  }
+  get booleanType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely10.sql.raw("tinyint(1)")).otherwise(() => "boolean");
+  }
+  get intType() {
+    return "integer";
+  }
+  get floatType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely10.sql.raw("double")).otherwise(() => "real");
+  }
+  get bigIntType() {
+    return "bigint";
+  }
+  get decimalType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely10.sql.raw("decimal(65, 30)")).otherwise(() => "decimal");
+  }
+  get dateTimeType() {
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely10.sql.raw("datetime(3)")).otherwise(() => "timestamp");
+  }
+  columnSupportsAutoIncrement() {
+    return [
+      "sqlite",
+      "mysql"
+    ].includes(this.schema.provider.type);
   }
 };
 
@@ -7434,15 +8609,15 @@ var ClientImpl = class _ClientImpl {
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
-        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely10.DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely11.DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
       this.auth = baseClient.auth;
     } else {
-      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely10.Log(this.$options.log ?? []));
+      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely11.Log(this.$options.log ?? []));
       const compiler = options.dialect.createQueryCompiler();
       const adapter = options.dialect.createAdapter();
-      const connectionProvider = new import_kysely10.DefaultConnectionProvider(driver);
+      const connectionProvider = new import_kysely11.DefaultConnectionProvider(driver);
       this.kyselyProps = {
         config: {
           dialect: options.dialect,
@@ -7452,12 +8627,12 @@ var ClientImpl = class _ClientImpl {
         driver,
         executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
-      this.kyselyRaw = new import_kysely10.Kysely({
+      this.kyselyRaw = new import_kysely11.Kysely({
         ...this.kyselyProps,
-        executor: new import_kysely10.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
+        executor: new import_kysely11.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
       });
     }
-    this.kysely = new import_kysely10.Kysely(this.kyselyProps);
+    this.kysely = new import_kysely11.Kysely(this.kyselyProps);
     this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this);
     return createClientProxy(this);
   }
@@ -7478,7 +8653,7 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    (0, import_common_helpers12.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");
+    (0, import_common_helpers14.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 {
@@ -7487,7 +8662,7 @@ var ClientImpl = class _ClientImpl {
   }
   forceTransaction() {
     if (!this.kysely.isTransaction) {
-      this.kysely = new import_kysely10.Transaction(this.kyselyProps);
+      this.kysely = new import_kysely11.Transaction(this.kyselyProps);
     }
   }
   async interactiveTransaction(callback, options) {
@@ -7575,7 +8750,7 @@ var ClientImpl = class _ClientImpl {
   }
   async $connect() {
     await this.kysely.connection().execute(async (conn) => {
-      await conn.executeQuery(import_kysely10.sql`select 1`.compile(this.kysely));
+      await conn.executeQuery(import_kysely11.sql`select 1`.compile(this.kysely));
     });
   }
   async $disconnect() {
@@ -7646,7 +8821,7 @@ var ClientImpl = class _ClientImpl {
   }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely10.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely11.sql)(query, ...values).execute(this.kysely);
       return Number(result.numAffectedRows ?? 0);
     });
   }
@@ -7659,7 +8834,7 @@ var ClientImpl = class _ClientImpl {
   }
   $queryRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely10.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely11.sql)(query, ...values).execute(this.kysely);
       return result.rows;
     });
   }
@@ -7671,7 +8846,7 @@ var ClientImpl = class _ClientImpl {
     });
   }
   createRawCompiledQuery(query, values) {
-    const q = import_kysely10.CompiledQuery.raw(query, values);
+    const q = import_kysely11.CompiledQuery.raw(query, values);
     return {
       ...q,
       $raw: true
@@ -7768,6 +8943,9 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return createPromise("createMany", "createMany", args, new CreateOperationHandler(client, model, inputValidator), false);
     }, "createMany"),
     createManyAndReturn: /* @__PURE__ */ __name((args) => {
+      if (client.$schema.provider.type === "mysql") {
+        throw createNotSupportedError('"createManyAndReturn" is not supported by "mysql" provider. Use "createMany" or multiple "create" calls instead.');
+      }
       return createPromise("createManyAndReturn", "createManyAndReturn", args, new CreateOperationHandler(client, model, inputValidator), true);
     }, "createManyAndReturn"),
     update: /* @__PURE__ */ __name((args) => {
@@ -7777,6 +8955,9 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return createPromise("updateMany", "updateMany", args, new UpdateOperationHandler(client, model, inputValidator), false);
     }, "updateMany"),
     updateManyAndReturn: /* @__PURE__ */ __name((args) => {
+      if (client.$schema.provider.type === "mysql") {
+        throw createNotSupportedError('"updateManyAndReturn" is not supported by "mysql" provider. Use "updateMany" or multiple "update" calls instead.');
+      }
       return createPromise("updateManyAndReturn", "updateManyAndReturn", args, new UpdateOperationHandler(client, model, inputValidator), true);
     }, "updateManyAndReturn"),
     upsert: /* @__PURE__ */ __name((args) => {
@@ -7815,8 +8996,8 @@ var kysely_utils_exports = {};
 __export(kysely_utils_exports, {
   DefaultOperationNodeVisitor: () => DefaultOperationNodeVisitor
 });
-var import_kysely11 = require("kysely");
-var DefaultOperationNodeVisitor = class extends import_kysely11.OperationNodeVisitor {
+var import_kysely12 = require("kysely");
+var DefaultOperationNodeVisitor = class extends import_kysely12.OperationNodeVisitor {
   static {
     __name(this, "DefaultOperationNodeVisitor");
   }
@@ -8132,13 +9313,13 @@ __export(schema_utils_exports, {
   ExpressionVisitor: () => ExpressionVisitor,
   MatchingExpressionVisitor: () => MatchingExpressionVisitor
 });
-var import_ts_pattern17 = require("ts-pattern");
+var import_ts_pattern18 = require("ts-pattern");
 var ExpressionVisitor = class {
   static {
     __name(this, "ExpressionVisitor");
   }
   visit(expr) {
-    return (0, import_ts_pattern17.match)(expr).with({
+    return (0, import_ts_pattern18.match)(expr).with({
       kind: "literal"
     }, (e) => this.visitLiteral(e)).with({
       kind: "array"
@@ -8153,6 +9334,8 @@ var ExpressionVisitor = class {
     }, (e) => this.visitUnary(e)).with({
       kind: "call"
     }, (e) => this.visitCall(e)).with({
+      kind: "binding"
+    }, (e) => this.visitBinding(e)).with({
       kind: "this"
     }, (e) => this.visitThis(e)).with({
       kind: "null"
@@ -8192,6 +9375,8 @@ var ExpressionVisitor = class {
       }
     }
   }
+  visitBinding(_e) {
+  }
   visitThis(_e) {
   }
   visitNull(_e) {