@zenstackhq/orm 3.4.0-beta.3 → 3.4.0

package/dist/index.js

@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
 // src/client/client-impl.ts
-import { invariant as invariant14 } from "@zenstackhq/common-helpers";
+import { invariant as invariant14, lowerCaseFirst as lowerCaseFirst3 } from "@zenstackhq/common-helpers";
 import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql8, Transaction } from "kysely";
 
 // src/client/crud/operations/aggregate.ts
@@ -27,6 +27,7 @@ import { match as match8 } from "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,
@@ -59,7 +60,8 @@ __export(query_utils_exports, {
   requireIdFields: () => requireIdFields,
   requireModel: () => requireModel,
   requireTypeDef: () => requireTypeDef,
-  stripAlias: () => stripAlias
+  stripAlias: () => stripAlias,
+  tmpAlias: () => tmpAlias
 });
 import { invariant } from "@zenstackhq/common-helpers";
 import { AliasNode, ColumnNode, ReferenceNode, TableNode } from "kysely";
@@ -575,6 +577,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
 import { createId as cuid2 } from "@paralleldrive/cuid2";
@@ -851,7 +862,7 @@ var BaseCrudDialect = class {
         });
       }
     }
-    const joinAlias = `${modelAlias}$${field}`;
+    const joinAlias = tmpAlias(`${modelAlias}$${field}`);
     const joinPairs = buildJoinPairs(
       this.schema,
       model,
@@ -860,7 +871,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) {
@@ -893,7 +904,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) {
@@ -1357,7 +1368,7 @@ var BaseCrudDialect = class {
               invariant2(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)))));
@@ -1366,7 +1377,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)))));
@@ -1559,7 +1570,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}`);
   }
@@ -1567,7 +1578,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)) {
@@ -1854,7 +1865,7 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
     ]), "=", this.transformInput(value, "Json", false))).with("array_ends_with", () => this.eb(sql2`JSON_EXTRACT(${lhs}, CONCAT('$[', JSON_LENGTH(${lhs}) - 1, ']'))`, "=", this.transformInput(value, "Json", false))).exhaustive();
   }
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
-    return this.eb.exists(this.eb.selectFrom(sql2`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(sql2`JSON_TABLE(${receiver}, '$[*]' COLUMNS(value JSON PATH '$'))`.as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
   }
   getStringCasingBehavior() {
     return {
@@ -2111,7 +2122,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)) {
@@ -2270,14 +2281,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);
@@ -2301,7 +2312,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 [
               sql4.lit(field),
               subJson
@@ -2309,7 +2320,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 [
                 sql4.lit(field),
                 subJson
@@ -2325,7 +2336,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 [
             sql4.lit(field),
             subJson
@@ -2402,7 +2413,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", [
@@ -2584,7 +2595,7 @@ var BaseOperationHandler = class {
     });
   }
   async existsNonUnique(kysely, model, filter) {
-    const query = kysely.selectNoFrom((eb) => eb.exists(this.dialect.buildSelectModel(model, model).select(sql5.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(sql5.lit(1).as("_")).where(() => this.dialect.buildFilter(model, model, filter))).as("$exists")).modifyEnd(this.makeContextComment({
       model,
       operation: "read"
     }));
@@ -2596,7 +2607,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);
@@ -3193,7 +3204,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) {
@@ -4590,11 +4601,9 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
   }
 };
 
-// src/client/crud/validator/index.ts
-import { enumerate as enumerate3, invariant as invariant9 } from "@zenstackhq/common-helpers";
-import Decimal5 from "decimal.js";
-import { match as match14, P as P3 } from "ts-pattern";
-import { z as z2, ZodType } from "zod";
+// src/client/crud/validator/validator.ts
+import { invariant as invariant9 } from "@zenstackhq/common-helpers";
+import { match as match14 } from "ts-pattern";
 
 // src/utils/zod-utils.ts
 import { fromError } from "zod-validation-error/v4";
@@ -4603,7 +4612,14 @@ function formatError(error) {
 }
 __name(formatError, "formatError");
 
-// src/client/crud/validator/cache-decorator.ts
+// src/client/zod/factory.ts
+import { enumerate as enumerate3, invariant as invariant8, lowerCaseFirst } from "@zenstackhq/common-helpers";
+import { ZodUtils } from "@zenstackhq/zod";
+import Decimal4 from "decimal.js";
+import { match as match13, P as P2 } from "ts-pattern";
+import { z, ZodObject, ZodType } from "zod";
+
+// src/client/zod/cache-decorator.ts
 import stableStringify from "json-stable-stringify";
 function cache() {
   return function(_target, propertyKey, descriptor) {
@@ -4635,371 +4651,7 @@ function cache() {
 }
 __name(cache, "cache");
 
-// src/client/crud/validator/utils.ts
-import { invariant as invariant8 } from "@zenstackhq/common-helpers";
-import Decimal4 from "decimal.js";
-import { match as match13, P as P2 } from "ts-pattern";
-import { z } from "zod";
-import { ZodIssueCode } from "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) {
-    match13(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;
-    }
-    match13(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;
-    }
-    match13(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 z.ZodString) {
-    result = schema.superRefine((v, ctx) => {
-      try {
-        new Decimal4(v);
-      } catch (err) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Invalid decimal: ${err}`
-        });
-      }
-    }).transform((val) => new Decimal4(val));
-  }
-  function refine(schema2, op, value) {
-    return schema2.superRefine((v, ctx) => {
-      const base = z.number();
-      const { error } = base[op](value).safeParse(v.toNumber());
-      error?.issues.forEach((issue) => {
-        if (op === "gt" || op === "gte") {
-          ctx.addIssue({
-            code: ZodIssueCode.too_small,
-            origin: "number",
-            minimum: value,
-            type: "decimal",
-            inclusive: op === "gte",
-            message: issue.message
-          });
-        } else {
-          ctx.addIssue({
-            code: 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;
-      }
-      match13(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) {
-    match13(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 match13(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 match13(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 match13(expr.function).with("length", (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    invariant8(typeof fieldArg === "string" || Array.isArray(fieldArg), `"${f}" first argument must be a string or a list`);
-    return fieldArg.length;
-  }).with(P2.union("startsWith", "endsWith", "contains"), (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    invariant8(typeof fieldArg === "string", `"${f}" first argument must be a string`);
-    invariant8(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) => match13(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;
-    }
-    invariant8(typeof fieldArg === "string", `"${f}" first argument must be a string`);
-    const pattern = getArgValue(expr.args?.[1]);
-    invariant8(pattern !== void 0, `"${f}" requires a pattern argument`);
-    return new RegExp(pattern).test(fieldArg);
-  }).with(P2.union("isEmail", "isUrl", "isDateTime"), (f) => {
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    invariant8(typeof fieldArg === "string", `"${f}" first argument must be a string`);
-    const fn = match13(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return z.string()[fn]().safeParse(fieldArg).success;
-  }).with(P2.union("has", "hasEvery", "hasSome"), (f) => {
-    invariant8(expr.args?.[1], `${f} requires a search argument`);
-    if (fieldArg === void 0 || fieldArg === null) {
-      return false;
-    }
-    invariant8(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
-    const search2 = evalExpression(data, expr.args?.[1]);
-    const matcher = /* @__PURE__ */ __name((x, y) => match13(f).with("has", () => x.some((item) => item === y)).with("hasEvery", () => {
-      invariant8(Array.isArray(y), "hasEvery second argument must be an array");
-      return y.every((v) => x.some((item) => item === v));
-    }).with("hasSome", () => {
-      invariant8(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;
-    }
-    invariant8(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);
@@ -5011,317 +4663,199 @@ 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);
+    return this.options.validateInput !== false;
   }
-  validateExistsArgs(model, args) {
-    return this.validate(model, "exists", (model2) => this.makeExistsSchema(model2), args);
-  }
-  validateCreateArgs(model, args) {
-    return this.validate(model, "create", (model2) => this.makeCreateSchema(model2), args);
+  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"] = 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 = 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 = 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 match13(type).with("String", () => this.extraValidationsEnabled ? ZodUtils.addStringValidation(z.string(), attributes) : z.string()).with("Int", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int()).with("Float", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number(), attributes) : z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([
+        this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int(),
+        this.extraValidationsEnabled ? ZodUtils.addBigIntValidation(z.bigint(), attributes) : z.bigint()
+      ])).with("Decimal", () => {
+        return z.union([
+          this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number(), attributes) : z.number(),
+          ZodUtils.addDecimalValidation(z.instanceof(Decimal4), attributes, this.extraValidationsEnabled),
+          ZodUtils.addDecimalValidation(z.string(), attributes, this.extraValidationsEnabled)
+        ]);
+      }).with("DateTime", () => z.union([
+        z.date(),
+        z.iso.datetime()
+      ])).with("Bytes", () => z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => z.unknown());
+    }
   }
-  validateGroupByArgs(model, args) {
-    return this.validate(model, "groupBy", (model2) => this.makeGroupBySchema(model2), args);
+  makeEnumSchema(_enum) {
+    const enumDef = getEnum(this.schema, _enum);
+    invariant8(enumDef, `Enum "${_enum}" not found in schema`);
+    return z.enum(Object.keys(enumDef.values));
   }
-  // TODO: turn it into a Zod schema and cache
-  validateProcedureInput(proc, input) {
-    const procDef = (this.schema.procedures ?? {})[proc];
-    invariant9(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);
+    invariant8(typeDef, `Type definition "${type}" not found in schema`);
+    const schema = 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;
+      return [
+        field,
+        fieldSchema
+      ];
+    })));
+    const finalSchema = z.any().superRefine((value, ctx) => {
+      const parseResult = schema.safeParse(value);
+      if (!parseResult.success) {
+        parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
       }
-      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) {
-        invariant9(createSchema instanceof z2.ZodObject, "Plugin extended query args schema must be a Zod object");
-        invariant9(updateSchema instanceof z2.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"];
-    }
-    invariant9(result === void 0 || result instanceof z2.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"] = z2.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 = z2.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 = z2.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 match14(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(z2.string(), attributes) : z2.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number()).with("Boolean", () => z2.boolean()).with("BigInt", () => z2.union([
-        this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int(),
-        this.extraValidationsEnabled ? addBigIntValidation(z2.bigint(), attributes) : z2.bigint()
-      ])).with("Decimal", () => {
-        return z2.union([
-          this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number(),
-          addDecimalValidation(z2.instanceof(Decimal5), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(z2.string(), attributes, this.extraValidationsEnabled)
-        ]);
-      }).with("DateTime", () => z2.union([
-        z2.date(),
-        z2.iso.datetime()
-      ])).with("Bytes", () => z2.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => z2.unknown());
-    }
-  }
-  makeEnumSchema(type) {
-    const enumDef = getEnum(this.schema, type);
-    invariant9(enumDef, `Enum "${type}" not found in schema`);
-    return z2.enum(Object.keys(enumDef.values));
-  }
-  makeTypeDefSchema(type) {
-    const typeDef = getTypeDef(this.schema, type);
-    invariant9(typeDef, `Type definition "${type}" not found in schema`);
-    const schema = z2.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 = z2.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) {
-    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 fields = {};
-    for (const field of Object.keys(modelDef.fields)) {
-      const fieldDef = requireField(this.schema, model, field);
-      let fieldSchema;
-      if (fieldDef.relation) {
-        if (withoutRelationFields) {
+    });
+    return finalSchema;
+  }
+  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 || !this.shouldIncludeRelations(options)) {
           continue;
         }
         const allowedFilterKinds = this.getEffectiveFilterKinds(model, field);
         if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) {
-          fieldSchema = z2.never();
+          fieldSchema = z.never();
         } else {
-          fieldSchema = z2.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+          fieldSchema = z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts).optional());
           fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
           if (fieldDef.array) {
-            fieldSchema = z2.union([
+            fieldSchema = z.union([
               fieldSchema,
-              z2.strictObject({
+              z.strictObject({
                 some: fieldSchema.optional(),
                 every: fieldSchema.optional(),
                 none: fieldSchema.optional()
               })
             ]);
           } else {
-            fieldSchema = z2.union([
+            fieldSchema = z.union([
               fieldSchema,
-              z2.strictObject({
+              z.strictObject({
                 is: fieldSchema.optional(),
                 isNot: fieldSchema.optional()
               })
@@ -5351,15 +4885,15 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = z2.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
-            invariant9(!def.relation, "unique field cannot be a relation");
+          fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+            invariant8(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(model, def, false, true);
               } else {
-                fieldSchema = z2.never();
+                fieldSchema = z.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(model, def, false, true);
@@ -5372,13 +4906,13 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = z2.custom((v) => typeof v === "function", {
+    fields["$expr"] = z.custom((v) => typeof v === "function", {
       error: '"$expr" must be a function'
     }).optional();
-    fields["AND"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = z2.strictObject(fields);
+    fields["AND"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
+    fields["OR"] = z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)).array().optional();
+    fields["NOT"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
+    const baseWhere = z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -5403,7 +4937,7 @@ var InputValidator = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const typeDef = getTypeDef(this.schema, type);
-    invariant9(typeDef, `Type definition "${type}" not found in schema`);
+    invariant8(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
     if (!array) {
       const fieldSchemas = {};
@@ -5421,31 +4955,31 @@ var InputValidator = class {
           }
         }
       }
-      candidates.push(z2.strictObject(fieldSchemas));
+      candidates.push(z.strictObject(fieldSchemas));
     }
-    const recursiveSchema = z2.lazy(() => this.makeTypedJsonFilterSchema(contextModel, {
+    const recursiveSchema = z.lazy(() => this.makeTypedJsonFilterSchema(contextModel, {
       name: field,
       type,
       optional,
       array: false
     })).optional();
     if (array) {
-      candidates.push(z2.strictObject({
+      candidates.push(z.strictObject({
         some: recursiveSchema,
         every: recursiveSchema,
         none: recursiveSchema
       }));
     } else {
-      candidates.push(z2.strictObject({
+      candidates.push(z.strictObject({
         is: recursiveSchema,
         isNot: recursiveSchema
       }));
     }
     candidates.push(this.makeJsonFilterSchema(contextModel, field, optional));
     if (optional) {
-      candidates.push(z2.null());
+      candidates.push(z.null());
     }
-    return z2.union(candidates);
+    return z.union(candidates);
   }
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
@@ -5455,13 +4989,13 @@ var InputValidator = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const enumDef = getEnum(this.schema, enumName);
-    invariant9(enumDef, `Enum "${enumName}" not found in schema`);
-    const baseSchema = z2.enum(Object.keys(enumDef.values));
+    invariant8(enumDef, `Enum "${enumName}" not found in schema`);
+    const baseSchema = z.enum(Object.keys(enumDef.values));
     if (array) {
       return this.internalMakeArrayFilterSchema(model, fieldInfo.name, baseSchema);
     }
     const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(model, fieldInfo.name);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(model, fieldInfo, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.lazy(() => this.makeEnumFilterSchema(model, fieldInfo, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -5483,43 +5017,43 @@ var InputValidator = class {
       has: elementSchema.optional(),
       hasEvery: elementSchema.array().optional(),
       hasSome: elementSchema.array().optional(),
-      isEmpty: z2.boolean().optional()
+      isEmpty: z.boolean().optional()
     };
     const filteredOperators = this.trimFilterOperators(operators, allowedFilterKinds);
-    return z2.strictObject(filteredOperators);
+    return z.strictObject(filteredOperators);
   }
   makePrimitiveFilterSchema(contextModel, fieldInfo, withAggregations, ignoreSlicing = false) {
     const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(contextModel, fieldInfo.name);
     const type = fieldInfo.type;
     const optional = !!fieldInfo.optional;
-    return match14(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P3.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", () => z2.never()).exhaustive();
+    return match13(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P2.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", () => z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
-      z2.string(),
-      z2.number(),
-      z2.boolean(),
-      z2.instanceof(JsonNullClass)
+      z.string(),
+      z.number(),
+      z.boolean(),
+      z.instanceof(JsonNullClass)
     ];
     if (forFilter) {
-      options.push(z2.instanceof(DbNullClass));
+      options.push(z.instanceof(DbNullClass));
     } else {
       if (nullable) {
-        options.push(z2.instanceof(DbNullClass));
+        options.push(z.instanceof(DbNullClass));
       }
     }
     if (forFilter) {
-      options.push(z2.instanceof(AnyNullClass));
+      options.push(z.instanceof(AnyNullClass));
     }
-    const schema = z2.union([
+    const schema = z.union([
       ...options,
-      z2.lazy(() => z2.union([
+      z.lazy(() => z.union([
         this.makeJsonValueSchema(false, false),
-        z2.null()
+        z.null()
       ]).array()),
-      z2.record(z2.string(), z2.lazy(() => z2.union([
+      z.record(z.string(), z.lazy(() => z.union([
         this.makeJsonValueSchema(false, false),
-        z2.null()
+        z.null()
       ])))
     ]);
     return this.nullableIf(schema, nullable);
@@ -5527,16 +5061,16 @@ var InputValidator = class {
   makeJsonFilterSchema(contextModel, field, optional) {
     const allowedFilterKinds = this.getEffectiveFilterKinds(contextModel, field);
     if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) {
-      return z2.never();
+      return z.never();
     }
     const valueSchema = this.makeJsonValueSchema(optional, true);
-    return z2.strictObject({
-      path: z2.string().optional(),
+    return z.strictObject({
+      path: z.string().optional(),
       equals: valueSchema.optional(),
       not: valueSchema.optional(),
-      string_contains: z2.string().optional(),
-      string_starts_with: z2.string().optional(),
-      string_ends_with: z2.string().optional(),
+      string_contains: z.string().optional(),
+      string_starts_with: z.string().optional(),
+      string_ends_with: z.string().optional(),
       mode: this.makeStringModeSchema().optional(),
       array_contains: valueSchema.optional(),
       array_starts_with: valueSchema.optional(),
@@ -5544,17 +5078,17 @@ var InputValidator = class {
     });
   }
   makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds) {
-    return this.makeCommonPrimitiveFilterSchema(z2.union([
-      z2.iso.datetime(),
-      z2.date()
-    ]), optional, () => z2.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(z.union([
+      z.iso.datetime(),
+      z.date()
+    ]), optional, () => z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0, allowedFilterKinds);
   }
   makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds) {
-    const components = this.makeCommonPrimitiveFilterComponents(z2.boolean(), optional, () => z2.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), [
+    const components = this.makeCommonPrimitiveFilterComponents(z.boolean(), optional, () => z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -5562,11 +5096,11 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0, allowedFilterKinds);
-    return this.createUnionFilterSchema(z2.boolean(), optional, components, allowedFilterKinds);
+    return this.createUnionFilterSchema(z.boolean(), optional, components, allowedFilterKinds);
   }
   makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds) {
-    const baseSchema = z2.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.instanceof(Uint8Array), [
+    const baseSchema = z.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -5591,7 +5125,7 @@ var InputValidator = class {
       between: baseSchema.array().length(2).optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(z2.number().int(), false, false, void 0).optional()
+        _count: this.makeNumberFilterSchema(z.number().int(), false, false, void 0).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -5621,7 +5155,7 @@ var InputValidator = class {
     return this.createUnionFilterSchema(baseSchema, optional, components, allowedFilterKinds);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z2.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -5630,15 +5164,15 @@ var InputValidator = class {
     ] : void 0, allowedFilterKinds);
   }
   makeStringFilterSchema(optional, withAggregations, allowedFilterKinds) {
-    const baseComponents = this.makeCommonPrimitiveFilterComponents(z2.string(), optional, () => z2.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)), void 0, withAggregations ? [
+    const baseComponents = this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)), void 0, withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0, allowedFilterKinds);
     const stringSpecificOperators = {
-      startsWith: z2.string().optional(),
-      endsWith: z2.string().optional(),
-      contains: z2.string().optional(),
+      startsWith: z.string().optional(),
+      endsWith: z.string().optional(),
+      contains: z.string().optional(),
       ...this.providerSupportsCaseSensitivity ? {
         mode: this.makeStringModeSchema().optional()
       } : {}
@@ -5648,78 +5182,86 @@ var InputValidator = class {
       ...baseComponents,
       ...filteredStringOperators
     };
-    return this.createUnionFilterSchema(z2.string(), optional, allComponents, allowedFilterKinds);
+    return this.createUnionFilterSchema(z.string(), optional, allComponents, allowedFilterKinds);
   }
   makeStringModeSchema() {
-    return z2.union([
-      z2.literal("default"),
-      z2.literal("insensitive")
+    return z.union([
+      z.literal("default"),
+      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] = z2.boolean().optional();
+        fields[field] = z.boolean().optional();
       }
     }
-    const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof z2.ZodNever)) {
-      fields["_count"] = _countSchema;
+    if (this.shouldIncludeRelations(options)) {
+      const _countSchema = this.makeCountSelectionSchema(model, options);
+      if (!(_countSchema instanceof z.ZodNever)) {
+        fields["_count"] = _countSchema;
+      }
     }
-    return z2.strictObject(fields);
+    return 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) {
-      return z2.union([
-        z2.literal(true),
-        z2.strictObject({
-          select: z2.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      const nextOpts = this.nextOptions(options);
+      return z.union([
+        z.literal(true),
+        z.strictObject({
+          select: z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: z2.union([
-              z2.boolean(),
-              z2.strictObject({
-                where: this.makeWhereSchema(fieldDef.type, false, false)
+            [fieldDef.name]: z.union([
+              z.boolean(),
+              z.strictObject({
+                where: this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts)
               })
             ]).optional()
           }), {}))
         })
       ]).optional();
     } else {
-      return z2.never();
+      return z.never();
     }
   }
-  makeRelationSelectIncludeSchema(model, field) {
+  makeRelationSelectIncludeSchema(model, field, options) {
     const fieldDef = requireField(this.schema, model, field);
-    let objSchema = z2.strictObject({
+    const nextOpts = this.nextOptions(options);
+    let objSchema = z.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: z2.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts)).optional()
       } : {},
-      select: z2.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: z2.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
-      omit: z2.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+      select: z.lazy(() => this.makeSelectSchema(fieldDef.type, nextOpts)).optional().nullable(),
+      include: z.lazy(() => this.makeIncludeSchema(fieldDef.type, nextOpts)).optional().nullable(),
+      omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: z2.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: 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);
-    return z2.union([
-      z2.boolean(),
+    objSchema = this.refineForSelectHasTruthyField(objSchema);
+    return z.union([
+      z.boolean(),
       objSchema
     ]);
   }
@@ -5730,44 +5272,50 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
-          fields[field] = z2.boolean().optional();
+          fields[field] = z.boolean().optional();
         } else {
-          fields[field] = z2.literal(true).optional();
+          fields[field] = z.literal(true).optional();
         }
       }
     }
-    return z2.strictObject(fields);
+    return 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 z2.ZodNever)) {
-      fields["_count"] = _countSchema;
+    if (this.shouldIncludeRelations(options)) {
+      const _countSchema = this.makeCountSelectionSchema(model, options);
+      if (!(_countSchema instanceof z.ZodNever)) {
+        fields["_count"] = _countSchema;
+      }
     }
-    return z2.strictObject(fields);
+    return z.strictObject(fields);
   }
-  makeOrderBySchema(model, withRelation, WithAggregation) {
+  makeOrderBySchema(model, withRelation, WithAggregation, options) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = z2.union([
-      z2.literal("asc"),
-      z2.literal("desc")
+    const sort = z.union([
+      z.literal("asc"),
+      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) {
-          fields[field] = z2.lazy(() => {
-            let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
+        if (withRelation && this.shouldIncludeRelations(options)) {
+          fields[field] = z.lazy(() => {
+            let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation, nextOpts);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
                 _count: sort
@@ -5778,13 +5326,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = z2.union([
+          fields[field] = z.union([
             sort,
-            z2.strictObject({
+            z.strictObject({
               sort,
-              nulls: z2.union([
-                z2.literal("first"),
-                z2.literal("last")
+              nulls: z.union([
+                z.literal("first"),
+                z.literal("last")
               ])
             })
           ]).optional();
@@ -5802,64 +5350,64 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = z2.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = z.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
       }
     }
-    return z2.strictObject(fields);
+    return z.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    return this.orArray(z2.enum(nonRelationFields), true);
+    return nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : 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);
-    const baseSchema = z2.strictObject({
+  makeCreateSchema(model, options) {
+    const dataSchema = this.makeCreateDataSchema(model, false, [], false, options);
+    const baseSchema = 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)) {
@@ -5874,7 +5422,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
+        let fieldSchema = z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create", nextOpts));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -5899,10 +5447,10 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
-          fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = z2.union([
+          fieldSchema = ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
+          fieldSchema = z.union([
             fieldSchema,
-            z2.strictObject({
+            z.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -5912,9 +5460,9 @@ var InputValidator = class {
         }
         if (fieldDef.optional) {
           if (fieldDef.type === "Json") {
-            fieldSchema = z2.union([
+            fieldSchema = z.union([
               fieldSchema,
-              z2.instanceof(DbNullClass)
+              z.instanceof(DbNullClass)
             ]);
           } else {
             fieldSchema = fieldSchema.nullable();
@@ -5926,170 +5474,171 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(uncheckedVariantFields), modelDef.attributes) : z.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(checkedVariantFields), modelDef.attributes) : z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return z2.union([
+      return z.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          z2.array(uncheckedCreateSchema)
+          z.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          z2.array(checkedCreateSchema)
+          z.array(checkedCreateSchema)
         ] : []
       ]);
     }
   }
-  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["update"] = array ? this.orArray(z2.strictObject({
-        where: this.makeWhereSchema(fieldType, true),
-        data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : z2.union([
-        z2.strictObject({
-          where: this.makeWhereSchema(fieldType, false).optional(),
-          data: this.makeUpdateDataSchema(fieldType, withoutFields)
+        fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array, options).optional();
+        fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true, options).optional();
+      }
+      fields["update"] = array ? this.orArray(z.strictObject({
+        where: this.makeWhereSchema(fieldType, true, false, false, options),
+        data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
+      }), true).optional() : z.union([
+        z.strictObject({
+          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(z2.strictObject({
+      fields["upsert"] = this.orArray(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["updateMany"] = this.orArray(z2.strictObject({
-          where: this.makeWhereSchema(fieldType, false, true),
-          data: this.makeUpdateDataSchema(fieldType, withoutFields)
+        fields["set"] = this.makeSetDataSchema(fieldType, true, options).optional();
+        fields["updateMany"] = this.orArray(z.strictObject({
+          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 z2.strictObject(fields);
+    return 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 z2.union([
-        z2.boolean(),
-        this.makeWhereSchema(model, false)
+      return z.union([
+        z.boolean(),
+        this.makeWhereSchema(model, false, false, false, options)
       ]);
     }
   }
-  makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z2.union([
-      z2.boolean(),
-      this.makeWhereSchema(model, uniqueFilter)
+  makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter, options) {
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter, false, false, options), true) : z.union([
+      z.boolean(),
+      this.makeWhereSchema(model, uniqueFilter, false, false, options)
     ]);
   }
-  makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
-    const whereSchema = this.makeWhereSchema(model, true);
-    const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(z2.strictObject({
+  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(z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
-  makeCreateManyDataSchema(model, withoutFields) {
-    return z2.strictObject({
-      data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: z2.boolean().optional()
+  makeCreateManyPayloadSchema(model, withoutFields, options) {
+    return z.strictObject({
+      data: this.makeCreateDataSchema(model, true, withoutFields, true, options),
+      skipDuplicates: z.boolean().optional()
     });
   }
   // #endregion
   // #region Update
-  makeUpdateSchema(model) {
-    const baseSchema = z2.strictObject({
-      where: this.makeWhereSchema(model, true),
-      data: this.makeUpdateDataSchema(model),
-      select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable(),
+  makeUpdateSchema(model, options) {
+    const baseSchema = z.strictObject({
+      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) {
-    return this.mergePluginArgsSchema(z2.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
-      data: this.makeUpdateDataSchema(model, [], true),
-      limit: z2.number().int().nonnegative().optional()
+  makeUpdateManySchema(model, options) {
+    return this.mergePluginArgsSchema(z.strictObject({
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
+      data: this.makeUpdateDataSchema(model, [], true, options),
+      limit: 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) {
-    const baseSchema = z2.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(),
+  makeUpsertSchema(model, options) {
+    const baseSchema = z.strictObject({
+      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)) {
@@ -6104,7 +5653,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
+        let fieldSchema = z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update", nextOpts)).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -6115,24 +5664,25 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = z2.union([
+          fieldSchema = z.union([
             fieldSchema,
-            z2.object({
-              set: this.nullableIf(z2.number().optional(), !!fieldDef.optional).optional(),
-              increment: z2.number().optional(),
-              decrement: z2.number().optional(),
-              multiply: z2.number().optional(),
-              divide: z2.number().optional()
+            z.object({
+              // TODO: use Decimal/BigInt for incremental updates
+              set: this.nullableIf(z.number().optional(), !!fieldDef.optional).optional(),
+              increment: z.number().optional(),
+              decrement: z.number().optional(),
+              multiply: z.number().optional(),
+              divide: z.number().optional()
             }).refine((v) => Object.keys(v).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided')
           ]);
         }
         if (fieldDef.array) {
-          const arraySchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = z2.union([
+          const arraySchema = ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
+          fieldSchema = z.union([
             arraySchema,
-            z2.object({
+            z.object({
               set: arraySchema.optional(),
-              push: z2.union([
+              push: z.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -6141,9 +5691,9 @@ var InputValidator = class {
         }
         if (fieldDef.optional) {
           if (fieldDef.type === "Json") {
-            fieldSchema = z2.union([
+            fieldSchema = z.union([
               fieldSchema,
-              z2.instanceof(DbNullClass)
+              z.instanceof(DbNullClass)
             ]);
           } else {
             fieldSchema = fieldSchema.nullable();
@@ -6156,12 +5706,12 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(uncheckedVariantFields), modelDef.attributes) : z.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(checkedVariantFields), modelDef.attributes) : z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return z2.union([
+      return z.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -6169,43 +5719,44 @@ var InputValidator = class {
   }
   // #endregion
   // #region Delete
-  makeDeleteSchema(model) {
-    const baseSchema = z2.strictObject({
-      where: this.makeWhereSchema(model, true),
-      select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable(),
+  makeDeleteSchema(model, options) {
+    const baseSchema = z.strictObject({
+      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) {
-    return this.mergePluginArgsSchema(z2.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
-      limit: z2.number().int().nonnegative().optional()
+  makeDeleteManySchema(model, options) {
+    return this.mergePluginArgsSchema(z.strictObject({
+      where: this.makeWhereSchema(model, false, false, false, options).optional(),
+      limit: z.number().int().nonnegative().optional()
     }), "deleteMany").optional();
   }
   // #endregion
   // #region Count
-  makeCountSchema(model) {
-    return this.mergePluginArgsSchema(z2.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
+  makeCountSchema(model, options) {
+    return this.mergePluginArgsSchema(z.strictObject({
+      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();
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.union([
-      z2.literal(true),
-      z2.strictObject({
-        _all: z2.literal(true).optional(),
+    return z.union([
+      z.literal(true),
+      z.strictObject({
+        _all: z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = z2.literal(true).optional();
+          acc[field] = z.literal(true).optional();
           return acc;
         }, {})
       })
@@ -6213,12 +5764,12 @@ var InputValidator = class {
   }
   // #endregion
   // #region Aggregate
-  makeAggregateSchema(model) {
-    return this.mergePluginArgsSchema(z2.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
+  makeAggregateSchema(model, options) {
+    return this.mergePluginArgsSchema(z.strictObject({
+      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(),
@@ -6228,33 +5779,35 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = z2.literal(true).optional();
+        acc[field] = z.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = z2.literal(true).optional();
+        acc[field] = z.literal(true).optional();
       }
       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(z2.enum(nonRelationFields), true) : z2.never();
-    const baseSchema = z2.strictObject({
-      where: this.makeWhereSchema(model, false).optional(),
-      orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : z.never();
+    const baseSchema = z.strictObject({
+      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(),
@@ -6265,9 +5818,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 = enumerate3(value.by);
       if (value.having && typeof value.having === "object") {
         for (const [key, val] of Object.entries(value.having)) {
           if (AggregateOperators.includes(key)) {
@@ -6287,14 +5838,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 = enumerate3(value.by);
+      for (const orderBy of enumerate3(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;
   }
@@ -6312,22 +5862,22 @@ 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);
     } else if (isEnum(this.schema, param.type)) {
       schema = this.makeEnumSchema(param.type);
     } else if (param.type in (this.schema.models ?? {})) {
-      schema = z2.record(z2.string(), z2.unknown());
+      schema = z.record(z.string(), z.unknown());
     } else {
       schema = this.makeScalarSchema(param.type);
-      if (schema instanceof z2.ZodUnknown) {
+      if (schema instanceof z.ZodUnknown) {
         throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
       }
     }
@@ -6340,29 +5890,62 @@ 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) {
+        invariant8(createSchema instanceof ZodObject, "Plugin extended query args schema must be a Zod object");
+        invariant8(updateSchema instanceof 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"];
     }
+    invariant8(result === void 0 || result instanceof ZodObject, "Plugin extended query args schema must be a Zod object");
+    return result;
   }
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return z2.number().int().nonnegative();
+    return z.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return z2.number().int();
+    return z.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -6370,13 +5953,22 @@ 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;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? z2.union([
+    return canBeArray ? z.union([
       schema,
-      z2.array(schema)
+      z.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -6387,7 +5979,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) {
@@ -6397,21 +5989,27 @@ var InputValidator = class {
     if (!slicing?.models) {
       return void 0;
     }
-    const modelConfig = slicing.models[model];
+    const modelsRecord = slicing.models;
+    const modelConfig = modelsRecord[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;
@@ -6454,15 +6052,15 @@ var InputValidator = class {
       if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) {
         return this.nullableIf(valueSchema, optional);
       }
-      return z2.never();
+      return z.never();
     }
     if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) {
-      return z2.union([
+      return z.union([
         this.nullableIf(valueSchema, optional),
-        z2.strictObject(components)
+        z.strictObject(components)
       ]);
     } else {
-      return z2.strictObject(components);
+      return z.strictObject(components);
     }
   }
   /**
@@ -6493,18 +6091,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 ZodType === "undefined" ? Object : ZodType)
+], ZodSchemaFactory.prototype, "makeExistsSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6512,15 +6112,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 z2 === "undefined" || typeof z2.ZodType === "undefined" ? Object : z2.ZodType)
-], InputValidator.prototype, "makeTypeDefSchema", null);
+  _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
+], ZodSchemaFactory.prototype, "makeTypeDefSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6528,10 +6128,11 @@ _ts_decorate([
     String,
     Boolean,
     void 0,
-    void 0
+    void 0,
+    typeof CreateSchemaOptions === "undefined" ? Object : CreateSchemaOptions
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
-], InputValidator.prototype, "makeWhereSchema", null);
+], ZodSchemaFactory.prototype, "makeWhereSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6540,7 +6141,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),
@@ -6551,7 +6152,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),
@@ -6560,7 +6161,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),
@@ -6571,7 +6172,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),
@@ -6581,7 +6182,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),
@@ -6591,7 +6192,7 @@ _ts_decorate([
     Object
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
-], InputValidator.prototype, "makeDateTimeFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeDateTimeFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6601,7 +6202,7 @@ _ts_decorate([
     Object
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
-], InputValidator.prototype, "makeBooleanFilterSchema", null);
+], ZodSchemaFactory.prototype, "makeBooleanFilterSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6611,32 +6212,35 @@ _ts_decorate([
     Object
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : 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),
@@ -6644,25 +6248,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),
@@ -6670,31 +6276,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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : ZodType)
+], ZodSchemaFactory.prototype, "makeCreateManyAndReturnSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6702,10 +6311,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),
@@ -6713,132 +6323,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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : 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 ZodType === "undefined" ? Object : ZodType)
+], ZodSchemaFactory.prototype, "makeCountSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6846,15 +6471,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 ZodType === "undefined" ? Object : ZodType)
+], ZodSchemaFactory.prototype, "makeAggregateSchema", null);
 _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
@@ -6862,7 +6488,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),
@@ -6870,35 +6496,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 ZodType === "undefined" ? Object : 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 z2 === "undefined" || typeof z2.ZodType === "undefined" ? Object : z2.ZodType)
-], InputValidator.prototype, "makeProcedureParamSchema", null);
+  _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : 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) => match14(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];
+    invariant9(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 {
@@ -7673,6 +7432,30 @@ var QueryNameMapper = class extends OperationNodeTransformer {
   }
 };
 
+// src/client/executor/temp-alias-transformer.ts
+import { IdentifierNode as IdentifierNode2, OperationNodeTransformer as OperationNodeTransformer2 } from "kysely";
+var TempAliasTransformer = class extends OperationNodeTransformer2 {
+  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 IdentifierNode2.create(mapped);
+    }
+    return super.transformIdentifier(node, queryId);
+  }
+};
+
 // src/client/executor/zenstack-query-executor.ts
 var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExecutor {
   static {
@@ -8049,9 +7832,21 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
       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 SingleConnectionProvider(connection));
     innerExecutor.suppressMutationHooks = true;
@@ -8071,7 +7866,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     }
   }
   async internalExecuteQuery(query, connection, queryId, parameters) {
-    const finalQuery = this.processNameMapping(query);
+    const finalQuery = this.processQueryNode(query);
     let compiledQuery = this.compileQuery(finalQuery, queryId ?? createQueryId2());
     if (parameters) {
       compiledQuery = {
@@ -8141,7 +7936,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-import { invariant as invariant12, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
+import { invariant as invariant12, lowerCaseFirst as lowerCaseFirst2, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { sql as sql6, ValueNode as ValueNode3 } from "kysely";
 import { match as match16 } from "ts-pattern";
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
@@ -8252,7 +8047,7 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
   invariant12(ValueNode3.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = match16(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst(result)).otherwise(() => {
+  result = match16(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => upperCaseFirst(result)).with("uncapitalize", () => lowerCaseFirst2(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -8802,6 +8597,9 @@ var ClientImpl = class _ClientImpl {
   get $qbRaw() {
     return this.kyselyRaw;
   }
+  get $zod() {
+    return this.inputValidator.zodFactory;
+  }
   get isTransaction() {
     return this.kysely.isTransaction;
   }
@@ -9208,7 +9006,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
   const slicing = client.$options.slicing;
   if (slicing?.models) {
-    const modelSlicing = slicing.models[model];
+    const modelSlicing = slicing.models[lowerCaseFirst3(model)];
     const allSlicing = slicing.models.$all;
     const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
     const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;
@@ -9678,6 +9476,7 @@ export {
   schema_utils_exports as SchemaUtils,
   TransactionIsolationLevel,
   ZenStackClient,
+  createQuerySchemaFactory,
   definePlugin,
   getCrudDialect
 };