@zenstackhq/orm 3.0.0-beta.26 → 3.0.0-beta.27

package/dist/index.cjs

@@ -632,6 +632,7 @@ var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_kysely3 = require("kysely");
 var import_ts_pattern3 = require("ts-pattern");
+var import_zod = __toESM(require("zod"), 1);
 
 // src/client/crud/dialects/base-dialect.ts
 var import_common_helpers2 = require("@zenstackhq/common-helpers");
@@ -1301,6 +1302,10 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "PostgresCrudDialect");
   }
+  isoDateSchema = import_zod.default.iso.datetime({
+    local: true,
+    offset: true
+  });
   constructor(schema, options) {
     super(schema, options);
   }
@@ -1349,7 +1354,12 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   }
   transformOutputDate(value) {
     if (typeof value === "string") {
-      return new Date(value);
+      if (this.isoDateSchema.safeParse(value).success) {
+        const hasOffset = value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
+        return new Date(hasOffset ? value : `${value}Z`);
+      } else {
+        return value;
+      }
     } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
       return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
     } else {
@@ -3631,7 +3641,7 @@ var import_common_helpers7 = require("@zenstackhq/common-helpers");
 var import_decimal4 = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
 var import_ts_pattern13 = require("ts-pattern");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/utils/zod-utils.ts
 var import_v4 = require("zod-validation-error/v4");
@@ -3644,7 +3654,7 @@ __name(formatError, "formatError");
 var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_decimal3 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern12 = require("ts-pattern");
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var import_v3 = require("zod/v3");
 function getArgValue(expr) {
   if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
@@ -3753,13 +3763,13 @@ function addBigIntValidation(schema, attributes) {
 __name(addBigIntValidation, "addBigIntValidation");
 function addDecimalValidation(schema, attributes, addExtraValidation) {
   let result = schema;
-  if (schema instanceof import_zod.z.ZodString) {
+  if (schema instanceof import_zod2.z.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
         new import_decimal3.default(v);
       } catch (err) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
@@ -3767,7 +3777,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
-      const base = import_zod.z.number();
+      const base = import_zod2.z.number();
       const { error } = base[op](value).safeParse(v.toNumber());
       error?.issues.forEach((issue) => {
         if (op === "gt" || op === "gte") {
@@ -3972,7 +3982,7 @@ function evalCall(data, expr) {
     }
     (0, import_common_helpers6.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const fn = (0, import_ts_pattern12.match)(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return import_zod.z.string()[fn]().safeParse(fieldArg).success;
+    return import_zod2.z.string()[fn]().safeParse(fieldArg).success;
   }).with(import_ts_pattern12.P.union("has", "hasEvery", "hasSome"), (f) => {
     (0, import_common_helpers6.invariant)(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
@@ -4110,7 +4120,7 @@ var InputValidator = class {
     if (!options.unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (options.findOne) {
-        fields["take"] = import_zod2.z.literal(1).optional();
+        fields["take"] = import_zod3.z.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
       }
@@ -4118,7 +4128,7 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    let result = import_zod2.z.strictObject(fields);
+    let result = import_zod3.z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4132,19 +4142,19 @@ var InputValidator = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
-        this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
-        this.extraValidationsEnabled ? addBigIntValidation(import_zod2.z.bigint(), attributes) : import_zod2.z.bigint()
+      return (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod3.z.string(), attributes) : import_zod3.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number()).with("Boolean", () => import_zod3.z.boolean()).with("BigInt", () => import_zod3.z.union([
+        this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int(),
+        this.extraValidationsEnabled ? addBigIntValidation(import_zod3.z.bigint(), attributes) : import_zod3.z.bigint()
       ])).with("Decimal", () => {
-        return import_zod2.z.union([
-          this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number(),
-          addDecimalValidation(import_zod2.z.instanceof(import_decimal4.default), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(import_zod2.z.string(), attributes, this.extraValidationsEnabled)
+        return import_zod3.z.union([
+          this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number(),
+          addDecimalValidation(import_zod3.z.instanceof(import_decimal4.default), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(import_zod3.z.string(), attributes, this.extraValidationsEnabled)
         ]);
-      }).with("DateTime", () => import_zod2.z.union([
-        import_zod2.z.date(),
-        import_zod2.z.string().datetime()
-      ])).with("Bytes", () => import_zod2.z.instanceof(Uint8Array)).otherwise(() => import_zod2.z.unknown());
+      }).with("DateTime", () => import_zod3.z.union([
+        import_zod3.z.date(),
+        import_zod3.z.string().datetime()
+      ])).with("Bytes", () => import_zod3.z.instanceof(Uint8Array)).otherwise(() => import_zod3.z.unknown());
     }
   }
   makeEnumSchema(type) {
@@ -4158,7 +4168,7 @@ var InputValidator = class {
     }
     const enumDef = getEnum(this.schema, type);
     (0, import_common_helpers7.invariant)(enumDef, `Enum "${type}" not found in schema`);
-    schema = import_zod2.z.enum(Object.keys(enumDef.values));
+    schema = import_zod3.z.enum(Object.keys(enumDef.values));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4174,7 +4184,7 @@ var InputValidator = class {
     }
     const typeDef = getTypeDef(this.schema, type);
     (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
-    schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    schema = import_zod3.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makePrimitiveSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -4200,21 +4210,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = import_zod3.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4240,7 +4250,7 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = import_zod2.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+          fields[uniqueField.name] = import_zod3.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
             (0, import_common_helpers7.invariant)(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
@@ -4248,7 +4258,7 @@ var InputValidator = class {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
               } else {
-                fieldSchema = import_zod2.z.never();
+                fieldSchema = import_zod3.z.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
@@ -4261,11 +4271,11 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = import_zod2.z.custom((v) => typeof v === "function").optional();
-    fields["AND"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = import_zod2.z.strictObject(fields);
+    fields["$expr"] = import_zod3.z.custom((v) => typeof v === "function").optional();
+    fields["AND"] = this.orArray(import_zod3.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    fields["OR"] = import_zod3.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
+    fields["NOT"] = this.orArray(import_zod3.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    const baseWhere = import_zod3.z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4285,8 +4295,8 @@ var InputValidator = class {
     return result;
   }
   makeEnumFilterSchema(enumDef, optional, withAggregations) {
-    const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+    const baseSchema = import_zod3.z.enum(Object.keys(enumDef.values));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -4296,41 +4306,41 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod2.z.union([
+    return import_zod3.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(components)
+      import_zod3.z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
-    return import_zod2.z.strictObject({
+    return import_zod3.z.strictObject({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
       hasSome: this.makePrimitiveSchema(type).array().optional(),
-      isEmpty: import_zod2.z.boolean().optional()
+      isEmpty: import_zod3.z.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefFilterSchema(type, optional);
     }
-    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod2.z.any()).with("Unsupported", () => import_zod2.z.never()).exhaustive();
+    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod3.z.any()).with("Unsupported", () => import_zod3.z.never()).exhaustive();
   }
   makeTypeDefFilterSchema(_type, _optional) {
-    return import_zod2.z.never();
+    return import_zod3.z.never();
   }
   makeDateTimeFilterSchema(optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod2.z.union([
-      import_zod2.z.string().datetime(),
-      import_zod2.z.date()
-    ]), optional, () => import_zod2.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(import_zod3.z.union([
+      import_zod3.z.string().datetime(),
+      import_zod3.z.date()
+    ]), optional, () => import_zod3.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0);
   }
   makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(import_zod2.z.boolean(), optional, () => import_zod2.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(import_zod3.z.boolean(), optional, () => import_zod3.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -4338,14 +4348,14 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod2.z.union([
-      this.nullableIf(import_zod2.z.boolean(), optional),
-      import_zod2.z.strictObject(components)
+    return import_zod3.z.union([
+      this.nullableIf(import_zod3.z.boolean(), optional),
+      import_zod3.z.strictObject(components)
     ]);
   }
   makeBytesFilterSchema(optional, withAggregations) {
-    const baseSchema = import_zod2.z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.instanceof(Uint8Array), [
+    const baseSchema = import_zod3.z.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -4355,9 +4365,9 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod2.z.union([
+    return import_zod3.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(components)
+      import_zod3.z.strictObject(components)
     ]);
   }
   makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
@@ -4373,7 +4383,7 @@ var InputValidator = class {
       gte: baseSchema.optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(import_zod2.z.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(import_zod3.z.number().int(), false, false).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -4398,13 +4408,13 @@ var InputValidator = class {
     return result;
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return import_zod2.z.union([
+    return import_zod3.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
+      import_zod3.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -4413,17 +4423,17 @@ var InputValidator = class {
     ] : void 0);
   }
   makeStringFilterSchema(optional, withAggregations) {
-    return import_zod2.z.union([
-      this.nullableIf(import_zod2.z.string(), optional),
-      import_zod2.z.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(import_zod2.z.string(), optional, () => import_zod2.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+    return import_zod3.z.union([
+      this.nullableIf(import_zod3.z.string(), optional),
+      import_zod3.z.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(import_zod3.z.string(), optional, () => import_zod3.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
           "_count",
           "_min",
           "_max"
         ] : void 0),
-        startsWith: import_zod2.z.string().optional(),
-        endsWith: import_zod2.z.string().optional(),
-        contains: import_zod2.z.string().optional(),
+        startsWith: import_zod3.z.string().optional(),
+        endsWith: import_zod3.z.string().optional(),
+        contains: import_zod3.z.string().optional(),
         ...this.providerSupportsCaseSensitivity ? {
           mode: this.makeStringModeSchema().optional()
         } : {}
@@ -4431,9 +4441,9 @@ var InputValidator = class {
     ]);
   }
   makeStringModeSchema() {
-    return import_zod2.z.union([
-      import_zod2.z.literal("default"),
-      import_zod2.z.literal("insensitive")
+    return import_zod3.z.union([
+      import_zod3.z.literal("default"),
+      import_zod3.z.literal("insensitive")
     ]);
   }
   makeSelectSchema(model) {
@@ -4444,26 +4454,26 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
       } else {
-        fields[field] = import_zod2.z.boolean().optional();
+        fields[field] = import_zod3.z.boolean().optional();
       }
     }
     const _countSchema = this.makeCountSelectionSchema(modelDef);
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeCountSelectionSchema(modelDef) {
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
-      return import_zod2.z.union([
-        import_zod2.z.literal(true),
-        import_zod2.z.strictObject({
-          select: import_zod2.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      return import_zod3.z.union([
+        import_zod3.z.literal(true),
+        import_zod3.z.strictObject({
+          select: import_zod3.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: import_zod2.z.union([
-              import_zod2.z.boolean(),
-              import_zod2.z.strictObject({
+            [fieldDef.name]: import_zod3.z.union([
+              import_zod3.z.boolean(),
+              import_zod3.z.strictObject({
                 where: this.makeWhereSchema(fieldDef.type, false, false)
               })
             ]).optional()
@@ -4475,17 +4485,17 @@ var InputValidator = class {
     }
   }
   makeRelationSelectIncludeSchema(fieldDef) {
-    let objSchema = import_zod2.z.strictObject({
+    let objSchema = import_zod3.z.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: import_zod3.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
       } : {},
-      select: import_zod2.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: import_zod2.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
-      omit: import_zod2.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+      select: import_zod3.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
+      include: import_zod3.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
+      omit: import_zod3.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: import_zod2.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: import_zod3.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
         skip: this.makeSkipSchema().optional(),
         take: this.makeTakeSchema().optional(),
         cursor: this.makeCursorSchema(fieldDef.type).optional(),
@@ -4494,8 +4504,8 @@ var InputValidator = class {
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
-    return import_zod2.z.union([
-      import_zod2.z.boolean(),
+    return import_zod3.z.union([
+      import_zod3.z.boolean(),
       objSchema
     ]);
   }
@@ -4506,13 +4516,13 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
-          fields[field] = import_zod2.z.boolean().optional();
+          fields[field] = import_zod3.z.boolean().optional();
         } else {
-          fields[field] = import_zod2.z.literal(true).optional();
+          fields[field] = import_zod3.z.literal(true).optional();
         }
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4527,20 +4537,20 @@ var InputValidator = class {
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = import_zod2.z.union([
-      import_zod2.z.literal("asc"),
-      import_zod2.z.literal("desc")
+    const sort = import_zod3.z.union([
+      import_zod3.z.literal("asc"),
+      import_zod3.z.literal("desc")
     ]);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = import_zod2.z.lazy(() => {
+          fields[field] = import_zod3.z.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
@@ -4552,13 +4562,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = import_zod2.z.union([
+          fields[field] = import_zod3.z.union([
             sort,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               sort,
-              nulls: import_zod2.z.union([
-                import_zod2.z.literal("first"),
-                import_zod2.z.literal("last")
+              nulls: import_zod3.z.union([
+                import_zod3.z.literal("first"),
+                import_zod3.z.literal("last")
               ])
             })
           ]).optional();
@@ -4576,15 +4586,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = import_zod2.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = import_zod3.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.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(import_zod2.z.enum(nonRelationFields), true);
+    return this.orArray(import_zod3.z.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -4593,7 +4603,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4643,7 +4653,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
+        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -4669,9 +4679,9 @@ var InputValidator = class {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
           fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -4688,19 +4698,19 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return import_zod2.z.union([
+      return import_zod3.z.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          import_zod2.z.array(uncheckedCreateSchema)
+          import_zod3.z.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          import_zod2.z.array(checkedCreateSchema)
+          import_zod3.z.array(checkedCreateSchema)
         ] : []
       ]);
     }
@@ -4728,11 +4738,11 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(import_zod2.z.strictObject({
+      fields["update"] = array ? this.orArray(import_zod3.z.strictObject({
         where: this.makeWhereSchema(fieldType, true).optional(),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : import_zod2.z.union([
-        import_zod2.z.strictObject({
+      }), true).optional() : import_zod3.z.union([
+        import_zod3.z.strictObject({
           where: this.makeWhereSchema(fieldType, true).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
@@ -4742,21 +4752,21 @@ var InputValidator = class {
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
-      fields["upsert"] = this.orArray(import_zod2.z.strictObject({
+      fields["upsert"] = this.orArray(import_zod3.z.strictObject({
         where: upsertWhere,
         create: this.makeCreateDataSchema(fieldType, false, withoutFields),
         update: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional();
       if (array) {
         fields["set"] = this.makeSetDataSchema(fieldType, true).optional();
-        fields["updateMany"] = this.orArray(import_zod2.z.strictObject({
+        fields["updateMany"] = this.orArray(import_zod3.z.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4768,36 +4778,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return import_zod2.z.union([
-        import_zod2.z.boolean(),
+      return import_zod3.z.union([
+        import_zod3.z.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod2.z.union([
-      import_zod2.z.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod3.z.union([
+      import_zod3.z.boolean(),
       this.makeWhereSchema(model, uniqueFilter)
     ]);
   }
   makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
     const whereSchema = this.makeWhereSchema(model, true);
     const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(import_zod2.z.strictObject({
+    return this.orArray(import_zod3.z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return import_zod2.z.strictObject({
+    return import_zod3.z.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: import_zod2.z.boolean().optional()
+      skipDuplicates: import_zod3.z.boolean().optional()
     });
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
@@ -4809,10 +4819,10 @@ var InputValidator = class {
     return schema;
   }
   makeUpdateManySchema(model) {
-    return import_zod2.z.strictObject({
+    return import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: import_zod2.z.number().int().nonnegative().optional()
+      limit: import_zod3.z.number().int().nonnegative().optional()
     });
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -4825,7 +4835,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -4860,7 +4870,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
+        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -4871,24 +4881,24 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type, fieldDef.attributes);
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.object({
-              set: this.nullableIf(import_zod2.z.number().optional(), !!fieldDef.optional).optional(),
-              increment: import_zod2.z.number().optional(),
-              decrement: import_zod2.z.number().optional(),
-              multiply: import_zod2.z.number().optional(),
-              divide: import_zod2.z.number().optional()
+            import_zod3.z.object({
+              set: this.nullableIf(import_zod3.z.number().optional(), !!fieldDef.optional).optional(),
+              increment: import_zod3.z.number().optional(),
+              decrement: import_zod3.z.number().optional(),
+              multiply: import_zod3.z.number().optional(),
+              divide: import_zod3.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 = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             arraySchema,
-            import_zod2.z.object({
+            import_zod3.z.object({
               set: arraySchema.optional(),
-              push: import_zod2.z.union([
+              push: import_zod3.z.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -4905,12 +4915,12 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return import_zod2.z.union([
+      return import_zod3.z.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -4919,7 +4929,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4930,15 +4940,15 @@ var InputValidator = class {
     return schema;
   }
   makeDeleteManySchema(model) {
-    return import_zod2.z.object({
+    return import_zod3.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: import_zod2.z.number().int().nonnegative().optional()
+      limit: import_zod3.z.number().int().nonnegative().optional()
     }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return import_zod2.z.object({
+    return import_zod3.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4948,12 +4958,12 @@ var InputValidator = class {
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.union([
-      import_zod2.z.literal(true),
-      import_zod2.z.strictObject({
-        _all: import_zod2.z.literal(true).optional(),
+    return import_zod3.z.union([
+      import_zod3.z.literal(true),
+      import_zod3.z.strictObject({
+        _all: import_zod3.z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = import_zod2.z.literal(true).optional();
+          acc[field] = import_zod3.z.literal(true).optional();
           return acc;
         }, {})
       })
@@ -4962,7 +4972,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return import_zod2.z.object({
+    return import_zod3.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4976,20 +4986,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod3.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = import_zod2.z.literal(true).optional();
+        acc[field] = import_zod3.z.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod3.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = import_zod2.z.literal(true).optional();
+        acc[field] = import_zod3.z.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -4997,8 +5007,8 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
-    let schema = import_zod2.z.strictObject({
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod3.z.enum(nonRelationFields), true) : import_zod3.z.never();
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -5065,10 +5075,10 @@ var InputValidator = class {
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return import_zod2.z.number().int().nonnegative();
+    return import_zod3.z.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return import_zod2.z.number().int();
+    return import_zod3.z.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -5080,9 +5090,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? import_zod2.z.union([
+    return canBeArray ? import_zod3.z.union([
       schema,
-      import_zod2.z.array(schema)
+      import_zod3.z.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {