@zenstackhq/orm 3.4.0-beta.3 → 3.4.0

package/dist/index.cjs

@@ -58,6 +58,7 @@ __export(src_exports, {
   SchemaUtils: () => schema_utils_exports,
   TransactionIsolationLevel: () => TransactionIsolationLevel,
   ZenStackClient: () => ZenStackClient,
+  createQuerySchemaFactory: () => createQuerySchemaFactory,
   definePlugin: () => definePlugin,
   getCrudDialect: () => getCrudDialect
 });
@@ -65,7 +66,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
 var import_common_helpers14 = require("@zenstackhq/common-helpers");
-var import_kysely11 = require("kysely");
+var import_kysely12 = require("kysely");
 
 // src/client/crud/operations/aggregate.ts
 var import_ts_pattern8 = require("ts-pattern");
@@ -73,6 +74,7 @@ var import_ts_pattern8 = require("ts-pattern");
 // src/client/query-utils.ts
 var query_utils_exports = {};
 __export(query_utils_exports, {
+  TEMP_ALIAS_PREFIX: () => TEMP_ALIAS_PREFIX,
   aggregate: () => aggregate,
   buildJoinPairs: () => buildJoinPairs,
   ensureArray: () => ensureArray,
@@ -105,7 +107,8 @@ __export(query_utils_exports, {
   requireIdFields: () => requireIdFields,
   requireModel: () => requireModel,
   requireTypeDef: () => requireTypeDef,
-  stripAlias: () => stripAlias
+  stripAlias: () => stripAlias,
+  tmpAlias: () => tmpAlias
 });
 var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_kysely = require("kysely");
@@ -620,6 +623,15 @@ function extractFieldName(node) {
   }
 }
 __name(extractFieldName, "extractFieldName");
+var TEMP_ALIAS_PREFIX = "$$_";
+function tmpAlias(name) {
+  if (!name.startsWith(TEMP_ALIAS_PREFIX)) {
+    return `${TEMP_ALIAS_PREFIX}${name}`;
+  } else {
+    return name;
+  }
+}
+__name(tmpAlias, "tmpAlias");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
@@ -896,7 +908,7 @@ var BaseCrudDialect = class {
         });
       }
     }
-    const joinAlias = `${modelAlias}$${field}`;
+    const joinAlias = tmpAlias(`${modelAlias}$${field}`);
     const joinPairs = buildJoinPairs(
       this.schema,
       model,
@@ -905,7 +917,7 @@ var BaseCrudDialect = class {
       field,
       joinAlias
     );
-    const filterResultField = `${field}$filter`;
+    const filterResultField = tmpAlias(`${field}$flt`);
     const joinSelect = this.eb.selectFrom(`${fieldDef.type} as ${joinAlias}`).where(() => this.and(...joinPairs.map(([left, right]) => this.eb(this.eb.ref(left), "=", this.eb.ref(right))))).select(() => this.eb.fn.count(this.eb.lit(1)).as(filterResultField));
     const conditions = [];
     if ("is" in payload || "isNot" in payload) {
@@ -938,7 +950,7 @@ var BaseCrudDialect = class {
       return this.eb(this.eb.ref(`${modelAlias}.${field}`), "is", null);
     }
     const relationModel = fieldDef.type;
-    const relationFilterSelectAlias = `${modelAlias}$${field}$filter`;
+    const relationFilterSelectAlias = tmpAlias(`${modelAlias}$${field}$flt`);
     const buildPkFkWhereRefs = /* @__PURE__ */ __name((eb) => {
       const m2m = getManyToManyRelation(this.schema, model, field);
       if (m2m) {
@@ -1402,7 +1414,7 @@ var BaseCrudDialect = class {
               (0, import_common_helpers2.invariant)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
               const sort = this.negateSort(value._count, negated);
               result = result.orderBy((eb) => {
-                const subQueryAlias = `${modelAlias}$orderBy$${field}$count`;
+                const subQueryAlias = tmpAlias(`${modelAlias}$ob$${field}$ct`);
                 let subQuery = this.buildSelectModel(relationModel, subQueryAlias);
                 const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
                 subQuery = subQuery.where(() => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
@@ -1411,7 +1423,7 @@ var BaseCrudDialect = class {
               }, sort);
             }
           } else {
-            const joinAlias = `${modelAlias}$orderBy$${index}`;
+            const joinAlias = tmpAlias(`${modelAlias}$ob$${index}`);
             result = result.leftJoin(`${relationModel} as ${joinAlias}`, (join) => {
               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)))));
@@ -1604,7 +1616,7 @@ var LateralJoinDialectBase = class extends BaseCrudDialect {
     __name(this, "LateralJoinDialectBase");
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
-    const relationResultName = `${parentAlias}$${relationField}`;
+    const relationResultName = tmpAlias(`${parentAlias}$${relationField}`);
     const joinedQuery = this.buildRelationJSON(model, query, relationField, parentAlias, payload, relationResultName);
     return joinedQuery.select(`${relationResultName}.$data as ${relationField}`);
   }
@@ -1612,7 +1624,7 @@ var LateralJoinDialectBase = class extends BaseCrudDialect {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     return qb.leftJoinLateral((eb) => {
-      const relationSelectName = `${resultName}$sub`;
+      const relationSelectName = tmpAlias(`${resultName}$sub`);
       const relationModelDef = requireModel(this.schema, relationModel);
       let tbl;
       if (this.canJoinWithoutNestedSelect(relationModelDef, payload)) {
@@ -1899,7 +1911,7 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
     ]), "=", 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"))));
+    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("_")).where(buildFilter(this.eb.ref("$items.value"))));
   }
   getStringCasingBehavior() {
     return {
@@ -2156,7 +2168,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
   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"))));
+    ]).as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
   }
   getSqlType(zmodelType) {
     if (isEnum(this.schema, zmodelType)) {
@@ -2315,14 +2327,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     const relationModelDef = requireModel(this.schema, relationModel);
-    const subQueryName = `${parentAlias}$${relationField}`;
+    const subQueryName = tmpAlias(`${parentAlias}$${relationField}`);
     let tbl;
     if (this.canJoinWithoutNestedSelect(relationModelDef, payload)) {
       tbl = this.buildModelSelect(relationModel, subQueryName, payload, false);
       tbl = this.buildRelationJoinFilter(tbl, model, relationField, subQueryName, parentAlias);
     } else {
       tbl = eb.selectFrom(() => {
-        const selectModelAlias = `${parentAlias}$${relationField}$sub`;
+        const selectModelAlias = tmpAlias(`${parentAlias}$${relationField}$sub`);
         let selectModelQuery = this.buildModelSelect(relationModel, selectModelAlias, payload, true);
         selectModelQuery = this.buildRelationJoinFilter(selectModelQuery, model, relationField, selectModelAlias, parentAlias);
         return selectModelQuery.as(subQueryName);
@@ -2346,7 +2358,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       } else if (payload.select) {
         objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
           if (field === "_count") {
-            const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
+            const subJson = this.buildCountJson(relationModel, eb, tmpAlias(`${parentAlias}$${relationField}`), value);
             return [
               import_kysely5.sql.lit(field),
               subJson
@@ -2354,7 +2366,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
           } else {
             const fieldDef = requireField(this.schema, relationModel, field);
             if (fieldDef.relation) {
-              const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
+              const subJson = this.buildRelationJSON(relationModel, eb, field, tmpAlias(`${parentAlias}$${relationField}`), value);
               return [
                 import_kysely5.sql.lit(field),
                 subJson
@@ -2370,7 +2382,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       }
       if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
         objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
-          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
+          const subJson = this.buildRelationJSON(relationModel, eb, field, tmpAlias(`${parentAlias}$${relationField}`), value);
           return [
             import_kysely5.sql.lit(field),
             subJson
@@ -2447,7 +2459,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   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"))));
+    ]).as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
   }
   buildArrayLength(array) {
     return this.eb.fn("json_array_length", [
@@ -2629,7 +2641,7 @@ var BaseOperationHandler = class {
     });
   }
   async existsNonUnique(kysely, model, filter) {
-    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({
+    const query = kysely.selectNoFrom((eb) => eb.exists(this.dialect.buildSelectModel(model, model).select(import_kysely6.sql.lit(1).as("_")).where(() => this.dialect.buildFilter(model, model, filter))).as("$exists")).modifyEnd(this.makeContextComment({
       model,
       operation: "read"
     }));
@@ -2641,7 +2653,7 @@ var BaseOperationHandler = class {
     } catch (err) {
       throw createDBQueryError(`Failed to execute query: ${err}`, err, compiled.sql, compiled.parameters);
     }
-    return !!result[0]?.exists;
+    return !!result[0]?.$exists;
   }
   async read(kysely, model, args) {
     let query = this.dialect.buildSelectModel(model, model);
@@ -3238,7 +3250,7 @@ var BaseOperationHandler = class {
     if (modelDef.baseModel) {
       const baseUpdateResult = await this.processBaseModelUpdate(kysely, modelDef.baseModel, combinedWhere, finalData, throwIfNotFound);
       finalData = baseUpdateResult.remainingFields;
-      combinedWhere = baseUpdateResult.baseEntity;
+      combinedWhere = baseUpdateResult.baseEntity ? getIdValues(this.schema, modelDef.baseModel, baseUpdateResult.baseEntity) : baseUpdateResult.baseEntity;
       if (baseUpdateResult.baseEntity) {
         for (const [key, value] of Object.entries(baseUpdateResult.baseEntity)) {
           if (key in thisEntity) {
@@ -4635,11 +4647,9 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
   }
 };
 
-// src/client/crud/validator/index.ts
+// src/client/crud/validator/validator.ts
 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_zod2 = require("zod");
 
 // src/utils/zod-utils.ts
 var import_v4 = require("zod-validation-error/v4");
@@ -4648,7 +4658,14 @@ function formatError(error) {
 }
 __name(formatError, "formatError");
 
-// src/client/crud/validator/cache-decorator.ts
+// src/client/zod/factory.ts
+var import_common_helpers8 = require("@zenstackhq/common-helpers");
+var import_zod = require("@zenstackhq/zod");
+var import_decimal4 = __toESM(require("decimal.js"), 1);
+var import_ts_pattern13 = require("ts-pattern");
+var import_zod2 = require("zod");
+
+// src/client/zod/cache-decorator.ts
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
 function cache() {
   return function(_target, propertyKey, descriptor) {
@@ -4680,371 +4697,7 @@ function cache() {
 }
 __name(cache, "cache");
 
-// src/client/crud/validator/utils.ts
-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_zod = require("zod");
-var import_v3 = require("zod/v3");
-function getArgValue(expr) {
-  if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
-    return void 0;
-  }
-  return expr.value;
-}
-__name(getArgValue, "getArgValue");
-function addStringValidation(schema, attributes) {
-  if (!attributes || attributes.length === 0) {
-    return schema;
-  }
-  let result = schema;
-  for (const attr of attributes) {
-    (0, import_ts_pattern13.match)(attr.name).with("@length", () => {
-      const min = getArgValue(attr.args?.[0]?.value);
-      if (min !== void 0) {
-        result = result.min(min);
-      }
-      const max = getArgValue(attr.args?.[1]?.value);
-      if (max !== void 0) {
-        result = result.max(max);
-      }
-    }).with("@startsWith", () => {
-      const value = getArgValue(attr.args?.[0]?.value);
-      if (value !== void 0) {
-        result = result.startsWith(value);
-      }
-    }).with("@endsWith", () => {
-      const value = getArgValue(attr.args?.[0]?.value);
-      if (value !== void 0) {
-        result = result.endsWith(value);
-      }
-    }).with("@contains", () => {
-      const value = getArgValue(attr.args?.[0]?.value);
-      if (value !== void 0) {
-        result = result.includes(value);
-      }
-    }).with("@regex", () => {
-      const pattern = getArgValue(attr.args?.[0]?.value);
-      if (pattern !== void 0) {
-        result = result.regex(new RegExp(pattern));
-      }
-    }).with("@email", () => {
-      result = result.email();
-    }).with("@datetime", () => {
-      result = result.datetime();
-    }).with("@url", () => {
-      result = result.url();
-    }).with("@trim", () => {
-      result = result.trim();
-    }).with("@lower", () => {
-      result = result.toLowerCase();
-    }).with("@upper", () => {
-      result = result.toUpperCase();
-    });
-  }
-  return result;
-}
-__name(addStringValidation, "addStringValidation");
-function addNumberValidation(schema, attributes) {
-  if (!attributes || attributes.length === 0) {
-    return schema;
-  }
-  let result = schema;
-  for (const attr of attributes) {
-    const val = getArgValue(attr.args?.[0]?.value);
-    if (val === void 0) {
-      continue;
-    }
-    (0, import_ts_pattern13.match)(attr.name).with("@gt", () => {
-      result = result.gt(val);
-    }).with("@gte", () => {
-      result = result.gte(val);
-    }).with("@lt", () => {
-      result = result.lt(val);
-    }).with("@lte", () => {
-      result = result.lte(val);
-    });
-  }
-  return result;
-}
-__name(addNumberValidation, "addNumberValidation");
-function addBigIntValidation(schema, attributes) {
-  if (!attributes || attributes.length === 0) {
-    return schema;
-  }
-  let result = schema;
-  for (const attr of attributes) {
-    const val = getArgValue(attr.args?.[0]?.value);
-    if (val === void 0) {
-      continue;
-    }
-    (0, import_ts_pattern13.match)(attr.name).with("@gt", () => {
-      result = result.gt(BigInt(val));
-    }).with("@gte", () => {
-      result = result.gte(BigInt(val));
-    }).with("@lt", () => {
-      result = result.lt(BigInt(val));
-    }).with("@lte", () => {
-      result = result.lte(BigInt(val));
-    });
-  }
-  return result;
-}
-__name(addBigIntValidation, "addBigIntValidation");
-function addDecimalValidation(schema, attributes, addExtraValidation) {
-  let result = schema;
-  if (schema instanceof import_zod.z.ZodString) {
-    result = schema.superRefine((v, ctx) => {
-      try {
-        new import_decimal4.default(v);
-      } catch (err) {
-        ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
-          message: `Invalid decimal: ${err}`
-        });
-      }
-    }).transform((val) => new import_decimal4.default(val));
-  }
-  function refine(schema2, op, value) {
-    return schema2.superRefine((v, ctx) => {
-      const base = import_zod.z.number();
-      const { error } = base[op](value).safeParse(v.toNumber());
-      error?.issues.forEach((issue) => {
-        if (op === "gt" || op === "gte") {
-          ctx.addIssue({
-            code: import_v3.ZodIssueCode.too_small,
-            origin: "number",
-            minimum: value,
-            type: "decimal",
-            inclusive: op === "gte",
-            message: issue.message
-          });
-        } else {
-          ctx.addIssue({
-            code: import_v3.ZodIssueCode.too_big,
-            origin: "number",
-            maximum: value,
-            type: "decimal",
-            inclusive: op === "lte",
-            message: issue.message
-          });
-        }
-      });
-    });
-  }
-  __name(refine, "refine");
-  if (attributes && addExtraValidation) {
-    for (const attr of attributes) {
-      const val = getArgValue(attr.args?.[0]?.value);
-      if (val === void 0) {
-        continue;
-      }
-      (0, import_ts_pattern13.match)(attr.name).with("@gt", () => {
-        result = refine(result, "gt", val);
-      }).with("@gte", () => {
-        result = refine(result, "gte", val);
-      }).with("@lt", () => {
-        result = refine(result, "lt", val);
-      }).with("@lte", () => {
-        result = refine(result, "lte", val);
-      });
-    }
-  }
-  return result;
-}
-__name(addDecimalValidation, "addDecimalValidation");
-function addListValidation(schema, attributes) {
-  if (!attributes || attributes.length === 0) {
-    return schema;
-  }
-  let result = schema;
-  for (const attr of attributes) {
-    (0, import_ts_pattern13.match)(attr.name).with("@length", () => {
-      const min = getArgValue(attr.args?.[0]?.value);
-      if (min !== void 0) {
-        result = result.min(min);
-      }
-      const max = getArgValue(attr.args?.[1]?.value);
-      if (max !== void 0) {
-        result = result.max(max);
-      }
-    }).otherwise(() => {
-    });
-  }
-  return result;
-}
-__name(addListValidation, "addListValidation");
-function addCustomValidation(schema, attributes) {
-  const attrs = attributes?.filter((a) => a.name === "@@validate");
-  if (!attrs || attrs.length === 0) {
-    return schema;
-  }
-  let result = schema;
-  for (const attr of attrs) {
-    const expr = attr.args?.[0]?.value;
-    if (!expr) {
-      continue;
-    }
-    const message = getArgValue(attr.args?.[1]?.value);
-    const pathExpr = attr.args?.[2]?.value;
-    let path = void 0;
-    if (pathExpr && schema_exports.ExpressionUtils.isArray(pathExpr)) {
-      path = pathExpr.items.map((e) => schema_exports.ExpressionUtils.getLiteralValue(e));
-    }
-    result = applyValidation(result, expr, message, path);
-  }
-  return result;
-}
-__name(addCustomValidation, "addCustomValidation");
-function applyValidation(schema, expr, message, path) {
-  const options = {};
-  if (message) {
-    options.error = message;
-  }
-  if (path) {
-    options.path = path;
-  }
-  return schema.refine((data) => Boolean(evalExpression(data, expr)), options);
-}
-__name(applyValidation, "applyValidation");
-function evalExpression(data, expr) {
-  return (0, import_ts_pattern13.match)(expr).with({
-    kind: "literal"
-  }, (e) => e.value).with({
-    kind: "array"
-  }, (e) => e.items.map((item) => evalExpression(data, item))).with({
-    kind: "field"
-  }, (e) => evalField(data, e)).with({
-    kind: "member"
-  }, (e) => evalMember(data, e)).with({
-    kind: "unary"
-  }, (e) => evalUnary(data, e)).with({
-    kind: "binary"
-  }, (e) => evalBinary(data, e)).with({
-    kind: "call"
-  }, (e) => evalCall(data, e)).with({
-    kind: "this"
-  }, () => data ?? null).with({
-    kind: "null"
-  }, () => null).with({
-    kind: "binding"
-  }, () => {
-    throw new Error("Binding expression is not supported in validation expressions");
-  }).exhaustive();
-}
-__name(evalExpression, "evalExpression");
-function evalField(data, e) {
-  return data?.[e.field] ?? null;
-}
-__name(evalField, "evalField");
-function evalUnary(data, expr) {
-  const operand = evalExpression(data, expr.operand);
-  switch (expr.op) {
-    case "!":
-      return !operand;
-    default:
-      throw new Error(`Unsupported unary operator: ${expr.op}`);
-  }
-}
-__name(evalUnary, "evalUnary");
-function evalBinary(data, expr) {
-  const left = evalExpression(data, expr.left);
-  const right = evalExpression(data, expr.right);
-  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;
-    }
-    return left.some((item) => item === right);
-  }).with("!", () => {
-    if (!Array.isArray(left)) {
-      return false;
-    }
-    return left.every((item) => item === right);
-  }).with("^", () => {
-    if (!Array.isArray(left)) {
-      return false;
-    }
-    return !left.some((item) => item === right);
-  }).with("in", () => {
-    if (!Array.isArray(right)) {
-      return false;
-    }
-    return right.includes(left);
-  }).exhaustive();
-}
-__name(evalBinary, "evalBinary");
-function evalMember(data, expr) {
-  let result = evalExpression(data, expr.receiver);
-  for (const member of expr.members) {
-    if (!result || typeof result !== "object") {
-      return void 0;
-    }
-    result = result[member];
-  }
-  return result ?? null;
-}
-__name(evalMember, "evalMember");
-function evalCall(data, expr) {
-  const fieldArg = expr.args?.[0] ? evalExpression(data, expr.args[0]) : void 0;
-  return (0, import_ts_pattern13.match)(expr.function).with("length", (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    (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_pattern13.P.union("startsWith", "endsWith", "contains"), (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    (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_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_helpers8.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
-    const pattern = getArgValue(expr.args?.[1]);
-    (0, import_common_helpers8.invariant)(pattern !== void 0, `"${f}" requires a pattern argument`);
-    return new RegExp(pattern).test(fieldArg);
-  }).with(import_ts_pattern13.P.union("isEmail", "isUrl", "isDateTime"), (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    (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_zod.z.string()[fn]().safeParse(fieldArg).success;
-  }).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_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_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_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);
-  }).with("isEmpty", (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    (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}"`);
-  });
-}
-__name(evalCall, "evalCall");
-
-// src/client/crud/validator/index.ts
+// src/client/zod/factory.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);
@@ -5056,303 +4709,185 @@ 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 {
+function createQuerySchemaFactory(clientOrSchema, options) {
+  return new ZodSchemaFactory(clientOrSchema, options);
+}
+__name(createQuerySchemaFactory, "createQuerySchemaFactory");
+var ZodSchemaFactory = class {
   static {
-    __name(this, "InputValidator");
+    __name(this, "ZodSchemaFactory");
   }
-  client;
   schemaCache = /* @__PURE__ */ new Map();
   allFilterKinds = [
     ...new Set(Object.values(FILTER_PROPERTY_TO_KIND))
   ];
-  constructor(client) {
-    this.client = client;
-  }
-  get schema() {
-    return this.client.$schema;
+  schema;
+  options;
+  constructor(clientOrSchema, options) {
+    if ("$schema" in clientOrSchema) {
+      this.schema = clientOrSchema.$schema;
+      this.options = clientOrSchema.$options;
+    } else {
+      this.schema = clientOrSchema;
+      this.options = options || {};
+    }
   }
-  get options() {
-    return this.client.$options;
+  get plugins() {
+    return this.options.plugins ?? [];
   }
   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);
+    return this.options.validateInput !== false;
   }
-  validateCreateArgs(model, args) {
-    return this.validate(model, "create", (model2) => this.makeCreateSchema(model2), args);
+  shouldIncludeRelations(options) {
+    return options?.relationDepth === void 0 || options.relationDepth > 0;
   }
-  validateCreateManyArgs(model, args) {
-    return this.validate(model, "createMany", (model2) => this.makeCreateManySchema(model2), args);
+  nextOptions(options) {
+    if (!options) return void 0;
+    if (options.relationDepth === void 0) return options;
+    return {
+      ...options,
+      relationDepth: options.relationDepth - 1
+    };
   }
-  validateCreateManyAndReturnArgs(model, args) {
-    return this.validate(model, "createManyAndReturn", (model2) => this.makeCreateManyAndReturnSchema(model2), args);
+  // #region Cache Management
+  // @ts-ignore
+  getCache(cacheKey) {
+    return this.schemaCache.get(cacheKey);
   }
-  validateUpdateArgs(model, args) {
-    return this.validate(model, "update", (model2) => this.makeUpdateSchema(model2), args);
+  // @ts-ignore
+  setCache(cacheKey, schema) {
+    return this.schemaCache.set(cacheKey, schema);
   }
-  validateUpdateManyArgs(model, args) {
-    return this.validate(model, "updateMany", (model2) => this.makeUpdateManySchema(model2), args);
+  // @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}`);
+      }
+    }
   }
-  validateUpdateManyAndReturnArgs(model, args) {
-    return this.validate(model, "updateManyAndReturn", (model2) => this.makeUpdateManyAndReturnSchema(model2), args);
+  // #endregion
+  // #region Find
+  makeFindUniqueSchema(model, options) {
+    return this.makeFindSchema(model, "findUnique", options);
   }
-  validateUpsertArgs(model, args) {
-    return this.validate(model, "upsert", (model2) => this.makeUpsertSchema(model2), args);
+  makeFindFirstSchema(model, options) {
+    return this.makeFindSchema(model, "findFirst", options);
   }
-  validateDeleteArgs(model, args) {
-    return this.validate(model, "delete", (model2) => this.makeDeleteSchema(model2), args);
+  makeFindManySchema(model, options) {
+    return this.makeFindSchema(model, "findMany", options);
   }
-  validateDeleteManyArgs(model, args) {
-    return this.validate(model, "deleteMany", (model2) => this.makeDeleteManySchema(model2), args);
+  makeFindSchema(model, operation, options) {
+    const fields = {};
+    const unique = operation === "findUnique";
+    const findOne = operation === "findUnique" || operation === "findFirst";
+    const where = this.makeWhereSchema(model, unique, false, false, options);
+    if (unique) {
+      fields["where"] = where;
+    } else {
+      fields["where"] = where.optional();
+    }
+    fields["select"] = this.makeSelectSchema(model, options).optional().nullable();
+    fields["include"] = this.makeIncludeSchema(model, options).optional().nullable();
+    fields["omit"] = this.makeOmitSchema(model).optional().nullable();
+    if (!unique) {
+      fields["skip"] = this.makeSkipSchema().optional();
+      if (findOne) {
+        fields["take"] = import_zod2.z.literal(1).optional();
+      } else {
+        fields["take"] = this.makeTakeSchema().optional();
+      }
+      fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false, options), true).optional();
+      fields["cursor"] = this.makeCursorSchema(model, options).optional();
+      fields["distinct"] = this.makeDistinctSchema(model).optional();
+    }
+    const baseSchema = import_zod2.z.strictObject(fields);
+    let result = this.mergePluginArgsSchema(baseSchema, operation);
+    result = this.refineForSelectIncludeMutuallyExclusive(result);
+    result = this.refineForSelectOmitMutuallyExclusive(result);
+    result = this.refineForSelectHasTruthyField(result);
+    if (!unique) {
+      result = result.optional();
+    }
+    return result;
   }
-  validateCountArgs(model, args) {
-    return this.validate(model, "count", (model2) => this.makeCountSchema(model2), args);
+  makeExistsSchema(model, options) {
+    const baseSchema = import_zod2.z.strictObject({
+      where: this.makeWhereSchema(model, false, false, false, options).optional()
+    });
+    return this.mergePluginArgsSchema(baseSchema, "exists").optional();
   }
-  validateAggregateArgs(model, args) {
-    return this.validate(model, "aggregate", (model2) => this.makeAggregateSchema(model2), args);
+  makeScalarSchema(type, attributes) {
+    if (this.schema.typeDefs && type in this.schema.typeDefs) {
+      return this.makeTypeDefSchema(type);
+    } 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 ? import_zod.ZodUtils.addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
+        this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
+        this.extraValidationsEnabled ? import_zod.ZodUtils.addBigIntValidation(import_zod2.z.bigint(), attributes) : import_zod2.z.bigint()
+      ])).with("Decimal", () => {
+        return import_zod2.z.union([
+          this.extraValidationsEnabled ? import_zod.ZodUtils.addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number(),
+          import_zod.ZodUtils.addDecimalValidation(import_zod2.z.instanceof(import_decimal4.default), attributes, this.extraValidationsEnabled),
+          import_zod.ZodUtils.addDecimalValidation(import_zod2.z.string(), attributes, this.extraValidationsEnabled)
+        ]);
+      }).with("DateTime", () => import_zod2.z.union([
+        import_zod2.z.date(),
+        import_zod2.z.iso.datetime()
+      ])).with("Bytes", () => import_zod2.z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => import_zod2.z.unknown());
+    }
   }
-  validateGroupByArgs(model, args) {
-    return this.validate(model, "groupBy", (model2) => this.makeGroupBySchema(model2), args);
+  makeEnumSchema(_enum) {
+    const enumDef = getEnum(this.schema, _enum);
+    (0, import_common_helpers8.invariant)(enumDef, `Enum "${_enum}" not found in schema`);
+    return import_zod2.z.enum(Object.keys(enumDef.values));
   }
-  // TODO: turn it into a Zod schema and cache
-  validateProcedureInput(proc, input) {
-    const procDef = (this.schema.procedures ?? {})[proc];
-    (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) {
-        return void 0;
-      }
-      if (params.every((p) => p.optional)) {
-        return void 0;
-      }
-      throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
-    }
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      throw createInvalidInputError("Procedure input must be an object", `$procs.${proc}`);
-    }
-    const envelope = input;
-    const argsPayload = Object.prototype.hasOwnProperty.call(envelope, "args") ? envelope.args : void 0;
-    if (params.length === 0) {
-      if (typeof argsPayload === "undefined") {
-        return input;
-      }
-      if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
-        throw createInvalidInputError("Procedure `args` must be an object", `$procs.${proc}`);
+  makeTypeDefSchema(type) {
+    const typeDef = getTypeDef(this.schema, type);
+    (0, import_common_helpers8.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    const schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+      let fieldSchema = this.makeScalarSchema(def.type);
+      if (def.array) {
+        fieldSchema = fieldSchema.array();
       }
-      if (Object.keys(argsPayload).length === 0) {
-        return input;
+      if (def.optional) {
+        fieldSchema = fieldSchema.nullish();
       }
-      throw createInvalidInputError("Procedure does not accept arguments", `$procs.${proc}`);
-    }
-    if (typeof argsPayload === "undefined") {
-      if (params.every((p) => p.optional)) {
-        return input;
-      }
-      throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
-    }
-    if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
-      throw createInvalidInputError("Procedure `args` must be an object", `$procs.${proc}`);
-    }
-    const obj = argsPayload;
-    for (const param of params) {
-      const value = obj[param.name];
-      if (!Object.prototype.hasOwnProperty.call(obj, param.name)) {
-        if (param.optional) {
-          continue;
-        }
-        throw createInvalidInputError(`Missing procedure argument: ${param.name}`, `$procs.${proc}`);
-      }
-      if (typeof value === "undefined") {
-        if (param.optional) {
-          continue;
-        }
-        throw createInvalidInputError(`Invalid procedure argument: ${param.name} is required`, `$procs.${proc}`);
-      }
-      const schema = this.makeProcedureParamSchema(param);
-      const parsed = schema.safeParse(value);
-      if (!parsed.success) {
-        throw createInvalidInputError(`Invalid procedure argument: ${param.name}: ${formatError(parsed.error)}`, `$procs.${proc}`);
-      }
-    }
-    return input;
-  }
-  // #endregion
-  // #region Validation helpers
-  validate(model, operation, getSchema, args) {
-    const schema = getSchema(model);
-    const { error, data } = schema.safeParse(args);
-    if (error) {
-      throw createInvalidInputError(`Invalid ${operation} args for model "${model}": ${formatError(error)}`, model, {
-        cause: error
-      });
-    }
-    return data;
-  }
-  mergePluginArgsSchema(schema, operation) {
-    let result = schema;
-    for (const plugin of this.options.plugins ?? []) {
-      if (plugin.queryArgs) {
-        const pluginSchema = this.getPluginExtQueryArgsSchema(plugin, operation);
-        if (pluginSchema) {
-          result = result.extend(pluginSchema.shape);
-        }
-      }
-    }
-    return result.strict();
-  }
-  getPluginExtQueryArgsSchema(plugin, operation) {
-    if (!plugin.queryArgs) {
-      return void 0;
-    }
-    let result;
-    if (operation in plugin.queryArgs && plugin.queryArgs[operation]) {
-      result = plugin.queryArgs[operation];
-    } else if (operation === "upsert") {
-      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_helpers9.invariant)(createSchema instanceof import_zod2.z.ZodObject, "Plugin extended query args schema must be a Zod object");
-        (0, import_common_helpers9.invariant)(updateSchema instanceof import_zod2.z.ZodObject, "Plugin extended query args schema must be a Zod object");
-        result = createSchema.extend(updateSchema.shape);
-      } else if (createSchema) {
-        result = createSchema;
-      } else if (updateSchema) {
-        result = updateSchema;
-      }
-    } else if (
-      // then comes grouped operations: $create, $read, $update, $delete
-      CoreCreateOperations.includes(operation) && "$create" in plugin.queryArgs && plugin.queryArgs["$create"]
-    ) {
-      result = plugin.queryArgs["$create"];
-    } else if (CoreReadOperations.includes(operation) && "$read" in plugin.queryArgs && plugin.queryArgs["$read"]) {
-      result = plugin.queryArgs["$read"];
-    } else if (CoreUpdateOperations.includes(operation) && "$update" in plugin.queryArgs && plugin.queryArgs["$update"]) {
-      result = plugin.queryArgs["$update"];
-    } else if (CoreDeleteOperations.includes(operation) && "$delete" in plugin.queryArgs && plugin.queryArgs["$delete"]) {
-      result = plugin.queryArgs["$delete"];
-    } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
-      result = plugin.queryArgs["$all"];
-    }
-    (0, import_common_helpers9.invariant)(result === void 0 || result instanceof import_zod2.z.ZodObject, "Plugin extended query args schema must be a Zod object");
-    return result;
-  }
-  // #endregion
-  // #region Find
-  makeFindSchema(model, operation) {
-    const fields = {};
-    const unique = operation === "findUnique";
-    const findOne = operation === "findUnique" || operation === "findFirst";
-    const where = this.makeWhereSchema(model, unique);
-    if (unique) {
-      fields["where"] = where;
-    } else {
-      fields["where"] = where.optional();
-    }
-    fields["select"] = this.makeSelectSchema(model).optional().nullable();
-    fields["include"] = this.makeIncludeSchema(model).optional().nullable();
-    fields["omit"] = this.makeOmitSchema(model).optional().nullable();
-    if (!unique) {
-      fields["skip"] = this.makeSkipSchema().optional();
-      if (findOne) {
-        fields["take"] = import_zod2.z.literal(1).optional();
-      } else {
-        fields["take"] = this.makeTakeSchema().optional();
-      }
-      fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false), true).optional();
-      fields["cursor"] = this.makeCursorSchema(model).optional();
-      fields["distinct"] = this.makeDistinctSchema(model).optional();
-    }
-    const baseSchema = import_zod2.z.strictObject(fields);
-    let result = this.mergePluginArgsSchema(baseSchema, operation);
-    result = this.refineForSelectIncludeMutuallyExclusive(result);
-    result = this.refineForSelectOmitMutuallyExclusive(result);
-    if (!unique) {
-      result = result.optional();
-    }
-    return result;
-  }
-  makeExistsSchema(model) {
-    const baseSchema = import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, false).optional()
-    });
-    return this.mergePluginArgsSchema(baseSchema, "exists").optional();
-  }
-  makeScalarSchema(type, attributes) {
-    if (this.schema.typeDefs && type in this.schema.typeDefs) {
-      return this.makeTypeDefSchema(type);
-    } else if (this.schema.enums && type in this.schema.enums) {
-      return this.makeEnumSchema(type);
-    } else {
-      return (0, import_ts_pattern14.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
-        this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
-        this.extraValidationsEnabled ? addBigIntValidation(import_zod2.z.bigint(), attributes) : import_zod2.z.bigint()
-      ])).with("Decimal", () => {
-        return import_zod2.z.union([
-          this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number(),
-          addDecimalValidation(import_zod2.z.instanceof(import_decimal5.default), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(import_zod2.z.string(), attributes, this.extraValidationsEnabled)
-        ]);
-      }).with("DateTime", () => import_zod2.z.union([
-        import_zod2.z.date(),
-        import_zod2.z.iso.datetime()
-      ])).with("Bytes", () => import_zod2.z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => import_zod2.z.unknown());
-    }
-  }
-  makeEnumSchema(type) {
-    const enumDef = getEnum(this.schema, type);
-    (0, import_common_helpers9.invariant)(enumDef, `Enum "${type}" not found in schema`);
-    return import_zod2.z.enum(Object.keys(enumDef.values));
-  }
-  makeTypeDefSchema(type) {
-    const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
-    const schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
-      let fieldSchema = this.makeScalarSchema(def.type);
-      if (def.array) {
-        fieldSchema = fieldSchema.array();
-      }
-      if (def.optional) {
-        fieldSchema = fieldSchema.nullish();
-      }
-      return [
-        field,
-        fieldSchema
-      ];
-    })));
-    const finalSchema = import_zod2.z.any().superRefine((value, ctx) => {
-      const parseResult = schema.safeParse(value);
-      if (!parseResult.success) {
-        parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
+      return [
+        field,
+        fieldSchema
+      ];
+    })));
+    const finalSchema = import_zod2.z.any().superRefine((value, ctx) => {
+      const parseResult = schema.safeParse(value);
+      if (!parseResult.success) {
+        parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
       }
     });
     return finalSchema;
   }
-  makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
+  makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false, options) {
     const modelDef = requireModel(this.schema, model);
     const uniqueFieldNames = unique ? getUniqueFields(this.schema, model).filter((uf) => (
       // single-field unique
       "def" in uf
     )).map((uf) => uf.name) : void 0;
+    const nextOpts = this.nextOptions(options);
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       let fieldSchema;
       if (fieldDef.relation) {
-        if (withoutRelationFields) {
+        if (withoutRelationFields || !this.shouldIncludeRelations(options)) {
           continue;
         }
         const allowedFilterKinds = this.getEffectiveFilterKinds(model, field);
         if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) {
           fieldSchema = import_zod2.z.never();
         } else {
-          fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+          fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts).optional());
           fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
           if (fieldDef.array) {
             fieldSchema = import_zod2.z.union([
@@ -5397,7 +4932,7 @@ var InputValidator = class {
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
           fields[uniqueField.name] = import_zod2.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
-            (0, import_common_helpers9.invariant)(!def.relation, "unique field cannot be a relation");
+            (0, import_common_helpers8.invariant)(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
@@ -5420,9 +4955,9 @@ var InputValidator = class {
     fields["$expr"] = import_zod2.z.custom((v) => typeof v === "function", {
       error: '"$expr" must be a function'
     }).optional();
-    fields["AND"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    fields["AND"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
+    fields["OR"] = import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)).array().optional();
+    fields["NOT"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
     const baseWhere = import_zod2.z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
@@ -5448,7 +4983,7 @@ var InputValidator = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    (0, import_common_helpers8.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
     if (!array) {
       const fieldSchemas = {};
@@ -5500,7 +5035,7 @@ var InputValidator = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const enumDef = getEnum(this.schema, enumName);
-    (0, import_common_helpers9.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
+    (0, import_common_helpers8.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
     const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
     if (array) {
       return this.internalMakeArrayFilterSchema(model, fieldInfo.name, baseSchema);
@@ -5537,7 +5072,7 @@ var InputValidator = class {
     const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(contextModel, fieldInfo.name);
     const type = fieldInfo.type;
     const optional = !!fieldInfo.optional;
-    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(contextModel, fieldInfo.name, optional)).with("Unsupported", () => import_zod2.z.never()).exhaustive();
+    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(contextModel, fieldInfo.name, optional)).with("Unsupported", () => import_zod2.z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
@@ -5701,29 +5236,35 @@ var InputValidator = class {
       import_zod2.z.literal("insensitive")
     ]);
   }
-  makeSelectSchema(model) {
+  makeSelectSchema(model, options) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
+        if (!this.shouldIncludeRelations(options)) {
+          continue;
+        }
         if (this.isModelAllowed(fieldDef.type)) {
-          fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
+          fields[field] = this.makeRelationSelectIncludeSchema(model, field, options).optional();
         }
       } else {
         fields[field] = import_zod2.z.boolean().optional();
       }
     }
-    const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof import_zod2.z.ZodNever)) {
-      fields["_count"] = _countSchema;
+    if (this.shouldIncludeRelations(options)) {
+      const _countSchema = this.makeCountSelectionSchema(model, options);
+      if (!(_countSchema instanceof import_zod2.z.ZodNever)) {
+        fields["_count"] = _countSchema;
+      }
     }
     return import_zod2.z.strictObject(fields);
   }
-  makeCountSelectionSchema(model) {
+  makeCountSelectionSchema(model, options) {
     const modelDef = requireModel(this.schema, model);
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
+      const nextOpts = this.nextOptions(options);
       return import_zod2.z.union([
         import_zod2.z.literal(true),
         import_zod2.z.strictObject({
@@ -5732,7 +5273,7 @@ var InputValidator = class {
             [fieldDef.name]: import_zod2.z.union([
               import_zod2.z.boolean(),
               import_zod2.z.strictObject({
-                where: this.makeWhereSchema(fieldDef.type, false, false)
+                where: this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts)
               })
             ]).optional()
           }), {}))
@@ -5742,27 +5283,29 @@ var InputValidator = class {
       return import_zod2.z.never();
     }
   }
-  makeRelationSelectIncludeSchema(model, field) {
+  makeRelationSelectIncludeSchema(model, field, options) {
     const fieldDef = requireField(this.schema, model, field);
+    const nextOpts = this.nextOptions(options);
     let objSchema = import_zod2.z.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts)).optional()
       } : {},
-      select: import_zod2.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: import_zod2.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
+      select: import_zod2.z.lazy(() => this.makeSelectSchema(fieldDef.type, nextOpts)).optional().nullable(),
+      include: import_zod2.z.lazy(() => this.makeIncludeSchema(fieldDef.type, nextOpts)).optional().nullable(),
       omit: import_zod2.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: import_zod2.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: import_zod2.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false, nextOpts), true)).optional(),
         skip: this.makeSkipSchema().optional(),
         take: this.makeTakeSchema().optional(),
-        cursor: this.makeCursorSchema(fieldDef.type).optional(),
+        cursor: this.makeCursorSchema(fieldDef.type, nextOpts).optional(),
         distinct: this.makeDistinctSchema(fieldDef.type).optional()
       } : {}
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
+    objSchema = this.refineForSelectHasTruthyField(objSchema);
     return import_zod2.z.union([
       import_zod2.z.boolean(),
       objSchema
@@ -5783,36 +5326,42 @@ var InputValidator = class {
     }
     return import_zod2.z.strictObject(fields);
   }
-  makeIncludeSchema(model) {
+  makeIncludeSchema(model, options) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
+        if (!this.shouldIncludeRelations(options)) {
+          continue;
+        }
         if (this.isModelAllowed(fieldDef.type)) {
-          fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
+          fields[field] = this.makeRelationSelectIncludeSchema(model, field, options).optional();
         }
       }
     }
-    const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof import_zod2.z.ZodNever)) {
-      fields["_count"] = _countSchema;
+    if (this.shouldIncludeRelations(options)) {
+      const _countSchema = this.makeCountSelectionSchema(model, options);
+      if (!(_countSchema instanceof import_zod2.z.ZodNever)) {
+        fields["_count"] = _countSchema;
+      }
     }
     return import_zod2.z.strictObject(fields);
   }
-  makeOrderBySchema(model, withRelation, WithAggregation) {
+  makeOrderBySchema(model, withRelation, WithAggregation, options) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
     const sort = import_zod2.z.union([
       import_zod2.z.literal("asc"),
       import_zod2.z.literal("desc")
     ]);
+    const nextOpts = this.nextOptions(options);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        if (withRelation) {
+        if (withRelation && this.shouldIncludeRelations(options)) {
           fields[field] = import_zod2.z.lazy(() => {
-            let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
+            let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation, nextOpts);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
                 _count: sort
@@ -5847,7 +5396,7 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = import_zod2.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = import_zod2.z.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
       }
     }
     return import_zod2.z.strictObject(fields);
@@ -5855,56 +5404,56 @@ var InputValidator = class {
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    return this.orArray(import_zod2.z.enum(nonRelationFields), true);
+    return nonRelationFields.length > 0 ? this.orArray(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
   }
-  makeCursorSchema(model) {
-    return this.makeWhereSchema(model, true, true).optional();
+  makeCursorSchema(model, options) {
+    return this.makeWhereSchema(model, true, true, false, options).optional();
   }
   // #endregion
   // #region Create
-  makeCreateSchema(model) {
-    const dataSchema = this.makeCreateDataSchema(model, false);
+  makeCreateSchema(model, options) {
+    const dataSchema = this.makeCreateDataSchema(model, false, [], false, options);
     const baseSchema = import_zod2.z.strictObject({
       data: dataSchema,
-      select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable(),
+      select: this.makeSelectSchema(model, options).optional().nullable(),
+      include: this.makeIncludeSchema(model, options).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "create");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
+    schema = this.refineForSelectHasTruthyField(schema);
     return schema;
   }
-  makeCreateManySchema(model) {
-    return this.mergePluginArgsSchema(this.makeCreateManyDataSchema(model, []), "createMany").optional();
+  makeCreateManySchema(model, options) {
+    return this.mergePluginArgsSchema(this.makeCreateManyPayloadSchema(model, [], options), "createMany");
   }
-  makeCreateManyAndReturnSchema(model) {
-    const base = this.makeCreateManyDataSchema(model, []);
+  makeCreateManyAndReturnSchema(model, options) {
+    const base = this.makeCreateManyPayloadSchema(model, [], options);
     let result = base.extend({
-      select: this.makeSelectSchema(model).optional().nullable(),
+      select: this.makeSelectSchema(model, options).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
     result = this.mergePluginArgsSchema(result, "createManyAndReturn");
-    return this.refineForSelectOmitMutuallyExclusive(result).optional();
+    return this.refineForSelectHasTruthyField(this.refineForSelectOmitMutuallyExclusive(result)).optional();
   }
-  makeCreateDataSchema(model, canBeArray, withoutFields = [], withoutRelationFields = false) {
+  makeCreateDataSchema(model, canBeArray, withoutFields = [], withoutRelationFields = false, options) {
+    const skipRelations = withoutRelationFields || !this.shouldIncludeRelations(options);
     const uncheckedVariantFields = {};
     const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
-    const hasRelation = !withoutRelationFields && Object.entries(modelDef.fields).some(([f, def]) => !withoutFields.includes(f) && def.relation);
+    const hasRelation = !skipRelations && Object.entries(modelDef.fields).some(([f, def]) => !withoutFields.includes(f) && def.relation);
+    const nextOpts = this.nextOptions(options);
     Object.keys(modelDef.fields).forEach((field) => {
       if (withoutFields.includes(field)) {
         return;
       }
       const fieldDef = requireField(this.schema, model, field);
-      if (fieldDef.computed) {
-        return;
-      }
-      if (this.isDelegateDiscriminator(fieldDef)) {
+      if (fieldDef.computed || fieldDef.isDiscriminator) {
         return;
       }
       if (fieldDef.relation) {
-        if (withoutRelationFields) {
+        if (skipRelations) {
           return;
         }
         if (!this.isModelAllowed(fieldDef.type)) {
@@ -5919,7 +5468,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
+        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create", nextOpts));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -5944,7 +5493,7 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
-          fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
+          fieldSchema = import_zod.ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
           fieldSchema = import_zod2.z.union([
             fieldSchema,
             import_zod2.z.strictObject({
@@ -5971,8 +5520,8 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? import_zod.ZodUtils.addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? import_zod.ZodUtils.addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
@@ -5988,153 +5537,154 @@ var InputValidator = class {
       ]);
     }
   }
-  isDelegateDiscriminator(fieldDef) {
-    if (!fieldDef.originModel) {
-      return false;
-    }
-    const discriminatorField = getDiscriminatorField(this.schema, fieldDef.originModel);
-    return discriminatorField === fieldDef.name;
-  }
-  makeRelationManipulationSchema(model, field, withoutFields, mode) {
+  makeRelationManipulationSchema(model, field, withoutFields, mode, options) {
     const fieldDef = requireField(this.schema, model, field);
     const fieldType = fieldDef.type;
     const array = !!fieldDef.array;
     const fields = {
-      create: this.makeCreateDataSchema(fieldDef.type, !!fieldDef.array, withoutFields).optional(),
-      connect: this.makeConnectDataSchema(fieldType, array).optional(),
-      connectOrCreate: this.makeConnectOrCreateDataSchema(fieldType, array, withoutFields).optional()
+      create: this.makeCreateDataSchema(fieldDef.type, !!fieldDef.array, withoutFields, false, options).optional(),
+      connect: this.makeConnectDataSchema(fieldType, array, options).optional(),
+      connectOrCreate: this.makeConnectOrCreateDataSchema(fieldType, array, withoutFields, options).optional()
     };
     if (array) {
-      fields["createMany"] = this.makeCreateManyDataSchema(fieldType, withoutFields).optional();
+      fields["createMany"] = this.makeCreateManyPayloadSchema(fieldType, withoutFields, options).optional();
     }
     if (mode === "update") {
       if (fieldDef.optional || fieldDef.array) {
-        fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
-        fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
+        fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array, options).optional();
+        fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true, options).optional();
       }
       fields["update"] = array ? this.orArray(import_zod2.z.strictObject({
-        where: this.makeWhereSchema(fieldType, true),
-        data: this.makeUpdateDataSchema(fieldType, withoutFields)
+        where: this.makeWhereSchema(fieldType, true, false, false, options),
+        data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
       }), true).optional() : import_zod2.z.union([
         import_zod2.z.strictObject({
-          where: this.makeWhereSchema(fieldType, false).optional(),
-          data: this.makeUpdateDataSchema(fieldType, withoutFields)
+          where: this.makeWhereSchema(fieldType, false, false, false, options).optional(),
+          data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
         }),
-        this.makeUpdateDataSchema(fieldType, withoutFields)
+        this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
       ]).optional();
-      let upsertWhere = this.makeWhereSchema(fieldType, true);
+      let upsertWhere = this.makeWhereSchema(fieldType, true, false, false, options);
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
       fields["upsert"] = this.orArray(import_zod2.z.strictObject({
         where: upsertWhere,
-        create: this.makeCreateDataSchema(fieldType, false, withoutFields),
-        update: this.makeUpdateDataSchema(fieldType, withoutFields)
+        create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
+        update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
       }), true).optional();
       if (array) {
-        fields["set"] = this.makeSetDataSchema(fieldType, true).optional();
+        fields["set"] = this.makeSetDataSchema(fieldType, true, options).optional();
         fields["updateMany"] = this.orArray(import_zod2.z.strictObject({
-          where: this.makeWhereSchema(fieldType, false, true),
-          data: this.makeUpdateDataSchema(fieldType, withoutFields)
+          where: this.makeWhereSchema(fieldType, false, true, false, options),
+          data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
         }), true).optional();
-        fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
+        fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false, options).optional();
       }
     }
     return import_zod2.z.strictObject(fields);
   }
-  makeSetDataSchema(model, canBeArray) {
-    return this.orArray(this.makeWhereSchema(model, true), canBeArray);
+  makeSetDataSchema(model, canBeArray, options) {
+    return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
   }
-  makeConnectDataSchema(model, canBeArray) {
-    return this.orArray(this.makeWhereSchema(model, true), canBeArray);
+  makeConnectDataSchema(model, canBeArray, options) {
+    return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
   }
-  makeDisconnectDataSchema(model, canBeArray) {
+  makeDisconnectDataSchema(model, canBeArray, options) {
     if (canBeArray) {
-      return this.orArray(this.makeWhereSchema(model, true), canBeArray);
+      return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
     } else {
       return import_zod2.z.union([
         import_zod2.z.boolean(),
-        this.makeWhereSchema(model, false)
+        this.makeWhereSchema(model, false, false, false, options)
       ]);
     }
   }
-  makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod2.z.union([
+  makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter, options) {
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter, false, false, options), true) : import_zod2.z.union([
       import_zod2.z.boolean(),
-      this.makeWhereSchema(model, uniqueFilter)
+      this.makeWhereSchema(model, uniqueFilter, false, false, options)
     ]);
   }
-  makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
-    const whereSchema = this.makeWhereSchema(model, true);
-    const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
+  makeConnectOrCreateDataSchema(model, canBeArray, withoutFields, options) {
+    const whereSchema = this.makeWhereSchema(model, true, false, false, options);
+    const createSchema = this.makeCreateDataSchema(model, false, withoutFields, false, options);
     return this.orArray(import_zod2.z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
-  makeCreateManyDataSchema(model, withoutFields) {
+  makeCreateManyPayloadSchema(model, withoutFields, options) {
     return import_zod2.z.strictObject({
-      data: this.makeCreateDataSchema(model, true, withoutFields, true),
+      data: this.makeCreateDataSchema(model, true, withoutFields, true, options),
       skipDuplicates: import_zod2.z.boolean().optional()
     });
   }
   // #endregion
   // #region Update
-  makeUpdateSchema(model) {
+  makeUpdateSchema(model, options) {
     const baseSchema = import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, true),
-      data: this.makeUpdateDataSchema(model),
-      select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable(),
+      where: this.makeWhereSchema(model, true, false, false, options),
+      data: this.makeUpdateDataSchema(model, [], false, options),
+      select: this.makeSelectSchema(model, options).optional().nullable(),
+      include: this.makeIncludeSchema(model, options).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "update");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
+    schema = this.refineForSelectHasTruthyField(schema);
     return schema;
   }
-  makeUpdateManySchema(model) {
+  makeUpdateManySchema(model, options) {
     return this.mergePluginArgsSchema(import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
-      data: this.makeUpdateDataSchema(model, [], true),
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
+      data: this.makeUpdateDataSchema(model, [], true, options),
       limit: import_zod2.z.number().int().nonnegative().optional()
     }), "updateMany");
   }
-  makeUpdateManyAndReturnSchema(model) {
-    const baseSchema = this.makeUpdateManySchema(model);
+  makeUpdateManyAndReturnSchema(model, options) {
+    const baseSchema = this.makeUpdateManySchema(model, options);
     let schema = baseSchema.extend({
-      select: this.makeSelectSchema(model).optional().nullable(),
+      select: this.makeSelectSchema(model, options).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
+    schema = this.refineForSelectHasTruthyField(schema);
     return schema;
   }
-  makeUpsertSchema(model) {
+  makeUpsertSchema(model, options) {
     const baseSchema = import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, true),
-      create: this.makeCreateDataSchema(model, false),
-      update: this.makeUpdateDataSchema(model),
-      select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable(),
+      where: this.makeWhereSchema(model, true, false, false, options),
+      create: this.makeCreateDataSchema(model, false, [], false, options),
+      update: this.makeUpdateDataSchema(model, [], false, options),
+      select: this.makeSelectSchema(model, options).optional().nullable(),
+      include: this.makeIncludeSchema(model, options).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "upsert");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
+    schema = this.refineForSelectHasTruthyField(schema);
     return schema;
   }
-  makeUpdateDataSchema(model, withoutFields = [], withoutRelationFields = false) {
+  makeUpdateDataSchema(model, withoutFields = [], withoutRelationFields = false, options) {
+    const skipRelations = withoutRelationFields || !this.shouldIncludeRelations(options);
     const uncheckedVariantFields = {};
     const checkedVariantFields = {};
     const modelDef = requireModel(this.schema, model);
-    const hasRelation = Object.entries(modelDef.fields).some(([key, value]) => value.relation && !withoutFields.includes(key));
+    const hasRelation = !skipRelations && Object.entries(modelDef.fields).some(([key, value]) => value.relation && !withoutFields.includes(key));
+    const nextOpts = this.nextOptions(options);
     Object.keys(modelDef.fields).forEach((field) => {
       if (withoutFields.includes(field)) {
         return;
       }
       const fieldDef = requireField(this.schema, model, field);
+      if (fieldDef.computed || fieldDef.isDiscriminator) {
+        return;
+      }
       if (fieldDef.relation) {
-        if (withoutRelationFields) {
+        if (skipRelations) {
           return;
         }
         if (!this.isModelAllowed(fieldDef.type)) {
@@ -6149,7 +5699,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
+        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update", nextOpts)).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -6163,6 +5713,7 @@ var InputValidator = class {
           fieldSchema = import_zod2.z.union([
             fieldSchema,
             import_zod2.z.object({
+              // TODO: use Decimal/BigInt for incremental updates
               set: this.nullableIf(import_zod2.z.number().optional(), !!fieldDef.optional).optional(),
               increment: import_zod2.z.number().optional(),
               decrement: import_zod2.z.number().optional(),
@@ -6172,7 +5723,7 @@ var InputValidator = class {
           ]);
         }
         if (fieldDef.array) {
-          const arraySchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
+          const arraySchema = import_zod.ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
           fieldSchema = import_zod2.z.union([
             arraySchema,
             import_zod2.z.object({
@@ -6201,8 +5752,8 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? import_zod.ZodUtils.addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? import_zod.ZodUtils.addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
@@ -6214,32 +5765,33 @@ var InputValidator = class {
   }
   // #endregion
   // #region Delete
-  makeDeleteSchema(model) {
+  makeDeleteSchema(model, options) {
     const baseSchema = import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, true),
-      select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable(),
+      where: this.makeWhereSchema(model, true, false, false, options),
+      select: this.makeSelectSchema(model, options).optional().nullable(),
+      include: this.makeIncludeSchema(model, options).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "delete");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
+    schema = this.refineForSelectHasTruthyField(schema);
     return schema;
   }
-  makeDeleteManySchema(model) {
+  makeDeleteManySchema(model, options) {
     return this.mergePluginArgsSchema(import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
       limit: import_zod2.z.number().int().nonnegative().optional()
     }), "deleteMany").optional();
   }
   // #endregion
   // #region Count
-  makeCountSchema(model) {
+  makeCountSchema(model, options) {
     return this.mergePluginArgsSchema(import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
-      orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
+      orderBy: this.orArray(this.makeOrderBySchema(model, true, false, options), true).optional(),
       select: this.makeCountAggregateInputSchema(model).optional()
     }), "count").optional();
   }
@@ -6258,12 +5810,12 @@ var InputValidator = class {
   }
   // #endregion
   // #region Aggregate
-  makeAggregateSchema(model) {
+  makeAggregateSchema(model, options) {
     return this.mergePluginArgsSchema(import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
-      orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
+      orderBy: this.orArray(this.makeOrderBySchema(model, true, false, options), true).optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
       _sum: this.makeSumAvgInputSchema(model).optional(),
@@ -6291,15 +5843,17 @@ var InputValidator = class {
       return acc;
     }, {}));
   }
-  makeGroupBySchema(model) {
+  // #endregion
+  // #region Group By
+  makeGroupBySchema(model, options) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
     const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
     const baseSchema = import_zod2.z.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
-      orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
+      orderBy: this.orArray(this.makeOrderBySchema(model, false, true, options), true).optional(),
       by: bySchema,
-      having: this.makeHavingSchema(model).optional(),
+      having: this.makeHavingSchema(model, options).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
@@ -6310,9 +5864,7 @@ var InputValidator = class {
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "groupBy");
     schema = schema.refine((value) => {
-      const bys = typeof value.by === "string" ? [
-        value.by
-      ] : value.by;
+      const bys = (0, import_common_helpers8.enumerate)(value.by);
       if (value.having && typeof value.having === "object") {
         for (const [key, val] of Object.entries(value.having)) {
           if (AggregateOperators.includes(key)) {
@@ -6332,14 +5884,13 @@ var InputValidator = class {
       return true;
     }, 'fields in "having" must be in "by"');
     schema = schema.refine((value) => {
-      const bys = typeof value.by === "string" ? [
-        value.by
-      ] : value.by;
-      if (value.orderBy && Object.keys(value.orderBy).filter((f) => !AggregateOperators.includes(f)).some((key) => !bys.includes(key))) {
-        return false;
-      } else {
-        return true;
+      const bys = (0, import_common_helpers8.enumerate)(value.by);
+      for (const orderBy of (0, import_common_helpers8.enumerate)(value.orderBy)) {
+        if (orderBy && Object.keys(orderBy).filter((f) => !AggregateOperators.includes(f)).some((key) => !bys.includes(key))) {
+          return false;
+        }
       }
+      return true;
     }, 'fields in "orderBy" must be in "by"');
     return schema;
   }
@@ -6349,7 +5900,7 @@ var InputValidator = class {
         continue;
       }
       if (LOGICAL_COMBINATORS.includes(key)) {
-        if ((0, import_common_helpers9.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
+        if ((0, import_common_helpers8.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
           continue;
         }
       }
@@ -6357,12 +5908,12 @@ var InputValidator = class {
     }
     return true;
   }
-  makeHavingSchema(model) {
-    return this.makeWhereSchema(model, false, true, true);
+  makeHavingSchema(model, options) {
+    return this.makeWhereSchema(model, false, true, true, options);
   }
   // #endregion
   // #region Procedures
-  makeProcedureParamSchema(param) {
+  makeProcedureParamSchema(param, _options) {
     let schema;
     if (isTypeDef(this.schema, param.type)) {
       schema = this.makeTypeDefSchema(param.type);
@@ -6385,21 +5936,54 @@ var InputValidator = class {
     return schema;
   }
   // #endregion
-  // #region Cache Management
-  getCache(cacheKey) {
-    return this.schemaCache.get(cacheKey);
-  }
-  setCache(cacheKey, schema) {
-    return this.schemaCache.set(cacheKey, schema);
+  // #region Plugin Args
+  mergePluginArgsSchema(schema, operation) {
+    let result = schema;
+    for (const plugin of this.plugins ?? []) {
+      if (plugin.queryArgs) {
+        const pluginSchema = this.getPluginExtQueryArgsSchema(plugin, operation);
+        if (pluginSchema) {
+          result = result.extend(pluginSchema.shape);
+        }
+      }
+    }
+    return result.strict();
   }
-  // @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}`);
+  getPluginExtQueryArgsSchema(plugin, operation) {
+    if (!plugin.queryArgs) {
+      return void 0;
+    }
+    let result;
+    if (operation in plugin.queryArgs && plugin.queryArgs[operation]) {
+      result = plugin.queryArgs[operation];
+    } else if (operation === "upsert") {
+      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_helpers8.invariant)(createSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers8.invariant)(updateSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        result = createSchema.extend(updateSchema.shape);
+      } else if (createSchema) {
+        result = createSchema;
+      } else if (updateSchema) {
+        result = updateSchema;
       }
+    } else if (
+      // then comes grouped operations: $create, $read, $update, $delete
+      CoreCreateOperations.includes(operation) && "$create" in plugin.queryArgs && plugin.queryArgs["$create"]
+    ) {
+      result = plugin.queryArgs["$create"];
+    } else if (CoreReadOperations.includes(operation) && "$read" in plugin.queryArgs && plugin.queryArgs["$read"]) {
+      result = plugin.queryArgs["$read"];
+    } else if (CoreUpdateOperations.includes(operation) && "$update" in plugin.queryArgs && plugin.queryArgs["$update"]) {
+      result = plugin.queryArgs["$update"];
+    } else if (CoreDeleteOperations.includes(operation) && "$delete" in plugin.queryArgs && plugin.queryArgs["$delete"]) {
+      result = plugin.queryArgs["$delete"];
+    } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
+      result = plugin.queryArgs["$all"];
     }
+    (0, import_common_helpers8.invariant)(result === void 0 || result instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+    return result;
   }
   // #endregion
   // #region Helpers
@@ -6415,6 +5999,15 @@ var InputValidator = class {
   refineForSelectOmitMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["omit"]), '"select" and "omit" cannot be used together');
   }
+  refineForSelectHasTruthyField(schema) {
+    return schema.refine((value) => {
+      const select = value["select"];
+      if (!select || typeof select !== "object") {
+        return true;
+      }
+      return Object.values(select).some((v) => v);
+    }, '"select" must have at least one truthy value');
+  }
   nullableIf(schema, nullable) {
     return nullable ? schema.nullable() : schema;
   }
@@ -6432,7 +6025,7 @@ var InputValidator = class {
   }
   /**
    * Gets the effective set of allowed FilterKind values for a specific model and field.
-   * Respects the precedence: field-level > model-level $all > global $all.
+   * Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
    */
   getEffectiveFilterKinds(model, field) {
     if (!model) {
@@ -6442,21 +6035,27 @@ var InputValidator = class {
     if (!slicing?.models) {
       return void 0;
     }
-    const modelConfig = slicing.models[model];
+    const modelsRecord = slicing.models;
+    const modelConfig = modelsRecord[(0, import_common_helpers8.lowerCaseFirst)(model)];
     if (modelConfig?.fields) {
       const fieldConfig = modelConfig.fields[field];
       if (fieldConfig) {
         return this.computeFilterKinds(fieldConfig.includedFilterKinds, fieldConfig.excludedFilterKinds);
       }
-      const allFieldsConfig = modelConfig.fields.$all;
+      const allFieldsConfig = modelConfig.fields["$all"];
       if (allFieldsConfig) {
         return this.computeFilterKinds(allFieldsConfig.includedFilterKinds, allFieldsConfig.excludedFilterKinds);
       }
     }
-    const allModelsConfig = slicing.models.$all;
+    const allModelsConfig = modelsRecord["$all"];
     if (allModelsConfig?.fields) {
-      if (allModelsConfig.fields.$all) {
-        return this.computeFilterKinds(allModelsConfig.fields.$all.includedFilterKinds, allModelsConfig.fields.$all.excludedFilterKinds);
+      const allModelsFieldConfig = allModelsConfig.fields[field];
+      if (allModelsFieldConfig) {
+        return this.computeFilterKinds(allModelsFieldConfig.includedFilterKinds, allModelsFieldConfig.excludedFilterKinds);
+      }
+      const allModelsAllFieldsConfig = allModelsConfig.fields["$all"];
+      if (allModelsAllFieldsConfig) {
+        return this.computeFilterKinds(allModelsAllFieldsConfig.includedFilterKinds, allModelsAllFieldsConfig.excludedFilterKinds);
       }
     }
     return void 0;
@@ -6538,18 +6137,20 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
-    typeof CoreCrudOperations === "undefined" ? Object : CoreCrudOperations
+    typeof CoreCrudOperations === "undefined" ? Object : CoreCrudOperations,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeFindSchema", null);
+], ZodSchemaFactory.prototype, "makeFindSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeExistsSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeExistsSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6557,15 +6158,15 @@ _ts_decorate([
     String
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeEnumSchema", null);
+], ZodSchemaFactory.prototype, "makeEnumSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String
   ]),
-  _ts_metadata("design:returntype", typeof import_zod2.z === "undefined" || typeof import_zod2.z.ZodType === "undefined" ? Object : import_zod2.z.ZodType)
-], InputValidator.prototype, "makeTypeDefSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeTypeDefSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6573,10 +6174,11 @@ _ts_decorate([
     String,
     Boolean,
     void 0,
-    void 0
+    void 0,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
-], InputValidator.prototype, "makeWhereSchema", null);
+], ZodSchemaFactory.prototype, "makeWhereSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6585,7 +6187,7 @@ _ts_decorate([
     typeof FieldInfo === "undefined" ? Object : FieldInfo
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeTypedJsonFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeTypedJsonFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6596,7 +6198,7 @@ _ts_decorate([
     Boolean
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeEnumFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeEnumFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6605,7 +6207,7 @@ _ts_decorate([
     typeof FieldInfo === "undefined" ? Object : FieldInfo
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeArrayFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeArrayFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6616,7 +6218,7 @@ _ts_decorate([
     void 0
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makePrimitiveFilterSchema", null);
+], ZodSchemaFactory.prototype, "makePrimitiveFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6626,7 +6228,7 @@ _ts_decorate([
     Boolean
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeJsonFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeJsonFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6636,7 +6238,7 @@ _ts_decorate([
     Object
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
-], InputValidator.prototype, "makeDateTimeFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeDateTimeFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6646,7 +6248,7 @@ _ts_decorate([
     Object
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
-], InputValidator.prototype, "makeBooleanFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeBooleanFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6656,32 +6258,35 @@ _ts_decorate([
     Object
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
-], InputValidator.prototype, "makeBytesFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeBytesFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    String,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeSelectSchema", null);
+], ZodSchemaFactory.prototype, "makeSelectSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    String,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCountSelectionSchema", null);
+], ZodSchemaFactory.prototype, "makeCountSelectionSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
-    String
+    String,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeRelationSelectIncludeSchema", null);
+], ZodSchemaFactory.prototype, "makeRelationSelectIncludeSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6689,25 +6294,27 @@ _ts_decorate([
     String
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeOmitSchema", null);
+], ZodSchemaFactory.prototype, "makeOmitSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    String,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeIncludeSchema", null);
+], ZodSchemaFactory.prototype, "makeIncludeSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
     Boolean,
-    Boolean
+    Boolean,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeOrderBySchema", null);
+], ZodSchemaFactory.prototype, "makeOrderBySchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6715,31 +6322,34 @@ _ts_decorate([
     String
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeDistinctSchema", null);
+], ZodSchemaFactory.prototype, "makeDistinctSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCreateSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeCreateSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCreateManySchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeCreateManySchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCreateManyAndReturnSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeCreateManyAndReturnSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6747,10 +6357,11 @@ _ts_decorate([
     String,
     Boolean,
     Array,
-    void 0
+    void 0,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCreateDataSchema", null);
+], ZodSchemaFactory.prototype, "makeCreateDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6758,132 +6369,147 @@ _ts_decorate([
     String,
     String,
     Array,
-    String
+    String,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeRelationManipulationSchema", null);
+], ZodSchemaFactory.prototype, "makeRelationManipulationSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
-    Boolean
+    Boolean,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeSetDataSchema", null);
+], ZodSchemaFactory.prototype, "makeSetDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
-    Boolean
+    Boolean,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeConnectDataSchema", null);
+], ZodSchemaFactory.prototype, "makeConnectDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
-    Boolean
+    Boolean,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeDisconnectDataSchema", null);
+], ZodSchemaFactory.prototype, "makeDisconnectDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
     Boolean,
-    Boolean
+    Boolean,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeDeleteRelationDataSchema", null);
+], ZodSchemaFactory.prototype, "makeDeleteRelationDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
     Boolean,
-    Array
+    Array,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeConnectOrCreateDataSchema", null);
+], ZodSchemaFactory.prototype, "makeConnectOrCreateDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
-    Array
+    Array,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCreateManyDataSchema", null);
+], ZodSchemaFactory.prototype, "makeCreateManyPayloadSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeUpdateSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeUpdateSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeUpdateManySchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeUpdateManySchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeUpdateManyAndReturnSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeUpdateManyAndReturnSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeUpsertSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeUpsertSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     String,
     Array,
-    void 0
+    void 0,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeUpdateDataSchema", null);
+], ZodSchemaFactory.prototype, "makeUpdateDataSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeDeleteSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeDeleteSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeDeleteManySchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeDeleteManySchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCountSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeCountSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6891,15 +6517,16 @@ _ts_decorate([
     String
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeCountAggregateInputSchema", null);
+], ZodSchemaFactory.prototype, "makeCountAggregateInputSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeAggregateSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeAggregateSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6907,7 +6534,7 @@ _ts_decorate([
     String
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeSumAvgInputSchema", null);
+], ZodSchemaFactory.prototype, "makeSumAvgInputSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6915,35 +6542,168 @@ _ts_decorate([
     String
   ]),
   _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeMinMaxInputSchema", null);
+], ZodSchemaFactory.prototype, "makeMinMaxInputSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String
+    typeof Model === "undefined" ? Object : Model,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", void 0)
-], InputValidator.prototype, "makeGroupBySchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.prototype, "makeGroupBySchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    Object
+    Object,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
-  _ts_metadata("design:returntype", typeof import_zod2.z === "undefined" || typeof import_zod2.z.ZodType === "undefined" ? Object : import_zod2.z.ZodType)
-], InputValidator.prototype, "makeProcedureParamSchema", null);
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
+], ZodSchemaFactory.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);
+], ZodSchemaFactory.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);
+], ZodSchemaFactory.prototype, "makeTakeSchema", null);
+
+// src/client/crud/validator/validator.ts
+var InputValidator = class {
+  static {
+    __name(this, "InputValidator");
+  }
+  client;
+  zodFactory;
+  constructor(client) {
+    this.client = client;
+    this.zodFactory = new ZodSchemaFactory(client);
+  }
+  // #region Entry points
+  validateFindArgs(model, args, operation) {
+    return this.validate(model, operation, (model2) => (0, import_ts_pattern14.match)(operation).with("findFirst", () => this.zodFactory.makeFindFirstSchema(model2)).with("findUnique", () => this.zodFactory.makeFindUniqueSchema(model2)).with("findMany", () => this.zodFactory.makeFindManySchema(model2)).exhaustive(), args);
+  }
+  validateExistsArgs(model, args) {
+    return this.validate(model, "exists", (model2) => this.zodFactory.makeExistsSchema(model2), args);
+  }
+  validateCreateArgs(model, args) {
+    return this.validate(model, "create", (model2) => this.zodFactory.makeCreateSchema(model2), args);
+  }
+  validateCreateManyArgs(model, args) {
+    return this.validate(model, "createMany", (model2) => this.zodFactory.makeCreateManySchema(model2), args);
+  }
+  validateCreateManyAndReturnArgs(model, args) {
+    return this.validate(model, "createManyAndReturn", (model2) => this.zodFactory.makeCreateManyAndReturnSchema(model2), args);
+  }
+  validateUpdateArgs(model, args) {
+    return this.validate(model, "update", (model2) => this.zodFactory.makeUpdateSchema(model2), args);
+  }
+  validateUpdateManyArgs(model, args) {
+    return this.validate(model, "updateMany", (model2) => this.zodFactory.makeUpdateManySchema(model2), args);
+  }
+  validateUpdateManyAndReturnArgs(model, args) {
+    return this.validate(model, "updateManyAndReturn", (model2) => this.zodFactory.makeUpdateManyAndReturnSchema(model2), args);
+  }
+  validateUpsertArgs(model, args) {
+    return this.validate(model, "upsert", (model2) => this.zodFactory.makeUpsertSchema(model2), args);
+  }
+  validateDeleteArgs(model, args) {
+    return this.validate(model, "delete", (model2) => this.zodFactory.makeDeleteSchema(model2), args);
+  }
+  validateDeleteManyArgs(model, args) {
+    return this.validate(model, "deleteMany", (model2) => this.zodFactory.makeDeleteManySchema(model2), args);
+  }
+  validateCountArgs(model, args) {
+    return this.validate(model, "count", (model2) => this.zodFactory.makeCountSchema(model2), args);
+  }
+  validateAggregateArgs(model, args) {
+    return this.validate(model, "aggregate", (model2) => this.zodFactory.makeAggregateSchema(model2), args);
+  }
+  validateGroupByArgs(model, args) {
+    return this.validate(model, "groupBy", (model2) => this.zodFactory.makeGroupBySchema(model2), args);
+  }
+  // TODO: turn it into a Zod schema and cache
+  validateProcedureInput(proc, input) {
+    const procDef = (this.client.$schema.procedures ?? {})[proc];
+    (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) {
+        return void 0;
+      }
+      if (params.every((p) => p.optional)) {
+        return void 0;
+      }
+      throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
+    }
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      throw createInvalidInputError("Procedure input must be an object", `$procs.${proc}`);
+    }
+    const envelope = input;
+    const argsPayload = Object.prototype.hasOwnProperty.call(envelope, "args") ? envelope.args : void 0;
+    if (params.length === 0) {
+      if (typeof argsPayload === "undefined") {
+        return input;
+      }
+      if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
+        throw createInvalidInputError("Procedure `args` must be an object", `$procs.${proc}`);
+      }
+      if (Object.keys(argsPayload).length === 0) {
+        return input;
+      }
+      throw createInvalidInputError("Procedure does not accept arguments", `$procs.${proc}`);
+    }
+    if (typeof argsPayload === "undefined") {
+      if (params.every((p) => p.optional)) {
+        return input;
+      }
+      throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
+    }
+    if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
+      throw createInvalidInputError("Procedure `args` must be an object", `$procs.${proc}`);
+    }
+    const obj = argsPayload;
+    for (const param of params) {
+      const value = obj[param.name];
+      if (!Object.prototype.hasOwnProperty.call(obj, param.name)) {
+        if (param.optional) {
+          continue;
+        }
+        throw createInvalidInputError(`Missing procedure argument: ${param.name}`, `$procs.${proc}`);
+      }
+      if (typeof value === "undefined") {
+        if (param.optional) {
+          continue;
+        }
+        throw createInvalidInputError(`Invalid procedure argument: ${param.name} is required`, `$procs.${proc}`);
+      }
+      const schema = this.zodFactory.makeProcedureParamSchema(param);
+      const parsed = schema.safeParse(value);
+      if (!parsed.success) {
+        throw createInvalidInputError(`Invalid procedure argument: ${param.name}: ${formatError(parsed.error)}`, `$procs.${proc}`);
+      }
+    }
+    return input;
+  }
+  // #endregion
+  // #region Validation helpers
+  validate(model, operation, getSchema, args) {
+    const schema = getSchema(model);
+    const { error, data } = schema.safeParse(args);
+    if (error) {
+      throw createInvalidInputError(`Invalid ${operation} args for model "${model}": ${formatError(error)}`, model, {
+        cause: error
+      });
+    }
+    return data;
+  }
+};
 
 // src/client/executor/zenstack-driver.ts
 var ZenStackDriver = class {
@@ -7130,7 +6890,7 @@ __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
 var import_common_helpers11 = require("@zenstackhq/common-helpers");
-var import_kysely8 = require("kysely");
+var import_kysely9 = require("kysely");
 var import_ts_pattern15 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
@@ -7718,8 +7478,32 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   }
 };
 
+// src/client/executor/temp-alias-transformer.ts
+var import_kysely8 = require("kysely");
+var TempAliasTransformer = class extends import_kysely8.OperationNodeTransformer {
+  static {
+    __name(this, "TempAliasTransformer");
+  }
+  aliasMap = /* @__PURE__ */ new Map();
+  run(node) {
+    this.aliasMap.clear();
+    return this.transformNode(node);
+  }
+  transformIdentifier(node, queryId) {
+    if (node.name.startsWith(TEMP_ALIAS_PREFIX)) {
+      let mapped = this.aliasMap.get(node.name);
+      if (!mapped) {
+        mapped = `$$t${this.aliasMap.size + 1}`;
+        this.aliasMap.set(node.name, mapped);
+      }
+      return import_kysely8.IdentifierNode.create(mapped);
+    }
+    return super.transformIdentifier(node, queryId);
+  }
+};
+
 // src/client/executor/zenstack-query-executor.ts
-var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely8.DefaultQueryExecutor {
+var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.DefaultQueryExecutor {
   static {
     __name(this, "ZenStackQueryExecutor");
   }
@@ -7821,17 +7605,17 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely8.
     }
     let preUpdateIds;
     const mutationModel = this.getMutationModel(query);
-    const needLoadAfterMutationEntities = (import_kysely8.InsertQueryNode.is(query) || import_kysely8.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks;
+    const needLoadAfterMutationEntities = (import_kysely9.InsertQueryNode.is(query) || import_kysely9.UpdateQueryNode.is(query)) && this.hasEntityMutationPluginsWithAfterMutationHooks;
     if (needLoadAfterMutationEntities) {
       if (this.dialect.supportsReturning) {
         query = {
           ...query,
-          returning: import_kysely8.ReturningNode.create([
-            import_kysely8.SelectionNode.createSelectAll()
+          returning: import_kysely9.ReturningNode.create([
+            import_kysely9.SelectionNode.createSelectAll()
           ])
         };
       } else {
-        if (import_kysely8.UpdateQueryNode.is(query)) {
+        if (import_kysely9.UpdateQueryNode.is(query)) {
           preUpdateIds = await this.getPreUpdateIds(mutationModel, query, connection);
         }
       }
@@ -7841,7 +7625,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely8.
     const mutationInfo = this.getMutationInfo(query);
     let beforeMutationEntities;
     const loadBeforeMutationEntities = /* @__PURE__ */ __name(async () => {
-      if (beforeMutationEntities === void 0 && (import_kysely8.UpdateQueryNode.is(query) || import_kysely8.DeleteQueryNode.is(query))) {
+      if (beforeMutationEntities === void 0 && (import_kysely9.UpdateQueryNode.is(query) || import_kysely9.DeleteQueryNode.is(query))) {
         beforeMutationEntities = await this.loadEntities(mutationInfo.model, mutationInfo.where, connection, void 0);
       }
       return beforeMutationEntities;
@@ -7945,10 +7729,10 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely8.
     if (this.dialect.supportsReturning) {
       return queryResult.rows;
     } else {
-      const mutatedIds = import_kysely8.InsertQueryNode.is(queryNode) ? this.getInsertIds(mutationInfo.model, queryNode, queryResult) : preUpdateIds;
+      const mutatedIds = import_kysely9.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 eb = (0, import_kysely9.expressionBuilder)();
         const filter = eb(
           // @ts-ignore
           eb.refTuple(...idFields),
@@ -7957,7 +7741,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely8.
             ...idFields.map((idField) => eb.val(idObj[idField]))
           ))
         );
-        const entities = await this.loadEntities(mutationInfo.model, import_kysely8.WhereNode.create(filter.toOperationNode()), connection, void 0);
+        const entities = await this.loadEntities(mutationInfo.model, import_kysely9.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}".
@@ -7978,9 +7762,9 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     const idFields = requireIdFields(this.client.$schema, mutationModel);
     if (query.updates) {
       for (const update of query.updates) {
-        if (import_kysely8.ColumnUpdateNode.is(update)) {
+        if (import_kysely9.ColumnUpdateNode.is(update)) {
           const columnNode = update.column;
-          if (import_kysely8.ColumnNode.is(columnNode)) {
+          if (import_kysely9.ColumnNode.is(columnNode)) {
             const columnName = columnNode.column.name;
             if (idFields.includes(columnName)) {
               return void 0;
@@ -7993,7 +7777,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   }
   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) {
+    if (import_kysely9.InsertQueryNode.is(query) && queryResult.numAffectedRows === 1n && queryResult.insertId && idFields.length === 1) {
       return [
         {
           [idFields[0]]: queryResult.insertId
@@ -8005,13 +7789,13 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
       return void 0;
     }
     const values = query.values;
-    if (!values || !import_kysely8.ValuesNode.is(values)) {
+    if (!values || !import_kysely9.ValuesNode.is(values)) {
       return void 0;
     }
     const allIds = [];
     for (const valuesItem of values.values) {
       const rowIds = {};
-      if (import_kysely8.PrimitiveValueListNode.is(valuesItem)) {
+      if (import_kysely9.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);
@@ -8028,7 +7812,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
             return void 0;
           }
           const valueNode = valuesItem.values[colIndex];
-          if (!valueNode || !import_kysely8.ValueNode.is(valueNode)) {
+          if (!valueNode || !import_kysely9.ValueNode.is(valueNode)) {
             return void 0;
           }
           rowIds[idField] = valueNode.value;
@@ -8057,13 +7841,13 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   // #region utilities
   getMutationInfo(queryNode) {
     const model = this.getMutationModel(queryNode);
-    const { action, where } = (0, import_ts_pattern15.match)(queryNode).when(import_kysely8.InsertQueryNode.is, () => ({
+    const { action, where } = (0, import_ts_pattern15.match)(queryNode).when(import_kysely9.InsertQueryNode.is, () => ({
       action: "create",
       where: void 0
-    })).when(import_kysely8.UpdateQueryNode.is, (node) => ({
+    })).when(import_kysely9.UpdateQueryNode.is, (node) => ({
       action: "update",
       where: node.where
-    })).when(import_kysely8.DeleteQueryNode.is, (node) => ({
+    })).when(import_kysely9.DeleteQueryNode.is, (node) => ({
       action: "delete",
       where: node.where
     })).exhaustive();
@@ -8074,31 +7858,43 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     };
   }
   isMutationNode(queryNode) {
-    return import_kysely8.InsertQueryNode.is(queryNode) || import_kysely8.UpdateQueryNode.is(queryNode) || import_kysely8.DeleteQueryNode.is(queryNode);
+    return import_kysely9.InsertQueryNode.is(queryNode) || import_kysely9.UpdateQueryNode.is(queryNode) || import_kysely9.DeleteQueryNode.is(queryNode);
   }
   getMutationModel(queryNode) {
-    return (0, import_ts_pattern15.match)(queryNode).when(import_kysely8.InsertQueryNode.is, (node) => {
+    return (0, import_ts_pattern15.match)(queryNode).when(import_kysely9.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) => {
+    }).when(import_kysely9.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");
+      (0, import_common_helpers11.invariant)(import_kysely9.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
-    }).when(import_kysely8.DeleteQueryNode.is, (node) => {
+    }).when(import_kysely9.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");
+      (0, import_common_helpers11.invariant)(import_kysely9.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw createInternalError(`Invalid query node: ${node}`);
     });
   }
+  processQueryNode(query) {
+    let result = query;
+    result = this.processNameMapping(result);
+    result = this.processTempAlias(result);
+    return result;
+  }
   processNameMapping(query) {
     return this.nameMapper?.transformNode(query) ?? query;
   }
+  processTempAlias(query) {
+    if (this.options.useCompactAliasNames === false) {
+      return query;
+    }
+    return new TempAliasTransformer().run(query);
+  }
   createClientForConnection(connection, inTx) {
-    const innerExecutor = this.withConnectionProvider(new import_kysely8.SingleConnectionProvider(connection));
+    const innerExecutor = this.withConnectionProvider(new import_kysely9.SingleConnectionProvider(connection));
     innerExecutor.suppressMutationHooks = true;
     const innerClient = this.client.withExecutor(innerExecutor);
     if (inTx) {
@@ -8108,16 +7904,16 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   }
   andNodes(condition1, condition2) {
     if (condition1 && condition2) {
-      return import_kysely8.WhereNode.create(import_kysely8.AndNode.create(condition1, condition2));
+      return import_kysely9.WhereNode.create(import_kysely9.AndNode.create(condition1, condition2));
     } else if (condition1) {
-      return import_kysely8.WhereNode.create(condition1);
+      return import_kysely9.WhereNode.create(condition1);
     } else {
       return condition2;
     }
   }
   async internalExecuteQuery(query, connection, queryId, parameters) {
-    const finalQuery = this.processNameMapping(query);
-    let compiledQuery = this.compileQuery(finalQuery, queryId ?? (0, import_kysely8.createQueryId)());
+    const finalQuery = this.processQueryNode(query);
+    let compiledQuery = this.compileQuery(finalQuery, queryId ?? (0, import_kysely9.createQueryId)());
     if (parameters) {
       compiledQuery = {
         ...compiledQuery,
@@ -8187,7 +7983,7 @@ __export(functions_exports, {
   startsWith: () => startsWith
 });
 var import_common_helpers12 = require("@zenstackhq/common-helpers");
-var import_kysely9 = require("kysely");
+var import_kysely10 = 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) => {
@@ -8225,20 +8021,20 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   } else {
     op = "like";
   }
-  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 = eb.fn.coalesce(searchExpr, import_kysely10.sql.lit(""));
+  const escapedSearch = import_kysely10.sql`REPLACE(REPLACE(REPLACE(${dialect.castText(searchExpr)}, ${import_kysely10.sql.val("\\")}, ${import_kysely10.sql.val("\\\\")}), ${import_kysely10.sql.val("%")}, ${import_kysely10.sql.val("\\%")}), ${import_kysely10.sql.val("_")}, ${import_kysely10.sql.val("\\_")})`;
   searchExpr = (0, import_ts_pattern16.match)(method).with("contains", () => eb.fn("CONCAT", [
-    import_kysely9.sql.lit("%"),
+    import_kysely10.sql.lit("%"),
     escapedSearch,
-    import_kysely9.sql.lit("%")
+    import_kysely10.sql.lit("%")
   ])).with("startsWith", () => eb.fn("CONCAT", [
     escapedSearch,
-    import_kysely9.sql.lit("%")
+    import_kysely10.sql.lit("%")
   ])).with("endsWith", () => eb.fn("CONCAT", [
-    import_kysely9.sql.lit("%"),
+    import_kysely10.sql.lit("%"),
     escapedSearch
   ])).exhaustive();
-  return import_kysely9.sql`${fieldExpr} ${import_kysely9.sql.raw(op)} ${searchExpr} escape ${import_kysely9.sql.val("\\")}`;
+  return import_kysely10.sql`${fieldExpr} ${import_kysely10.sql.raw(op)} ${searchExpr} escape ${import_kysely10.sql.val("\\")}`;
 }, "textMatch");
 var has = /* @__PURE__ */ __name((_eb, args, context) => {
   const [field, search2] = args;
@@ -8275,16 +8071,16 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   if (!field) {
     throw new Error('"field" parameter is required');
   }
-  return eb(dialect.buildArrayLength(field), "=", import_kysely9.sql.lit(0));
+  return eb(dialect.buildArrayLength(field), "=", import_kysely10.sql.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name(() => import_kysely9.sql.raw("CURRENT_TIMESTAMP"), "now");
+var now = /* @__PURE__ */ __name(() => import_kysely10.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_kysely9.sql.lit(result);
+  return import_kysely10.sql.lit(result);
 }, "currentModel");
 var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   let result = operation;
@@ -8292,11 +8088,11 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
   if (casing) {
     result = processCasing(casing, result, operation);
   }
-  return import_kysely9.sql.lit(result);
+  return import_kysely10.sql.lit(result);
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers12.invariant)(import_kysely9.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  (0, import_common_helpers12.invariant)(import_kysely10.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".`);
   });
@@ -8308,14 +8104,14 @@ function readBoolean(expr, defaultValue) {
     return defaultValue;
   }
   const opNode = expr.toOperationNode();
-  (0, import_common_helpers12.invariant)(import_kysely9.ValueNode.is(opNode), "expression must be a literal value");
+  (0, import_common_helpers12.invariant)(import_kysely10.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_helpers13 = require("@zenstackhq/common-helpers");
-var import_kysely10 = require("kysely");
+var import_kysely11 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern17 = require("ts-pattern");
 var SchemaDbPusher = class {
@@ -8493,7 +8289,7 @@ var SchemaDbPusher = class {
       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 = this.schema.provider.type === "mysql" ? col.defaultTo(import_kysely10.sql`CURRENT_TIMESTAMP(3)`) : col.defaultTo(import_kysely10.sql`CURRENT_TIMESTAMP`);
+            col = this.schema.provider.type === "mysql" ? col.defaultTo(import_kysely11.sql`CURRENT_TIMESTAMP(3)`) : col.defaultTo(import_kysely11.sql`CURRENT_TIMESTAMP`);
           }
         } else {
           if (this.schema.provider.type === "mysql" && fieldDef.type === "DateTime" && typeof fieldDef.default === "string") {
@@ -8525,7 +8321,7 @@ var SchemaDbPusher = class {
   mapFieldType(fieldDef) {
     if (this.schema.enums?.[fieldDef.type]) {
       if (this.schema.provider.type === "postgresql") {
-        return import_kysely10.sql.ref(fieldDef.type);
+        return import_kysely11.sql.ref(fieldDef.type);
       } else if (this.schema.provider.type === "mysql") {
         const enumDef = this.schema.enums[fieldDef.type];
         let enumValues;
@@ -8543,7 +8339,7 @@ var SchemaDbPusher = class {
         } else {
           enumValues = Object.values(enumDef.values);
         }
-        return import_kysely10.sql.raw(`enum(${enumValues.map((v) => `'${v}'`).join(", ")})`);
+        return import_kysely11.sql.raw(`enum(${enumValues.map((v) => `'${v}'`).join(", ")})`);
       } else {
         return "text";
       }
@@ -8559,7 +8355,7 @@ var SchemaDbPusher = class {
       throw new Error(`Unsupported field type: ${type}`);
     });
     if (fieldDef.array) {
-      return import_kysely10.sql.raw(`${result}[]`);
+      return import_kysely11.sql.raw(`${result}[]`);
     } else {
       return result;
     }
@@ -8605,25 +8401,25 @@ var SchemaDbPusher = class {
     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");
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.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");
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("tinyint(1)")).otherwise(() => "boolean");
   }
   get intType() {
     return "integer";
   }
   get floatType() {
-    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => import_kysely10.sql.raw("double")).otherwise(() => "real");
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("postgresql", () => "double precision").with("mysql", () => import_kysely11.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");
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.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");
+    return (0, import_ts_pattern17.match)(this.schema.provider.type).with("mysql", () => import_kysely11.sql.raw("datetime(3)")).otherwise(() => "timestamp");
   }
   columnSupportsAutoIncrement() {
     return [
@@ -8814,15 +8610,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_kysely11.DefaultConnectionProvider(baseClient.kyselyProps.driver))
+        executor: executor ?? new ZenStackQueryExecutor(this, baseClient.kyselyProps.driver, baseClient.kyselyProps.dialect.createQueryCompiler(), baseClient.kyselyProps.dialect.createAdapter(), new import_kysely12.DefaultConnectionProvider(baseClient.kyselyProps.driver))
       };
       this.kyselyRaw = baseClient.kyselyRaw;
       this.auth = baseClient.auth;
     } else {
-      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely11.Log(this.$options.log ?? []));
+      const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely12.Log(this.$options.log ?? []));
       const compiler = options.dialect.createQueryCompiler();
       const adapter = options.dialect.createAdapter();
-      const connectionProvider = new import_kysely11.DefaultConnectionProvider(driver);
+      const connectionProvider = new import_kysely12.DefaultConnectionProvider(driver);
       this.kyselyProps = {
         config: {
           dialect: options.dialect,
@@ -8832,12 +8628,12 @@ var ClientImpl = class _ClientImpl {
         driver,
         executor: executor ?? new ZenStackQueryExecutor(this, driver, compiler, adapter, connectionProvider)
       };
-      this.kyselyRaw = new import_kysely11.Kysely({
+      this.kyselyRaw = new import_kysely12.Kysely({
         ...this.kyselyProps,
-        executor: new import_kysely11.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
+        executor: new import_kysely12.DefaultQueryExecutor(compiler, adapter, connectionProvider, [])
       });
     }
-    this.kysely = new import_kysely11.Kysely(this.kyselyProps);
+    this.kysely = new import_kysely12.Kysely(this.kyselyProps);
     this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this);
     return createClientProxy(this);
   }
@@ -8847,6 +8643,9 @@ var ClientImpl = class _ClientImpl {
   get $qbRaw() {
     return this.kyselyRaw;
   }
+  get $zod() {
+    return this.inputValidator.zodFactory;
+  }
   get isTransaction() {
     return this.kysely.isTransaction;
   }
@@ -8887,7 +8686,7 @@ var ClientImpl = class _ClientImpl {
   }
   forceTransaction() {
     if (!this.kysely.isTransaction) {
-      this.kysely = new import_kysely11.Transaction(this.kyselyProps);
+      this.kysely = new import_kysely12.Transaction(this.kyselyProps);
     }
   }
   async interactiveTransaction(callback, options) {
@@ -8978,7 +8777,7 @@ var ClientImpl = class _ClientImpl {
   }
   async $connect() {
     await this.kysely.connection().execute(async (conn) => {
-      await conn.executeQuery(import_kysely11.sql`select 1`.compile(this.kysely));
+      await conn.executeQuery(import_kysely12.sql`select 1`.compile(this.kysely));
     });
   }
   async $disconnect() {
@@ -9049,7 +8848,7 @@ var ClientImpl = class _ClientImpl {
   }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely11.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely12.sql)(query, ...values).execute(this.kysely);
       return Number(result.numAffectedRows ?? 0);
     });
   }
@@ -9062,7 +8861,7 @@ var ClientImpl = class _ClientImpl {
   }
   $queryRaw(query, ...values) {
     return createZenStackPromise(async () => {
-      const result = await (0, import_kysely11.sql)(query, ...values).execute(this.kysely);
+      const result = await (0, import_kysely12.sql)(query, ...values).execute(this.kysely);
       return result.rows;
     });
   }
@@ -9074,7 +8873,7 @@ var ClientImpl = class _ClientImpl {
     });
   }
   createRawCompiledQuery(query, values) {
-    const q = import_kysely11.CompiledQuery.raw(query, values);
+    const q = import_kysely12.CompiledQuery.raw(query, values);
     return {
       ...q,
       $raw: true
@@ -9253,7 +9052,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
   const slicing = client.$options.slicing;
   if (slicing?.models) {
-    const modelSlicing = slicing.models[model];
+    const modelSlicing = slicing.models[(0, import_common_helpers14.lowerCaseFirst)(model)];
     const allSlicing = slicing.models.$all;
     const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
     const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;
@@ -9285,8 +9084,8 @@ var kysely_utils_exports = {};
 __export(kysely_utils_exports, {
   DefaultOperationNodeVisitor: () => DefaultOperationNodeVisitor
 });
-var import_kysely12 = require("kysely");
-var DefaultOperationNodeVisitor = class extends import_kysely12.OperationNodeVisitor {
+var import_kysely13 = require("kysely");
+var DefaultOperationNodeVisitor = class extends import_kysely13.OperationNodeVisitor {
   static {
     __name(this, "DefaultOperationNodeVisitor");
   }
@@ -9724,6 +9523,7 @@ var MatchingExpressionVisitor = class extends ExpressionVisitor {
   SchemaUtils,
   TransactionIsolationLevel,
   ZenStackClient,
+  createQuerySchemaFactory,
   definePlugin,
   getCrudDialect
 });