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

package/dist/index.cjs

@@ -956,24 +956,31 @@ var BaseCrudDialect = class {
       if (_value === void 0) {
         continue;
       }
-      const value = this.transformInput(_value, fieldType, !!fieldDef.array);
+      (0, import_common_helpers2.invariant)(fieldDef.array, "Field must be an array type to build array filter");
+      const value = this.transformInput(_value, fieldType, true);
+      let receiver = fieldRef;
+      if (isEnum(this.schema, fieldType)) {
+        receiver = this.eb.cast(fieldRef, import_kysely2.sql.raw("text[]"));
+      }
+      const buildArray = /* @__PURE__ */ __name((value2) => {
+        (0, import_common_helpers2.invariant)(Array.isArray(value2), "Array filter value must be an array");
+        return this.buildArrayValue(value2.map((v) => this.eb.val(v)), fieldType);
+      }, "buildArray");
       switch (key) {
         case "equals": {
-          clauses.push(this.buildLiteralFilter(fieldRef, fieldType, this.eb.val(value)));
+          clauses.push(this.eb(receiver, "=", buildArray(value)));
           break;
         }
         case "has": {
-          clauses.push(this.eb(fieldRef, "@>", this.eb.val([
-            value
-          ])));
+          clauses.push(this.buildArrayContains(receiver, this.eb.val(value)));
           break;
         }
         case "hasEvery": {
-          clauses.push(this.eb(fieldRef, "@>", this.eb.val(value)));
+          clauses.push(this.buildArrayHasEvery(receiver, buildArray(value)));
           break;
         }
         case "hasSome": {
-          clauses.push(this.eb(fieldRef, "&&", this.eb.val(value)));
+          clauses.push(this.buildArrayHasSome(receiver, buildArray(value)));
           break;
         }
         case "isEmpty": {
@@ -1809,8 +1816,17 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
       array
     ]);
   }
-  buildArrayLiteralSQL(_values) {
-    throw new Error("MySQL does not support array literals");
+  buildArrayValue(values, _elemType) {
+    return new import_kysely3.ExpressionWrapper(import_kysely3.ValueListNode.create(values.map((v) => v.toOperationNode())));
+  }
+  buildArrayContains(_field, _value) {
+    throw createNotSupportedError("MySQL does not support native array operations");
+  }
+  buildArrayHasEvery(_field, _values) {
+    throw createNotSupportedError("MySQL does not support native array operations");
+  }
+  buildArrayHasSome(_field, _values) {
+    throw createNotSupportedError("MySQL does not support native array operations");
   }
   buildJsonEqualityFilter(lhs, rhs) {
     return this.eb.and([
@@ -1848,21 +1864,6 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(import_kysely3.sql`JSON_TABLE(${receiver}, '$[*]' COLUMNS(value JSON PATH '$'))`.as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  getFieldSqlType(fieldDef) {
-    if (fieldDef.relation) {
-      throw createInternalError("Cannot get SQL type of a relation field");
-    }
-    let result;
-    if (this.schema.enums?.[fieldDef.type]) {
-      result = "varchar(255)";
-    } else {
-      result = (0, import_ts_pattern3.match)(fieldDef.type).with("String", () => "varchar(255)").with("Boolean", () => "tinyint(1)").with("Int", () => "int").with("BigInt", () => "bigint").with("Float", () => "double").with("Decimal", () => "decimal").with("DateTime", () => "datetime").with("Bytes", () => "blob").with("Json", () => "json").otherwise(() => "text");
-    }
-    if (fieldDef.array) {
-      result = "json";
-    }
-    return result;
-  }
   getStringCasingBehavior() {
     return {
       supportsILike: false,
@@ -1902,21 +1903,36 @@ var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_kysely4 = require("kysely");
 var import_postgres_array = require("postgres-array");
 var import_ts_pattern4 = require("ts-pattern");
-var import_zod = __toESM(require("zod"), 1);
-var PostgresCrudDialect = class extends LateralJoinDialectBase {
+var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectBase {
   static {
     __name(this, "PostgresCrudDialect");
   }
-  isoDateSchema = import_zod.default.iso.datetime({
-    local: true,
-    offset: true
-  });
+  static typeParserOverrideApplied = false;
   constructor(schema, options) {
     super(schema, options);
+    this.overrideTypeParsers();
   }
   get provider() {
     return "postgresql";
   }
+  overrideTypeParsers() {
+    if (this.options.fixPostgresTimezone !== false && !_PostgresCrudDialect.typeParserOverrideApplied) {
+      _PostgresCrudDialect.typeParserOverrideApplied = true;
+      import("pg").then((pg) => {
+        pg.types.setTypeParser(pg.types.builtins.TIMESTAMP, (value) => {
+          if (typeof value !== "string") {
+            return value;
+          }
+          if (!this.hasTimezoneOffset(value)) {
+            value += "Z";
+          }
+          const result = new Date(value);
+          return isNaN(result.getTime()) ? value : result;
+        });
+      }).catch(() => {
+      });
+    }
+  }
   // #region capabilities
   get supportsUpdateWithLimit() {
     return false;
@@ -1961,9 +1977,6 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
     } else if (Array.isArray(value)) {
       if (type === "Json" && !forArrayField) {
         return JSON.stringify(value);
-      }
-      if (isEnum(this.schema, type)) {
-        return this.eb.cast(import_kysely4.sql`ARRAY[${import_kysely4.sql.join(value.map((v) => this.transformInput(v, type, false)), import_kysely4.sql.raw(","))}]`, this.createSchemaQualifiedEnumType(type, true));
       } else {
         return value.map((v) => this.transformInput(v, type, false));
       }
@@ -1977,24 +1990,6 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
       }).otherwise(() => value);
     }
   }
-  createSchemaQualifiedEnumType(type, array) {
-    let qualified = type;
-    const enumDef = getEnum(this.schema, type);
-    if (enumDef) {
-      const schemaAttr = enumDef.attributes?.find((attr) => attr.name === "@@schema");
-      if (schemaAttr) {
-        const mapArg = schemaAttr.args?.find((arg) => arg.name === "map");
-        if (mapArg && mapArg.value.kind === "literal") {
-          const schemaName = mapArg.value.value;
-          qualified = `"${schemaName}"."${type}"`;
-        }
-      } else {
-        const defaultSchema = this.schema.provider.defaultSchema ?? "public";
-        qualified = `"${defaultSchema}"."${type}"`;
-      }
-    }
-    return array ? import_kysely4.sql.raw(`${qualified}[]`) : import_kysely4.sql.raw(qualified);
-  }
   transformOutput(value, type, array) {
     if (value === null || value === void 0) {
       return value;
@@ -2017,18 +2012,16 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
   }
   transformOutputDate(value) {
     if (typeof value === "string") {
-      if (this.isoDateSchema.safeParse(value).success) {
-        const hasOffset = value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
-        return new Date(hasOffset ? value : `${value}Z`);
-      } else {
-        return value;
-      }
-    } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
-      return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
+      const normalized = this.hasTimezoneOffset(value) ? value : `${value}Z`;
+      const parsed = new Date(normalized);
+      return Number.isNaN(parsed.getTime()) ? value : parsed;
     } else {
       return value;
     }
   }
+  hasTimezoneOffset(value) {
+    return value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
+  }
   transformOutputBytes(value) {
     return Buffer.isBuffer(value) ? Uint8Array.from(value) : typeof value === "string" && value.startsWith("\\x") ? Uint8Array.from(Buffer.from(value.slice(2), "hex")) : value;
   }
@@ -2078,12 +2071,19 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
       array
     ]);
   }
-  buildArrayLiteralSQL(values) {
-    if (values.length === 0) {
-      return import_kysely4.sql`{}`;
-    } else {
-      return import_kysely4.sql`ARRAY[${import_kysely4.sql.join(values.map((v) => import_kysely4.sql.val(v)), import_kysely4.sql.raw(","))}]`;
-    }
+  buildArrayValue(values, elemType) {
+    const arr = import_kysely4.sql`ARRAY[${import_kysely4.sql.join(values, import_kysely4.sql.raw(","))}]`;
+    const mappedType = this.getSqlType(elemType);
+    return this.eb.cast(arr, import_kysely4.sql`${import_kysely4.sql.raw(mappedType)}[]`);
+  }
+  buildArrayContains(field, value) {
+    return this.eb(field, "@>", import_kysely4.sql`ARRAY[${value}]`);
+  }
+  buildArrayHasEvery(field, values) {
+    return this.eb(field, "@>", values);
+  }
+  buildArrayHasSome(field, values) {
+    return this.eb(field, "&&", values);
   }
   buildJsonPathSelection(receiver, path) {
     if (path) {
@@ -2114,20 +2114,12 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
       receiver
     ]).as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  getFieldSqlType(fieldDef) {
-    if (fieldDef.relation) {
-      throw createInternalError("Cannot get SQL type of a relation field");
-    }
-    let result;
-    if (this.schema.enums?.[fieldDef.type]) {
-      result = "text";
+  getSqlType(zmodelType) {
+    if (isEnum(this.schema, zmodelType)) {
+      return "text";
     } else {
-      result = (0, import_ts_pattern4.match)(fieldDef.type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
+      return (0, import_ts_pattern4.match)(zmodelType).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
     }
-    if (fieldDef.array) {
-      result += "[]";
-    }
-    return result;
   }
   getStringCasingBehavior() {
     return {
@@ -2149,7 +2141,11 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
       }
     }
     const eb = (0, import_kysely4.expressionBuilder)();
-    return eb.selectFrom(import_kysely4.sql`(VALUES ${import_kysely4.sql.join(rows.map((row) => import_kysely4.sql`(${import_kysely4.sql.join(row.map((v) => import_kysely4.sql.val(v)))})`), import_kysely4.sql.raw(", "))})`.as("$values")).select(fields.map((f, i) => import_kysely4.sql`CAST(${import_kysely4.sql.ref(`$values.column${i + 1}`)} AS ${import_kysely4.sql.raw(this.getFieldSqlType(f))})`.as(f.name)));
+    return eb.selectFrom(import_kysely4.sql`(VALUES ${import_kysely4.sql.join(rows.map((row) => import_kysely4.sql`(${import_kysely4.sql.join(row.map((v) => import_kysely4.sql.val(v)))})`), import_kysely4.sql.raw(", "))})`.as("$values")).select(fields.map((f, i) => {
+      const mappedType = this.getSqlType(f.type);
+      const castType = f.array ? import_kysely4.sql`${import_kysely4.sql.raw(mappedType)}[]` : import_kysely4.sql.raw(mappedType);
+      return this.eb.cast(import_kysely4.sql.ref(`$values.column${i + 1}`), castType).as(f.name);
+    }));
   }
   buildOrderByField(query, field, sort, nulls) {
     return query.orderBy(field, (ob) => {
@@ -2414,8 +2410,17 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       array
     ]);
   }
-  buildArrayLiteralSQL(_values) {
-    throw new Error("SQLite does not support array literals");
+  buildArrayValue(values, _elemType) {
+    return new import_kysely5.ExpressionWrapper(import_kysely5.ValueListNode.create(values.map((v) => v.toOperationNode())));
+  }
+  buildArrayContains(_field, _value) {
+    throw createNotSupportedError("SQLite does not support native array operations");
+  }
+  buildArrayHasEvery(_field, _values) {
+    throw createNotSupportedError("SQLite does not support native array operations");
+  }
+  buildArrayHasSome(_field, _values) {
+    throw createNotSupportedError("SQLite does not support native array operations");
   }
   castInt(expression) {
     return expression;
@@ -2429,18 +2434,6 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       import_kysely5.sql.lit('"')
     ]);
   }
-  getFieldSqlType(fieldDef) {
-    if (fieldDef.relation) {
-      throw createInternalError("Cannot get SQL type of a relation field");
-    }
-    if (fieldDef.array) {
-      throw createInternalError("SQLite does not support scalar list type");
-    }
-    if (this.schema.enums?.[fieldDef.type]) {
-      return "text";
-    }
-    return (0, import_ts_pattern5.match)(fieldDef.type).with("String", () => "text").with("Boolean", () => "integer").with("Int", () => "integer").with("BigInt", () => "integer").with("Float", () => "real").with("Decimal", () => "decimal").with("DateTime", () => "numeric").with("Bytes", () => "blob").with("Json", () => "jsonb").otherwise(() => "text");
-  }
   getStringCasingBehavior() {
     return {
       supportsILike: false,
@@ -4598,7 +4591,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_decimal5 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern14 = require("ts-pattern");
-var import_zod3 = require("zod");
+var import_zod2 = require("zod");
 
 // src/utils/zod-utils.ts
 var import_v4 = require("zod-validation-error/v4");
@@ -4643,7 +4636,7 @@ __name(cache, "cache");
 var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_decimal4 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern13 = require("ts-pattern");
-var import_zod2 = require("zod");
+var import_zod = require("zod");
 var import_v3 = require("zod/v3");
 function getArgValue(expr) {
   if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
@@ -4752,13 +4745,13 @@ function addBigIntValidation(schema, attributes) {
 __name(addBigIntValidation, "addBigIntValidation");
 function addDecimalValidation(schema, attributes, addExtraValidation) {
   let result = schema;
-  if (schema instanceof import_zod2.z.ZodString) {
+  if (schema instanceof import_zod.z.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
         new import_decimal4.default(v);
       } catch (err) {
         ctx.addIssue({
-          code: import_zod2.z.ZodIssueCode.custom,
+          code: import_zod.z.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
@@ -4766,7 +4759,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
-      const base = import_zod2.z.number();
+      const base = import_zod.z.number();
       const { error } = base[op](value).safeParse(v.toNumber());
       error?.issues.forEach((issue) => {
         if (op === "gt" || op === "gte") {
@@ -4975,7 +4968,7 @@ function evalCall(data, expr) {
     }
     (0, import_common_helpers8.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const fn = (0, import_ts_pattern13.match)(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return import_zod2.z.string()[fn]().safeParse(fieldArg).success;
+    return import_zod.z.string()[fn]().safeParse(fieldArg).success;
   }).with(import_ts_pattern13.P.union("has", "hasEvery", "hasSome"), (f) => {
     (0, import_common_helpers8.invariant)(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
@@ -5174,8 +5167,8 @@ var InputValidator = class {
       const createSchema = "$create" in plugin.queryArgs && plugin.queryArgs["$create"] ? plugin.queryArgs["$create"] : void 0;
       const updateSchema = "$update" in plugin.queryArgs && plugin.queryArgs["$update"] ? plugin.queryArgs["$update"] : void 0;
       if (createSchema && updateSchema) {
-        (0, import_common_helpers9.invariant)(createSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
-        (0, import_common_helpers9.invariant)(updateSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(createSchema instanceof import_zod2.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(updateSchema instanceof import_zod2.z.ZodObject, "Plugin extended query args schema must be a Zod object");
         result = createSchema.extend(updateSchema.shape);
       } else if (createSchema) {
         result = createSchema;
@@ -5196,7 +5189,7 @@ var InputValidator = class {
     } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
       result = plugin.queryArgs["$all"];
     }
-    (0, import_common_helpers9.invariant)(result === void 0 || result instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+    (0, import_common_helpers9.invariant)(result === void 0 || result instanceof import_zod2.z.ZodObject, "Plugin extended query args schema must be a Zod object");
     return result;
   }
   // #endregion
@@ -5217,7 +5210,7 @@ var InputValidator = class {
     if (!unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (findOne) {
-        fields["take"] = import_zod3.z.literal(1).optional();
+        fields["take"] = import_zod2.z.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
       }
@@ -5225,7 +5218,7 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    const baseSchema = import_zod3.z.strictObject(fields);
+    const baseSchema = import_zod2.z.strictObject(fields);
     let result = this.mergePluginArgsSchema(baseSchema, operation);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
@@ -5235,7 +5228,7 @@ var InputValidator = class {
     return result;
   }
   makeExistsSchema(model) {
-    const baseSchema = import_zod3.z.strictObject({
+    const baseSchema = import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false).optional()
     });
     return this.mergePluginArgsSchema(baseSchema, "exists").optional();
@@ -5246,30 +5239,30 @@ var InputValidator = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return (0, import_ts_pattern14.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_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()
+      return (0, import_ts_pattern14.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
+        this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
+        this.extraValidationsEnabled ? addBigIntValidation(import_zod2.z.bigint(), attributes) : import_zod2.z.bigint()
       ])).with("Decimal", () => {
-        return import_zod3.z.union([
-          this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number(),
-          addDecimalValidation(import_zod3.z.instanceof(import_decimal5.default), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(import_zod3.z.string(), attributes, this.extraValidationsEnabled)
+        return import_zod2.z.union([
+          this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number(),
+          addDecimalValidation(import_zod2.z.instanceof(import_decimal5.default), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(import_zod2.z.string(), attributes, this.extraValidationsEnabled)
         ]);
-      }).with("DateTime", () => import_zod3.z.union([
-        import_zod3.z.date(),
-        import_zod3.z.iso.datetime()
-      ])).with("Bytes", () => import_zod3.z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => import_zod3.z.unknown());
+      }).with("DateTime", () => import_zod2.z.union([
+        import_zod2.z.date(),
+        import_zod2.z.iso.datetime()
+      ])).with("Bytes", () => import_zod2.z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => import_zod2.z.unknown());
     }
   }
   makeEnumSchema(type) {
     const enumDef = getEnum(this.schema, type);
     (0, import_common_helpers9.invariant)(enumDef, `Enum "${type}" not found in schema`);
-    return import_zod3.z.enum(Object.keys(enumDef.values));
+    return import_zod2.z.enum(Object.keys(enumDef.values));
   }
   makeTypeDefSchema(type) {
     const typeDef = getTypeDef(this.schema, type);
     (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
-    const schema = import_zod3.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    const schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makeScalarSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -5282,7 +5275,7 @@ var InputValidator = class {
         fieldSchema
       ];
     })));
-    const finalSchema = import_zod3.z.any().superRefine((value, ctx) => {
+    const finalSchema = import_zod2.z.any().superRefine((value, ctx) => {
       const parseResult = schema.safeParse(value);
       if (!parseResult.success) {
         parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
@@ -5300,21 +5293,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = import_zod3.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = import_zod3.z.union([
+          fieldSchema = import_zod2.z.union([
             fieldSchema,
-            import_zod3.z.strictObject({
+            import_zod2.z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = import_zod3.z.union([
+          fieldSchema = import_zod2.z.union([
             fieldSchema,
-            import_zod3.z.strictObject({
+            import_zod2.z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -5342,7 +5335,7 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = import_zod3.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+          fields[uniqueField.name] = import_zod2.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
             (0, import_common_helpers9.invariant)(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
@@ -5350,7 +5343,7 @@ var InputValidator = class {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(def.type, !!def.optional, false, false);
               } else {
-                fieldSchema = import_zod3.z.never();
+                fieldSchema = import_zod2.z.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
@@ -5363,13 +5356,13 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = import_zod3.z.custom((v) => typeof v === "function", {
+    fields["$expr"] = import_zod2.z.custom((v) => typeof v === "function", {
       error: '"$expr" must be a 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);
+    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);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -5408,26 +5401,26 @@ var InputValidator = class {
           }
         }
       }
-      candidates.push(import_zod3.z.strictObject(fieldSchemas));
+      candidates.push(import_zod2.z.strictObject(fieldSchemas));
     }
-    const recursiveSchema = import_zod3.z.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
+    const recursiveSchema = import_zod2.z.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
     if (array) {
-      candidates.push(import_zod3.z.strictObject({
+      candidates.push(import_zod2.z.strictObject({
         some: recursiveSchema,
         every: recursiveSchema,
         none: recursiveSchema
       }));
     } else {
-      candidates.push(import_zod3.z.strictObject({
+      candidates.push(import_zod2.z.strictObject({
         is: recursiveSchema,
         isNot: recursiveSchema
       }));
     }
     candidates.push(this.makeJsonFilterSchema(optional));
     if (optional) {
-      candidates.push(import_zod3.z.null());
+      candidates.push(import_zod2.z.null());
     }
-    return import_zod3.z.union(candidates);
+    return import_zod2.z.union(candidates);
   }
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
@@ -5435,11 +5428,11 @@ var InputValidator = class {
   makeEnumFilterSchema(enumName, optional, withAggregations, array) {
     const enumDef = getEnum(this.schema, enumName);
     (0, import_common_helpers9.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
-    const baseSchema = import_zod3.z.enum(Object.keys(enumDef.values));
+    const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
     if (array) {
       return this.internalMakeArrayFilterSchema(baseSchema);
     }
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
       "equals",
       "in",
       "notIn",
@@ -5449,65 +5442,65 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod3.z.union([
+    return import_zod2.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod3.z.strictObject(components)
+      import_zod2.z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
     return this.internalMakeArrayFilterSchema(this.makeScalarSchema(type));
   }
   internalMakeArrayFilterSchema(elementSchema) {
-    return import_zod3.z.strictObject({
+    return import_zod2.z.strictObject({
       equals: elementSchema.array().optional(),
       has: elementSchema.optional(),
       hasEvery: elementSchema.array().optional(),
       hasSome: elementSchema.array().optional(),
-      isEmpty: import_zod3.z.boolean().optional()
+      isEmpty: import_zod2.z.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
-    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => this.makeJsonFilterSchema(optional)).with("Unsupported", () => import_zod3.z.never()).exhaustive();
+    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => this.makeJsonFilterSchema(optional)).with("Unsupported", () => import_zod2.z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
-      import_zod3.z.string(),
-      import_zod3.z.number(),
-      import_zod3.z.boolean(),
-      import_zod3.z.instanceof(JsonNullClass)
+      import_zod2.z.string(),
+      import_zod2.z.number(),
+      import_zod2.z.boolean(),
+      import_zod2.z.instanceof(JsonNullClass)
     ];
     if (forFilter) {
-      options.push(import_zod3.z.instanceof(DbNullClass));
+      options.push(import_zod2.z.instanceof(DbNullClass));
     } else {
       if (nullable) {
-        options.push(import_zod3.z.instanceof(DbNullClass));
+        options.push(import_zod2.z.instanceof(DbNullClass));
       }
     }
     if (forFilter) {
-      options.push(import_zod3.z.instanceof(AnyNullClass));
+      options.push(import_zod2.z.instanceof(AnyNullClass));
     }
-    const schema = import_zod3.z.union([
+    const schema = import_zod2.z.union([
       ...options,
-      import_zod3.z.lazy(() => import_zod3.z.union([
+      import_zod2.z.lazy(() => import_zod2.z.union([
         this.makeJsonValueSchema(false, false),
-        import_zod3.z.null()
+        import_zod2.z.null()
       ]).array()),
-      import_zod3.z.record(import_zod3.z.string(), import_zod3.z.lazy(() => import_zod3.z.union([
+      import_zod2.z.record(import_zod2.z.string(), import_zod2.z.lazy(() => import_zod2.z.union([
         this.makeJsonValueSchema(false, false),
-        import_zod3.z.null()
+        import_zod2.z.null()
       ])))
     ]);
     return this.nullableIf(schema, nullable);
   }
   makeJsonFilterSchema(optional) {
     const valueSchema = this.makeJsonValueSchema(optional, true);
-    return import_zod3.z.strictObject({
-      path: import_zod3.z.string().optional(),
+    return import_zod2.z.strictObject({
+      path: import_zod2.z.string().optional(),
       equals: valueSchema.optional(),
       not: valueSchema.optional(),
-      string_contains: import_zod3.z.string().optional(),
-      string_starts_with: import_zod3.z.string().optional(),
-      string_ends_with: import_zod3.z.string().optional(),
+      string_contains: import_zod2.z.string().optional(),
+      string_starts_with: import_zod2.z.string().optional(),
+      string_ends_with: import_zod2.z.string().optional(),
       mode: this.makeStringModeSchema().optional(),
       array_contains: valueSchema.optional(),
       array_starts_with: valueSchema.optional(),
@@ -5515,17 +5508,17 @@ var InputValidator = class {
     });
   }
   makeDateTimeFilterSchema(optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod3.z.union([
-      import_zod3.z.iso.datetime(),
-      import_zod3.z.date()
-    ]), optional, () => import_zod3.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(import_zod2.z.union([
+      import_zod2.z.iso.datetime(),
+      import_zod2.z.date()
+    ]), optional, () => import_zod2.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0);
   }
   makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(import_zod3.z.boolean(), optional, () => import_zod3.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(import_zod2.z.boolean(), optional, () => import_zod2.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -5533,14 +5526,14 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod3.z.union([
-      this.nullableIf(import_zod3.z.boolean(), optional),
-      import_zod3.z.strictObject(components)
+    return import_zod2.z.union([
+      this.nullableIf(import_zod2.z.boolean(), optional),
+      import_zod2.z.strictObject(components)
     ]);
   }
   makeBytesFilterSchema(optional, withAggregations) {
-    const baseSchema = import_zod3.z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.instanceof(Uint8Array), [
+    const baseSchema = import_zod2.z.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -5550,9 +5543,9 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod3.z.union([
+    return import_zod2.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod3.z.strictObject(components)
+      import_zod2.z.strictObject(components)
     ]);
   }
   makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
@@ -5569,7 +5562,7 @@ var InputValidator = class {
       between: baseSchema.array().length(2).optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(import_zod3.z.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(import_zod2.z.number().int(), false, false).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -5594,13 +5587,13 @@ var InputValidator = class {
     return result;
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return import_zod3.z.union([
+    return import_zod2.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod3.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
+      import_zod2.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -5609,17 +5602,17 @@ var InputValidator = class {
     ] : void 0);
   }
   makeStringFilterSchema(optional, 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 ? [
+    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 ? [
           "_count",
           "_min",
           "_max"
         ] : void 0),
-        startsWith: import_zod3.z.string().optional(),
-        endsWith: import_zod3.z.string().optional(),
-        contains: import_zod3.z.string().optional(),
+        startsWith: import_zod2.z.string().optional(),
+        endsWith: import_zod2.z.string().optional(),
+        contains: import_zod2.z.string().optional(),
         ...this.providerSupportsCaseSensitivity ? {
           mode: this.makeStringModeSchema().optional()
         } : {}
@@ -5627,9 +5620,9 @@ var InputValidator = class {
     ]);
   }
   makeStringModeSchema() {
-    return import_zod3.z.union([
-      import_zod3.z.literal("default"),
-      import_zod3.z.literal("insensitive")
+    return import_zod2.z.union([
+      import_zod2.z.literal("default"),
+      import_zod2.z.literal("insensitive")
     ]);
   }
   makeSelectSchema(model) {
@@ -5640,27 +5633,27 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
       } else {
-        fields[field] = import_zod3.z.boolean().optional();
+        fields[field] = import_zod2.z.boolean().optional();
       }
     }
     const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof import_zod3.z.ZodNever)) {
+    if (!(_countSchema instanceof import_zod2.z.ZodNever)) {
       fields["_count"] = _countSchema;
     }
-    return import_zod3.z.strictObject(fields);
+    return import_zod2.z.strictObject(fields);
   }
   makeCountSelectionSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
-      return import_zod3.z.union([
-        import_zod3.z.literal(true),
-        import_zod3.z.strictObject({
-          select: import_zod3.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      return import_zod2.z.union([
+        import_zod2.z.literal(true),
+        import_zod2.z.strictObject({
+          select: import_zod2.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: import_zod3.z.union([
-              import_zod3.z.boolean(),
-              import_zod3.z.strictObject({
+            [fieldDef.name]: import_zod2.z.union([
+              import_zod2.z.boolean(),
+              import_zod2.z.strictObject({
                 where: this.makeWhereSchema(fieldDef.type, false, false)
               })
             ]).optional()
@@ -5668,22 +5661,22 @@ var InputValidator = class {
         })
       ]).optional();
     } else {
-      return import_zod3.z.never();
+      return import_zod2.z.never();
     }
   }
   makeRelationSelectIncludeSchema(model, field) {
     const fieldDef = requireField(this.schema, model, field);
-    let objSchema = import_zod3.z.strictObject({
+    let objSchema = import_zod2.z.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: import_zod3.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
       } : {},
-      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(),
+      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(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: import_zod3.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: import_zod2.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
         skip: this.makeSkipSchema().optional(),
         take: this.makeTakeSchema().optional(),
         cursor: this.makeCursorSchema(fieldDef.type).optional(),
@@ -5692,8 +5685,8 @@ var InputValidator = class {
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
-    return import_zod3.z.union([
-      import_zod3.z.boolean(),
+    return import_zod2.z.union([
+      import_zod2.z.boolean(),
       objSchema
     ]);
   }
@@ -5704,13 +5697,13 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
-          fields[field] = import_zod3.z.boolean().optional();
+          fields[field] = import_zod2.z.boolean().optional();
         } else {
-          fields[field] = import_zod3.z.literal(true).optional();
+          fields[field] = import_zod2.z.literal(true).optional();
         }
       }
     }
-    return import_zod3.z.strictObject(fields);
+    return import_zod2.z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -5722,23 +5715,23 @@ var InputValidator = class {
       }
     }
     const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof import_zod3.z.ZodNever)) {
+    if (!(_countSchema instanceof import_zod2.z.ZodNever)) {
       fields["_count"] = _countSchema;
     }
-    return import_zod3.z.strictObject(fields);
+    return import_zod2.z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = import_zod3.z.union([
-      import_zod3.z.literal("asc"),
-      import_zod3.z.literal("desc")
+    const sort = import_zod2.z.union([
+      import_zod2.z.literal("asc"),
+      import_zod2.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_zod3.z.lazy(() => {
+          fields[field] = import_zod2.z.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
@@ -5750,13 +5743,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = import_zod3.z.union([
+          fields[field] = import_zod2.z.union([
             sort,
-            import_zod3.z.strictObject({
+            import_zod2.z.strictObject({
               sort,
-              nulls: import_zod3.z.union([
-                import_zod3.z.literal("first"),
-                import_zod3.z.literal("last")
+              nulls: import_zod2.z.union([
+                import_zod2.z.literal("first"),
+                import_zod2.z.literal("last")
               ])
             })
           ]).optional();
@@ -5774,15 +5767,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = import_zod3.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = import_zod2.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return import_zod3.z.strictObject(fields);
+    return import_zod2.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_zod3.z.enum(nonRelationFields), true);
+    return this.orArray(import_zod2.z.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -5791,7 +5784,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    const baseSchema = import_zod3.z.strictObject({
+    const baseSchema = import_zod2.z.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -5843,7 +5836,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
+        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -5869,9 +5862,9 @@ var InputValidator = class {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
           fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = import_zod3.z.union([
+          fieldSchema = import_zod2.z.union([
             fieldSchema,
-            import_zod3.z.strictObject({
+            import_zod2.z.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -5881,9 +5874,9 @@ var InputValidator = class {
         }
         if (fieldDef.optional) {
           if (fieldDef.type === "Json") {
-            fieldSchema = import_zod3.z.union([
+            fieldSchema = import_zod2.z.union([
               fieldSchema,
-              import_zod3.z.instanceof(DbNullClass)
+              import_zod2.z.instanceof(DbNullClass)
             ]);
           } else {
             fieldSchema = fieldSchema.nullable();
@@ -5895,19 +5888,19 @@ var InputValidator = class {
         }
       }
     });
-    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);
+    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);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return import_zod3.z.union([
+      return import_zod2.z.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          import_zod3.z.array(uncheckedCreateSchema)
+          import_zod2.z.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          import_zod3.z.array(checkedCreateSchema)
+          import_zod2.z.array(checkedCreateSchema)
         ] : []
       ]);
     }
@@ -5936,11 +5929,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_zod3.z.strictObject({
+      fields["update"] = array ? this.orArray(import_zod2.z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : import_zod3.z.union([
-        import_zod3.z.strictObject({
+      }), true).optional() : import_zod2.z.union([
+        import_zod2.z.strictObject({
           where: this.makeWhereSchema(fieldType, false).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
@@ -5950,21 +5943,21 @@ var InputValidator = class {
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
-      fields["upsert"] = this.orArray(import_zod3.z.strictObject({
+      fields["upsert"] = this.orArray(import_zod2.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_zod3.z.strictObject({
+        fields["updateMany"] = this.orArray(import_zod2.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_zod3.z.strictObject(fields);
+    return import_zod2.z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -5976,36 +5969,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return import_zod3.z.union([
-        import_zod3.z.boolean(),
+      return import_zod2.z.union([
+        import_zod2.z.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod3.z.union([
-      import_zod3.z.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod2.z.union([
+      import_zod2.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_zod3.z.strictObject({
+    return this.orArray(import_zod2.z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return import_zod3.z.strictObject({
+    return import_zod2.z.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: import_zod3.z.boolean().optional()
+      skipDuplicates: import_zod2.z.boolean().optional()
     });
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    const baseSchema = import_zod3.z.strictObject({
+    const baseSchema = import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
@@ -6018,10 +6011,10 @@ var InputValidator = class {
     return schema;
   }
   makeUpdateManySchema(model) {
-    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
+    return this.mergePluginArgsSchema(import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: import_zod3.z.number().int().nonnegative().optional()
+      limit: import_zod2.z.number().int().nonnegative().optional()
     }), "updateMany");
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -6034,7 +6027,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    const baseSchema = import_zod3.z.strictObject({
+    const baseSchema = import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -6070,7 +6063,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
+        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -6081,24 +6074,24 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = import_zod3.z.union([
+          fieldSchema = import_zod2.z.union([
             fieldSchema,
-            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()
+            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()
             }).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_zod3.z.union([
+          fieldSchema = import_zod2.z.union([
             arraySchema,
-            import_zod3.z.object({
+            import_zod2.z.object({
               set: arraySchema.optional(),
-              push: import_zod3.z.union([
+              push: import_zod2.z.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -6107,9 +6100,9 @@ var InputValidator = class {
         }
         if (fieldDef.optional) {
           if (fieldDef.type === "Json") {
-            fieldSchema = import_zod3.z.union([
+            fieldSchema = import_zod2.z.union([
               fieldSchema,
-              import_zod3.z.instanceof(DbNullClass)
+              import_zod2.z.instanceof(DbNullClass)
             ]);
           } else {
             fieldSchema = fieldSchema.nullable();
@@ -6122,12 +6115,12 @@ var InputValidator = class {
         }
       }
     });
-    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);
+    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);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return import_zod3.z.union([
+      return import_zod2.z.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -6136,7 +6129,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    const baseSchema = import_zod3.z.strictObject({
+    const baseSchema = import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -6148,15 +6141,15 @@ var InputValidator = class {
     return schema;
   }
   makeDeleteManySchema(model) {
-    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
+    return this.mergePluginArgsSchema(import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: import_zod3.z.number().int().nonnegative().optional()
+      limit: import_zod2.z.number().int().nonnegative().optional()
     }), "deleteMany").optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
+    return this.mergePluginArgsSchema(import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -6166,12 +6159,12 @@ var InputValidator = class {
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod3.z.union([
-      import_zod3.z.literal(true),
-      import_zod3.z.strictObject({
-        _all: import_zod3.z.literal(true).optional(),
+    return import_zod2.z.union([
+      import_zod2.z.literal(true),
+      import_zod2.z.strictObject({
+        _all: import_zod2.z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = import_zod3.z.literal(true).optional();
+          acc[field] = import_zod2.z.literal(true).optional();
           return acc;
         }, {})
       })
@@ -6180,7 +6173,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
+    return this.mergePluginArgsSchema(import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -6194,20 +6187,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod3.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = import_zod3.z.literal(true).optional();
+        acc[field] = import_zod2.z.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod3.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = import_zod3.z.literal(true).optional();
+        acc[field] = import_zod2.z.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -6215,8 +6208,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_zod3.z.enum(nonRelationFields), true) : import_zod3.z.never();
-    const baseSchema = import_zod3.z.strictObject({
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
+    const baseSchema = import_zod2.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -6290,10 +6283,10 @@ var InputValidator = class {
     } else if (isEnum(this.schema, param.type)) {
       schema = this.makeEnumSchema(param.type);
     } else if (param.type in (this.schema.models ?? {})) {
-      schema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown());
+      schema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown());
     } else {
       schema = this.makeScalarSchema(param.type);
-      if (schema instanceof import_zod3.z.ZodUnknown) {
+      if (schema instanceof import_zod2.z.ZodUnknown) {
         throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
       }
     }
@@ -6325,10 +6318,10 @@ var InputValidator = class {
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return import_zod3.z.number().int().nonnegative();
+    return import_zod2.z.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return import_zod3.z.number().int();
+    return import_zod2.z.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -6340,9 +6333,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? import_zod3.z.union([
+    return canBeArray ? import_zod2.z.union([
       schema,
-      import_zod3.z.array(schema)
+      import_zod2.z.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -6383,7 +6376,7 @@ _ts_decorate([
   _ts_metadata("design:paramtypes", [
     String
   ]),
-  _ts_metadata("design:returntype", typeof import_zod3.z === "undefined" || typeof import_zod3.z.ZodType === "undefined" ? Object : import_zod3.z.ZodType)
+  _ts_metadata("design:returntype", typeof import_zod2.z === "undefined" || typeof import_zod2.z.ZodType === "undefined" ? Object : import_zod2.z.ZodType)
 ], InputValidator.prototype, "makeTypeDefSchema", null);
 _ts_decorate([
   cache(),
@@ -6394,7 +6387,7 @@ _ts_decorate([
     void 0,
     void 0
   ]),
-  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeWhereSchema", null);
 _ts_decorate([
   cache(),
@@ -6450,7 +6443,7 @@ _ts_decorate([
     Boolean,
     Boolean
   ]),
-  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeDateTimeFilterSchema", null);
 _ts_decorate([
   cache(),
@@ -6459,7 +6452,7 @@ _ts_decorate([
     Boolean,
     Boolean
   ]),
-  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeBooleanFilterSchema", null);
 _ts_decorate([
   cache(),
@@ -6468,7 +6461,7 @@ _ts_decorate([
     Boolean,
     Boolean
   ]),
-  _ts_metadata("design:returntype", typeof import_zod3.ZodType === "undefined" ? Object : import_zod3.ZodType)
+  _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeBytesFilterSchema", null);
 _ts_decorate([
   cache(),
@@ -6743,7 +6736,7 @@ _ts_decorate([
   _ts_metadata("design:paramtypes", [
     Object
   ]),
-  _ts_metadata("design:returntype", typeof import_zod3.z === "undefined" || typeof import_zod3.z.ZodType === "undefined" ? Object : import_zod3.z.ZodType)
+  _ts_metadata("design:returntype", typeof import_zod2.z === "undefined" || typeof import_zod2.z.ZodType === "undefined" ? Object : import_zod2.z.ZodType)
 ], InputValidator.prototype, "makeProcedureParamSchema", null);
 _ts_decorate([
   cache(),
@@ -6956,6 +6949,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   client;
   modelToTableMap = /* @__PURE__ */ new Map();
   fieldToColumnMap = /* @__PURE__ */ new Map();
+  enumTypeMap = /* @__PURE__ */ new Map();
   scopes = [];
   dialect;
   constructor(client) {
@@ -6973,14 +6967,20 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
         }
       }
     }
+    for (const [enumName, enumDef] of Object.entries(client.$schema.enums ?? {})) {
+      const mappedName = this.getMappedName(enumDef);
+      if (mappedName) {
+        this.enumTypeMap.set(enumName, mappedName);
+      }
+    }
   }
   get schema() {
     return this.client.$schema;
   }
   // #region overrides
-  transformSelectQuery(node) {
+  transformSelectQuery(node, queryId) {
     if (!node.from?.froms) {
-      return super.transformSelectQuery(node);
+      return super.transformSelectQuery(node, queryId);
     }
     const processedFroms = node.from.froms.map((from) => this.processSelectTable(from));
     const processedJoins = [];
@@ -6999,7 +6999,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
         on: this.transformNode(join.on)
       })) : void 0;
       const selections = this.processSelectQuerySelections(node);
-      const baseResult = super.transformSelectQuery(node);
+      const baseResult = super.transformSelectQuery(node, queryId);
       return {
         ...baseResult,
         from: import_kysely7.FromNode.create(processedFroms.map((f) => f.node)),
@@ -7008,16 +7008,16 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       };
     });
   }
-  transformInsertQuery(node) {
+  transformInsertQuery(node, queryId) {
     if (!node.into) {
-      return super.transformInsertQuery(node);
+      return super.transformInsertQuery(node, queryId);
     }
     const model = extractModelName(node.into);
     (0, import_common_helpers10.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
     return this.withScope({
       model
     }, () => {
-      const baseResult = super.transformInsertQuery(node);
+      const baseResult = super.transformInsertQuery(node, queryId);
       let values = baseResult.values;
       if (node.columns && values) {
         values = this.processEnumMappingForColumns(model, node.columns, values);
@@ -7040,9 +7040,9 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       selections: this.processSelections(node.selections)
     };
   }
-  transformReference(node) {
+  transformReference(node, queryId) {
     if (!import_kysely7.ColumnNode.is(node.column)) {
-      return super.transformReference(node);
+      return super.transformReference(node, queryId);
     }
     const scope = this.resolveFieldFromScopes(node.column.column.name, node.table?.table.identifier.name);
     if (scope && !scope.namesMapped && scope.model) {
@@ -7059,15 +7059,15 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       return node;
     }
   }
-  transformColumn(node) {
+  transformColumn(node, queryId) {
     const scope = this.resolveFieldFromScopes(node.column.name);
     if (!scope || scope.namesMapped || !scope.model) {
-      return super.transformColumn(node);
+      return super.transformColumn(node, queryId);
     }
     const mappedName = this.mapFieldName(scope.model, node.column.name);
     return import_kysely7.ColumnNode.create(mappedName);
   }
-  transformBinaryOperation(node) {
+  transformBinaryOperation(node, queryId) {
     if (import_kysely7.ReferenceNode.is(node.leftOperand) && import_kysely7.ColumnNode.is(node.leftOperand.column) && (import_kysely7.ValueNode.is(node.rightOperand) || import_kysely7.PrimitiveValueListNode.is(node.rightOperand))) {
       const columnNode = node.leftOperand.column;
       const resolvedScope = this.resolveFieldFromScopes(columnNode.column.name, node.leftOperand.table?.table.identifier.name);
@@ -7082,14 +7082,14 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
         return super.transformBinaryOperation({
           ...node,
           rightOperand: resultValue
-        });
+        }, queryId);
       }
     }
-    return super.transformBinaryOperation(node);
+    return super.transformBinaryOperation(node, queryId);
   }
-  transformUpdateQuery(node) {
+  transformUpdateQuery(node, queryId) {
     if (!node.table) {
-      return super.transformUpdateQuery(node);
+      return super.transformUpdateQuery(node, queryId);
     }
     const { alias, node: innerTable } = stripAlias(node.table);
     if (!innerTable || !import_kysely7.TableNode.is(innerTable)) {
@@ -7101,7 +7101,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       model,
       alias
     }, () => {
-      const baseResult = super.transformUpdateQuery(node);
+      const baseResult = super.transformUpdateQuery(node, queryId);
       const updates = baseResult.updates?.map((update, i) => {
         if (import_kysely7.ColumnNode.is(update.column)) {
           const origColumn = node.updates[i].column;
@@ -7118,7 +7118,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       };
     });
   }
-  transformDeleteQuery(node) {
+  transformDeleteQuery(node, queryId) {
     const scopes = node.from.froms.map((node2) => {
       const { alias, node: innerNode } = stripAlias(node2);
       return {
@@ -7132,12 +7132,12 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       if (import_kysely7.TableNode.is(innerNode)) {
         return this.wrapAlias(this.processTableRef(innerNode), alias);
       } else {
-        return super.transformNode(from);
+        return super.transformNode(from, queryId);
       }
     });
     return this.withScopes(scopes, () => {
       return {
-        ...super.transformDeleteQuery(node),
+        ...super.transformDeleteQuery(node, queryId),
         from: import_kysely7.FromNode.create(froms)
       };
     });
@@ -8046,7 +8046,7 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   ])).exhaustive();
   return import_kysely9.sql`${fieldExpr} ${import_kysely9.sql.raw(op)} ${searchExpr} escape ${import_kysely9.sql.val("\\")}`;
 }, "textMatch");
-var has = /* @__PURE__ */ __name((eb, args) => {
+var has = /* @__PURE__ */ __name((_eb, args, context) => {
   const [field, search2] = args;
   if (!field) {
     throw new Error('"field" parameter is required');
@@ -8054,11 +8054,9 @@ var has = /* @__PURE__ */ __name((eb, args) => {
   if (!search2) {
     throw new Error('"search" parameter is required');
   }
-  return eb(field, "@>", [
-    search2
-  ]);
+  return context.dialect.buildArrayContains(field, search2);
 }, "has");
-var hasEvery = /* @__PURE__ */ __name((eb, args) => {
+var hasEvery = /* @__PURE__ */ __name((_eb, args, { dialect }) => {
   const [field, search2] = args;
   if (!field) {
     throw new Error('"field" parameter is required');
@@ -8066,9 +8064,9 @@ var hasEvery = /* @__PURE__ */ __name((eb, args) => {
   if (!search2) {
     throw new Error('"search" parameter is required');
   }
-  return eb(field, "@>", search2);
+  return dialect.buildArrayHasEvery(field, search2);
 }, "hasEvery");
-var hasSome = /* @__PURE__ */ __name((eb, args) => {
+var hasSome = /* @__PURE__ */ __name((_eb, args, { dialect }) => {
   const [field, search2] = args;
   if (!field) {
     throw new Error('"field" parameter is required');
@@ -8076,7 +8074,7 @@ var hasSome = /* @__PURE__ */ __name((eb, args) => {
   if (!search2) {
     throw new Error('"search" parameter is required');
   }
-  return eb(field, "&&", search2);
+  return dialect.buildArrayHasSome(field, search2);
 }, "hasSome");
 var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   const [field] = args;
@@ -8139,7 +8137,7 @@ var SchemaDbPusher = class {
   async push() {
     await this.kysely.transaction().execute(async (tx) => {
       if (this.schema.enums && this.providerSupportsNativeEnum) {
-        for (const [name, enumDef] of Object.entries(this.schema.enums)) {
+        for (const enumDef of Object.values(this.schema.enums)) {
           let enumValues;
           if (enumDef.fields) {
             enumValues = Object.values(enumDef.fields).map((f) => {
@@ -8155,7 +8153,7 @@ var SchemaDbPusher = class {
           } else {
             enumValues = Object.values(enumDef.values);
           }
-          const createEnum = tx.schema.createType(name).asEnum(enumValues);
+          const createEnum = tx.schema.createType(this.getEnumName(enumDef)).asEnum(enumValues);
           await createEnum.execute();
         }
       }
@@ -8233,6 +8231,16 @@ var SchemaDbPusher = class {
     }
     return modelDef.name;
   }
+  getEnumName(enumDef) {
+    const mapAttr = enumDef.attributes?.find((a) => a.name === "@@map");
+    if (mapAttr && mapAttr.args?.[0]) {
+      const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
+      if (mappedName) {
+        return mappedName;
+      }
+    }
+    return enumDef.name;
+  }
   getColumnName(fieldDef) {
     const mapAttr = fieldDef.attributes?.find((a) => a.name === "@map");
     if (mapAttr && mapAttr.args?.[0]) {