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

package/dist/index.js

@@ -633,7 +633,7 @@ import { match as match6 } from "ts-pattern";
 // src/client/crud/dialects/mysql.ts
 import { invariant as invariant4 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
-import { expressionBuilder as expressionBuilder2, sql as sql2 } from "kysely";
+import { expressionBuilder as expressionBuilder2, ExpressionWrapper, sql as sql2, ValueListNode } from "kysely";
 import { match as match3 } from "ts-pattern";
 
 // src/common-types.ts
@@ -911,24 +911,31 @@ var BaseCrudDialect = class {
       if (_value === void 0) {
         continue;
       }
-      const value = this.transformInput(_value, fieldType, !!fieldDef.array);
+      invariant2(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, sql.raw("text[]"));
+      }
+      const buildArray = /* @__PURE__ */ __name((value2) => {
+        invariant2(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": {
@@ -1764,8 +1771,17 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
       array
     ]);
   }
-  buildArrayLiteralSQL(_values) {
-    throw new Error("MySQL does not support array literals");
+  buildArrayValue(values, _elemType) {
+    return new ExpressionWrapper(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([
@@ -1803,21 +1819,6 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
   buildJsonArrayExistsPredicate(receiver, buildFilter) {
     return this.eb.exists(this.eb.selectFrom(sql2`JSON_TABLE(${receiver}, '$[*]' COLUMNS(value JSON PATH '$'))`.as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  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 = match3(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,
@@ -1857,21 +1858,36 @@ import Decimal2 from "decimal.js";
 import { expressionBuilder as expressionBuilder3, sql as sql3 } from "kysely";
 import { parse as parsePostgresArray } from "postgres-array";
 import { match as match4 } from "ts-pattern";
-import z from "zod";
-var PostgresCrudDialect = class extends LateralJoinDialectBase {
+var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectBase {
   static {
     __name(this, "PostgresCrudDialect");
   }
-  isoDateSchema = z.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;
@@ -1916,9 +1932,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(sql3`ARRAY[${sql3.join(value.map((v) => this.transformInput(v, type, false)), sql3.raw(","))}]`, this.createSchemaQualifiedEnumType(type, true));
       } else {
         return value.map((v) => this.transformInput(v, type, false));
       }
@@ -1932,24 +1945,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 ? sql3.raw(`${qualified}[]`) : sql3.raw(qualified);
-  }
   transformOutput(value, type, array) {
     if (value === null || value === void 0) {
       return value;
@@ -1972,18 +1967,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;
   }
@@ -2033,12 +2026,19 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
       array
     ]);
   }
-  buildArrayLiteralSQL(values) {
-    if (values.length === 0) {
-      return sql3`{}`;
-    } else {
-      return sql3`ARRAY[${sql3.join(values.map((v) => sql3.val(v)), sql3.raw(","))}]`;
-    }
+  buildArrayValue(values, elemType) {
+    const arr = sql3`ARRAY[${sql3.join(values, sql3.raw(","))}]`;
+    const mappedType = this.getSqlType(elemType);
+    return this.eb.cast(arr, sql3`${sql3.raw(mappedType)}[]`);
+  }
+  buildArrayContains(field, value) {
+    return this.eb(field, "@>", sql3`ARRAY[${value}]`);
+  }
+  buildArrayHasEvery(field, values) {
+    return this.eb(field, "@>", values);
+  }
+  buildArrayHasSome(field, values) {
+    return this.eb(field, "&&", values);
   }
   buildJsonPathSelection(receiver, path) {
     if (path) {
@@ -2069,20 +2069,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 = match4(fieldDef.type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
-    }
-    if (fieldDef.array) {
-      result += "[]";
+      return match4(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");
     }
-    return result;
   }
   getStringCasingBehavior() {
     return {
@@ -2104,7 +2096,11 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
       }
     }
     const eb = expressionBuilder3();
-    return eb.selectFrom(sql3`(VALUES ${sql3.join(rows.map((row) => sql3`(${sql3.join(row.map((v) => sql3.val(v)))})`), sql3.raw(", "))})`.as("$values")).select(fields.map((f, i) => sql3`CAST(${sql3.ref(`$values.column${i + 1}`)} AS ${sql3.raw(this.getFieldSqlType(f))})`.as(f.name)));
+    return eb.selectFrom(sql3`(VALUES ${sql3.join(rows.map((row) => sql3`(${sql3.join(row.map((v) => sql3.val(v)))})`), sql3.raw(", "))})`.as("$values")).select(fields.map((f, i) => {
+      const mappedType = this.getSqlType(f.type);
+      const castType = f.array ? sql3`${sql3.raw(mappedType)}[]` : sql3.raw(mappedType);
+      return this.eb.cast(sql3.ref(`$values.column${i + 1}`), castType).as(f.name);
+    }));
   }
   buildOrderByField(query, field, sort, nulls) {
     return query.orderBy(field, (ob) => {
@@ -2118,7 +2114,7 @@ var PostgresCrudDialect = class extends LateralJoinDialectBase {
 // src/client/crud/dialects/sqlite.ts
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import Decimal3 from "decimal.js";
-import { expressionBuilder as expressionBuilder4, sql as sql4 } from "kysely";
+import { expressionBuilder as expressionBuilder4, ExpressionWrapper as ExpressionWrapper2, sql as sql4, ValueListNode as ValueListNode2 } from "kysely";
 import { match as match5 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
@@ -2369,8 +2365,17 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       array
     ]);
   }
-  buildArrayLiteralSQL(_values) {
-    throw new Error("SQLite does not support array literals");
+  buildArrayValue(values, _elemType) {
+    return new ExpressionWrapper2(ValueListNode2.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;
@@ -2384,18 +2389,6 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       sql4.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 match5(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,
@@ -4553,7 +4546,7 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 import { enumerate as enumerate3, invariant as invariant9 } from "@zenstackhq/common-helpers";
 import Decimal5 from "decimal.js";
 import { match as match14, P as P3 } from "ts-pattern";
-import { z as z3, ZodType } from "zod";
+import { z as z2, ZodType } from "zod";
 
 // src/utils/zod-utils.ts
 import { fromError } from "zod-validation-error/v4";
@@ -4598,7 +4591,7 @@ __name(cache, "cache");
 import { invariant as invariant8 } from "@zenstackhq/common-helpers";
 import Decimal4 from "decimal.js";
 import { match as match13, P as P2 } from "ts-pattern";
-import { z as z2 } from "zod";
+import { z } from "zod";
 import { ZodIssueCode } from "zod/v3";
 function getArgValue(expr) {
   if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
@@ -4707,13 +4700,13 @@ function addBigIntValidation(schema, attributes) {
 __name(addBigIntValidation, "addBigIntValidation");
 function addDecimalValidation(schema, attributes, addExtraValidation) {
   let result = schema;
-  if (schema instanceof z2.ZodString) {
+  if (schema instanceof z.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
         new Decimal4(v);
       } catch (err) {
         ctx.addIssue({
-          code: z2.ZodIssueCode.custom,
+          code: z.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
@@ -4721,7 +4714,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
-      const base = z2.number();
+      const base = z.number();
       const { error } = base[op](value).safeParse(v.toNumber());
       error?.issues.forEach((issue) => {
         if (op === "gt" || op === "gte") {
@@ -4930,7 +4923,7 @@ function evalCall(data, expr) {
     }
     invariant8(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const fn = match13(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return z2.string()[fn]().safeParse(fieldArg).success;
+    return z.string()[fn]().safeParse(fieldArg).success;
   }).with(P2.union("has", "hasEvery", "hasSome"), (f) => {
     invariant8(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
@@ -5129,8 +5122,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) {
-        invariant9(createSchema instanceof z3.ZodObject, "Plugin extended query args schema must be a Zod object");
-        invariant9(updateSchema instanceof z3.ZodObject, "Plugin extended query args schema must be a Zod object");
+        invariant9(createSchema instanceof z2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        invariant9(updateSchema instanceof z2.ZodObject, "Plugin extended query args schema must be a Zod object");
         result = createSchema.extend(updateSchema.shape);
       } else if (createSchema) {
         result = createSchema;
@@ -5151,7 +5144,7 @@ var InputValidator = class {
     } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
       result = plugin.queryArgs["$all"];
     }
-    invariant9(result === void 0 || result instanceof z3.ZodObject, "Plugin extended query args schema must be a Zod object");
+    invariant9(result === void 0 || result instanceof z2.ZodObject, "Plugin extended query args schema must be a Zod object");
     return result;
   }
   // #endregion
@@ -5172,7 +5165,7 @@ var InputValidator = class {
     if (!unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (findOne) {
-        fields["take"] = z3.literal(1).optional();
+        fields["take"] = z2.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
       }
@@ -5180,7 +5173,7 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    const baseSchema = z3.strictObject(fields);
+    const baseSchema = z2.strictObject(fields);
     let result = this.mergePluginArgsSchema(baseSchema, operation);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
@@ -5190,7 +5183,7 @@ var InputValidator = class {
     return result;
   }
   makeExistsSchema(model) {
-    const baseSchema = z3.strictObject({
+    const baseSchema = z2.strictObject({
       where: this.makeWhereSchema(model, false).optional()
     });
     return this.mergePluginArgsSchema(baseSchema, "exists").optional();
@@ -5201,30 +5194,30 @@ var InputValidator = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return match14(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(z3.string(), attributes) : z3.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(z3.number().int(), attributes) : z3.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(z3.number(), attributes) : z3.number()).with("Boolean", () => z3.boolean()).with("BigInt", () => z3.union([
-        this.extraValidationsEnabled ? addNumberValidation(z3.number().int(), attributes) : z3.number().int(),
-        this.extraValidationsEnabled ? addBigIntValidation(z3.bigint(), attributes) : z3.bigint()
+      return match14(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(z2.string(), attributes) : z2.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number()).with("Boolean", () => z2.boolean()).with("BigInt", () => z2.union([
+        this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int(),
+        this.extraValidationsEnabled ? addBigIntValidation(z2.bigint(), attributes) : z2.bigint()
       ])).with("Decimal", () => {
-        return z3.union([
-          this.extraValidationsEnabled ? addNumberValidation(z3.number(), attributes) : z3.number(),
-          addDecimalValidation(z3.instanceof(Decimal5), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(z3.string(), attributes, this.extraValidationsEnabled)
+        return z2.union([
+          this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number(),
+          addDecimalValidation(z2.instanceof(Decimal5), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(z2.string(), attributes, this.extraValidationsEnabled)
         ]);
-      }).with("DateTime", () => z3.union([
-        z3.date(),
-        z3.iso.datetime()
-      ])).with("Bytes", () => z3.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => z3.unknown());
+      }).with("DateTime", () => z2.union([
+        z2.date(),
+        z2.iso.datetime()
+      ])).with("Bytes", () => z2.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => z2.unknown());
     }
   }
   makeEnumSchema(type) {
     const enumDef = getEnum(this.schema, type);
     invariant9(enumDef, `Enum "${type}" not found in schema`);
-    return z3.enum(Object.keys(enumDef.values));
+    return z2.enum(Object.keys(enumDef.values));
   }
   makeTypeDefSchema(type) {
     const typeDef = getTypeDef(this.schema, type);
     invariant9(typeDef, `Type definition "${type}" not found in schema`);
-    const schema = z3.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    const schema = z2.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makeScalarSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -5237,7 +5230,7 @@ var InputValidator = class {
         fieldSchema
       ];
     })));
-    const finalSchema = z3.any().superRefine((value, ctx) => {
+    const finalSchema = z2.any().superRefine((value, ctx) => {
       const parseResult = schema.safeParse(value);
       if (!parseResult.success) {
         parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
@@ -5255,21 +5248,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = z3.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = z2.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = z3.union([
+          fieldSchema = z2.union([
             fieldSchema,
-            z3.strictObject({
+            z2.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = z3.union([
+          fieldSchema = z2.union([
             fieldSchema,
-            z3.strictObject({
+            z2.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -5297,7 +5290,7 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = z3.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+          fields[uniqueField.name] = z2.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
             invariant9(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
@@ -5305,7 +5298,7 @@ var InputValidator = class {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(def.type, !!def.optional, false, false);
               } else {
-                fieldSchema = z3.never();
+                fieldSchema = z2.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
@@ -5318,13 +5311,13 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = z3.custom((v) => typeof v === "function", {
+    fields["$expr"] = z2.custom((v) => typeof v === "function", {
       error: '"$expr" must be a function'
     }).optional();
-    fields["AND"] = this.orArray(z3.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = z3.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(z3.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = z3.strictObject(fields);
+    fields["AND"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    fields["OR"] = z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
+    fields["NOT"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    const baseWhere = z2.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -5363,26 +5356,26 @@ var InputValidator = class {
           }
         }
       }
-      candidates.push(z3.strictObject(fieldSchemas));
+      candidates.push(z2.strictObject(fieldSchemas));
     }
-    const recursiveSchema = z3.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
+    const recursiveSchema = z2.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
     if (array) {
-      candidates.push(z3.strictObject({
+      candidates.push(z2.strictObject({
         some: recursiveSchema,
         every: recursiveSchema,
         none: recursiveSchema
       }));
     } else {
-      candidates.push(z3.strictObject({
+      candidates.push(z2.strictObject({
         is: recursiveSchema,
         isNot: recursiveSchema
       }));
     }
     candidates.push(this.makeJsonFilterSchema(optional));
     if (optional) {
-      candidates.push(z3.null());
+      candidates.push(z2.null());
     }
-    return z3.union(candidates);
+    return z2.union(candidates);
   }
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
@@ -5390,11 +5383,11 @@ var InputValidator = class {
   makeEnumFilterSchema(enumName, optional, withAggregations, array) {
     const enumDef = getEnum(this.schema, enumName);
     invariant9(enumDef, `Enum "${enumName}" not found in schema`);
-    const baseSchema = z3.enum(Object.keys(enumDef.values));
+    const baseSchema = z2.enum(Object.keys(enumDef.values));
     if (array) {
       return this.internalMakeArrayFilterSchema(baseSchema);
     }
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
       "equals",
       "in",
       "notIn",
@@ -5404,65 +5397,65 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z3.union([
+    return z2.union([
       this.nullableIf(baseSchema, optional),
-      z3.strictObject(components)
+      z2.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
     return this.internalMakeArrayFilterSchema(this.makeScalarSchema(type));
   }
   internalMakeArrayFilterSchema(elementSchema) {
-    return z3.strictObject({
+    return z2.strictObject({
       equals: elementSchema.array().optional(),
       has: elementSchema.optional(),
       hasEvery: elementSchema.array().optional(),
       hasSome: elementSchema.array().optional(),
-      isEmpty: z3.boolean().optional()
+      isEmpty: z2.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
-    return match14(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P3.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", () => z3.never()).exhaustive();
+    return match14(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P3.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", () => z2.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
-      z3.string(),
-      z3.number(),
-      z3.boolean(),
-      z3.instanceof(JsonNullClass)
+      z2.string(),
+      z2.number(),
+      z2.boolean(),
+      z2.instanceof(JsonNullClass)
     ];
     if (forFilter) {
-      options.push(z3.instanceof(DbNullClass));
+      options.push(z2.instanceof(DbNullClass));
     } else {
       if (nullable) {
-        options.push(z3.instanceof(DbNullClass));
+        options.push(z2.instanceof(DbNullClass));
       }
     }
     if (forFilter) {
-      options.push(z3.instanceof(AnyNullClass));
+      options.push(z2.instanceof(AnyNullClass));
     }
-    const schema = z3.union([
+    const schema = z2.union([
       ...options,
-      z3.lazy(() => z3.union([
+      z2.lazy(() => z2.union([
         this.makeJsonValueSchema(false, false),
-        z3.null()
+        z2.null()
       ]).array()),
-      z3.record(z3.string(), z3.lazy(() => z3.union([
+      z2.record(z2.string(), z2.lazy(() => z2.union([
         this.makeJsonValueSchema(false, false),
-        z3.null()
+        z2.null()
       ])))
     ]);
     return this.nullableIf(schema, nullable);
   }
   makeJsonFilterSchema(optional) {
     const valueSchema = this.makeJsonValueSchema(optional, true);
-    return z3.strictObject({
-      path: z3.string().optional(),
+    return z2.strictObject({
+      path: z2.string().optional(),
       equals: valueSchema.optional(),
       not: valueSchema.optional(),
-      string_contains: z3.string().optional(),
-      string_starts_with: z3.string().optional(),
-      string_ends_with: z3.string().optional(),
+      string_contains: z2.string().optional(),
+      string_starts_with: z2.string().optional(),
+      string_ends_with: z2.string().optional(),
       mode: this.makeStringModeSchema().optional(),
       array_contains: valueSchema.optional(),
       array_starts_with: valueSchema.optional(),
@@ -5470,17 +5463,17 @@ var InputValidator = class {
     });
   }
   makeDateTimeFilterSchema(optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(z3.union([
-      z3.iso.datetime(),
-      z3.date()
-    ]), optional, () => z3.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(z2.union([
+      z2.iso.datetime(),
+      z2.date()
+    ]), optional, () => z2.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0);
   }
   makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(z3.boolean(), optional, () => z3.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(z2.boolean(), optional, () => z2.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -5488,14 +5481,14 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z3.union([
-      this.nullableIf(z3.boolean(), optional),
-      z3.strictObject(components)
+    return z2.union([
+      this.nullableIf(z2.boolean(), optional),
+      z2.strictObject(components)
     ]);
   }
   makeBytesFilterSchema(optional, withAggregations) {
-    const baseSchema = z3.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.instanceof(Uint8Array), [
+    const baseSchema = z2.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -5505,9 +5498,9 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z3.union([
+    return z2.union([
       this.nullableIf(baseSchema, optional),
-      z3.strictObject(components)
+      z2.strictObject(components)
     ]);
   }
   makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
@@ -5524,7 +5517,7 @@ var InputValidator = class {
       between: baseSchema.array().length(2).optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(z3.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(z2.number().int(), false, false).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -5549,13 +5542,13 @@ var InputValidator = class {
     return result;
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return z3.union([
+    return z2.union([
       this.nullableIf(baseSchema, optional),
-      z3.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
+      z2.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z3.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z2.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -5564,17 +5557,17 @@ var InputValidator = class {
     ] : void 0);
   }
   makeStringFilterSchema(optional, withAggregations) {
-    return z3.union([
-      this.nullableIf(z3.string(), optional),
-      z3.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(z3.string(), optional, () => z3.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+    return z2.union([
+      this.nullableIf(z2.string(), optional),
+      z2.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(z2.string(), optional, () => z2.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
           "_count",
           "_min",
           "_max"
         ] : void 0),
-        startsWith: z3.string().optional(),
-        endsWith: z3.string().optional(),
-        contains: z3.string().optional(),
+        startsWith: z2.string().optional(),
+        endsWith: z2.string().optional(),
+        contains: z2.string().optional(),
         ...this.providerSupportsCaseSensitivity ? {
           mode: this.makeStringModeSchema().optional()
         } : {}
@@ -5582,9 +5575,9 @@ var InputValidator = class {
     ]);
   }
   makeStringModeSchema() {
-    return z3.union([
-      z3.literal("default"),
-      z3.literal("insensitive")
+    return z2.union([
+      z2.literal("default"),
+      z2.literal("insensitive")
     ]);
   }
   makeSelectSchema(model) {
@@ -5595,27 +5588,27 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
       } else {
-        fields[field] = z3.boolean().optional();
+        fields[field] = z2.boolean().optional();
       }
     }
     const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof z3.ZodNever)) {
+    if (!(_countSchema instanceof z2.ZodNever)) {
       fields["_count"] = _countSchema;
     }
-    return z3.strictObject(fields);
+    return z2.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 z3.union([
-        z3.literal(true),
-        z3.strictObject({
-          select: z3.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      return z2.union([
+        z2.literal(true),
+        z2.strictObject({
+          select: z2.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: z3.union([
-              z3.boolean(),
-              z3.strictObject({
+            [fieldDef.name]: z2.union([
+              z2.boolean(),
+              z2.strictObject({
                 where: this.makeWhereSchema(fieldDef.type, false, false)
               })
             ]).optional()
@@ -5623,22 +5616,22 @@ var InputValidator = class {
         })
       ]).optional();
     } else {
-      return z3.never();
+      return z2.never();
     }
   }
   makeRelationSelectIncludeSchema(model, field) {
     const fieldDef = requireField(this.schema, model, field);
-    let objSchema = z3.strictObject({
+    let objSchema = z2.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: z3.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: z2.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
       } : {},
-      select: z3.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: z3.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
-      omit: z3.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+      select: z2.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
+      include: z2.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
+      omit: z2.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: z3.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: z2.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(),
@@ -5647,8 +5640,8 @@ var InputValidator = class {
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
-    return z3.union([
-      z3.boolean(),
+    return z2.union([
+      z2.boolean(),
       objSchema
     ]);
   }
@@ -5659,13 +5652,13 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
-          fields[field] = z3.boolean().optional();
+          fields[field] = z2.boolean().optional();
         } else {
-          fields[field] = z3.literal(true).optional();
+          fields[field] = z2.literal(true).optional();
         }
       }
     }
-    return z3.strictObject(fields);
+    return z2.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -5677,23 +5670,23 @@ var InputValidator = class {
       }
     }
     const _countSchema = this.makeCountSelectionSchema(model);
-    if (!(_countSchema instanceof z3.ZodNever)) {
+    if (!(_countSchema instanceof z2.ZodNever)) {
       fields["_count"] = _countSchema;
     }
-    return z3.strictObject(fields);
+    return z2.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = z3.union([
-      z3.literal("asc"),
-      z3.literal("desc")
+    const sort = z2.union([
+      z2.literal("asc"),
+      z2.literal("desc")
     ]);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = z3.lazy(() => {
+          fields[field] = z2.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
@@ -5705,13 +5698,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = z3.union([
+          fields[field] = z2.union([
             sort,
-            z3.strictObject({
+            z2.strictObject({
               sort,
-              nulls: z3.union([
-                z3.literal("first"),
-                z3.literal("last")
+              nulls: z2.union([
+                z2.literal("first"),
+                z2.literal("last")
               ])
             })
           ]).optional();
@@ -5729,15 +5722,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = z3.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = z2.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return z3.strictObject(fields);
+    return z2.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(z3.enum(nonRelationFields), true);
+    return this.orArray(z2.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -5746,7 +5739,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    const baseSchema = z3.strictObject({
+    const baseSchema = z2.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -5798,7 +5791,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z3.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
+        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -5824,9 +5817,9 @@ var InputValidator = class {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
           fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = z3.union([
+          fieldSchema = z2.union([
             fieldSchema,
-            z3.strictObject({
+            z2.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -5836,9 +5829,9 @@ var InputValidator = class {
         }
         if (fieldDef.optional) {
           if (fieldDef.type === "Json") {
-            fieldSchema = z3.union([
+            fieldSchema = z2.union([
               fieldSchema,
-              z3.instanceof(DbNullClass)
+              z2.instanceof(DbNullClass)
             ]);
           } else {
             fieldSchema = fieldSchema.nullable();
@@ -5850,19 +5843,19 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(uncheckedVariantFields), modelDef.attributes) : z3.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(checkedVariantFields), modelDef.attributes) : z3.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return z3.union([
+      return z2.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          z3.array(uncheckedCreateSchema)
+          z2.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          z3.array(checkedCreateSchema)
+          z2.array(checkedCreateSchema)
         ] : []
       ]);
     }
@@ -5891,11 +5884,11 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(z3.strictObject({
+      fields["update"] = array ? this.orArray(z2.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : z3.union([
-        z3.strictObject({
+      }), true).optional() : z2.union([
+        z2.strictObject({
           where: this.makeWhereSchema(fieldType, false).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
@@ -5905,21 +5898,21 @@ var InputValidator = class {
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
-      fields["upsert"] = this.orArray(z3.strictObject({
+      fields["upsert"] = this.orArray(z2.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(z3.strictObject({
+        fields["updateMany"] = this.orArray(z2.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return z3.strictObject(fields);
+    return z2.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -5931,36 +5924,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return z3.union([
-        z3.boolean(),
+      return z2.union([
+        z2.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z3.union([
-      z3.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z2.union([
+      z2.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(z3.strictObject({
+    return this.orArray(z2.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return z3.strictObject({
+    return z2.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: z3.boolean().optional()
+      skipDuplicates: z2.boolean().optional()
     });
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    const baseSchema = z3.strictObject({
+    const baseSchema = z2.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
@@ -5973,10 +5966,10 @@ var InputValidator = class {
     return schema;
   }
   makeUpdateManySchema(model) {
-    return this.mergePluginArgsSchema(z3.strictObject({
+    return this.mergePluginArgsSchema(z2.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: z3.number().int().nonnegative().optional()
+      limit: z2.number().int().nonnegative().optional()
     }), "updateMany");
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -5989,7 +5982,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    const baseSchema = z3.strictObject({
+    const baseSchema = z2.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -6025,7 +6018,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z3.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
+        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -6036,24 +6029,24 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = z3.union([
+          fieldSchema = z2.union([
             fieldSchema,
-            z3.object({
-              set: this.nullableIf(z3.number().optional(), !!fieldDef.optional).optional(),
-              increment: z3.number().optional(),
-              decrement: z3.number().optional(),
-              multiply: z3.number().optional(),
-              divide: z3.number().optional()
+            z2.object({
+              set: this.nullableIf(z2.number().optional(), !!fieldDef.optional).optional(),
+              increment: z2.number().optional(),
+              decrement: z2.number().optional(),
+              multiply: z2.number().optional(),
+              divide: z2.number().optional()
             }).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 = z3.union([
+          fieldSchema = z2.union([
             arraySchema,
-            z3.object({
+            z2.object({
               set: arraySchema.optional(),
-              push: z3.union([
+              push: z2.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -6062,9 +6055,9 @@ var InputValidator = class {
         }
         if (fieldDef.optional) {
           if (fieldDef.type === "Json") {
-            fieldSchema = z3.union([
+            fieldSchema = z2.union([
               fieldSchema,
-              z3.instanceof(DbNullClass)
+              z2.instanceof(DbNullClass)
             ]);
           } else {
             fieldSchema = fieldSchema.nullable();
@@ -6077,12 +6070,12 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(uncheckedVariantFields), modelDef.attributes) : z3.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(checkedVariantFields), modelDef.attributes) : z3.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return z3.union([
+      return z2.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -6091,7 +6084,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    const baseSchema = z3.strictObject({
+    const baseSchema = z2.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -6103,15 +6096,15 @@ var InputValidator = class {
     return schema;
   }
   makeDeleteManySchema(model) {
-    return this.mergePluginArgsSchema(z3.strictObject({
+    return this.mergePluginArgsSchema(z2.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: z3.number().int().nonnegative().optional()
+      limit: z2.number().int().nonnegative().optional()
     }), "deleteMany").optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return this.mergePluginArgsSchema(z3.strictObject({
+    return this.mergePluginArgsSchema(z2.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -6121,12 +6114,12 @@ var InputValidator = class {
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z3.union([
-      z3.literal(true),
-      z3.strictObject({
-        _all: z3.literal(true).optional(),
+    return z2.union([
+      z2.literal(true),
+      z2.strictObject({
+        _all: z2.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = z3.literal(true).optional();
+          acc[field] = z2.literal(true).optional();
           return acc;
         }, {})
       })
@@ -6135,7 +6128,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return this.mergePluginArgsSchema(z3.strictObject({
+    return this.mergePluginArgsSchema(z2.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -6149,20 +6142,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z3.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = z3.literal(true).optional();
+        acc[field] = z2.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z3.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = z3.literal(true).optional();
+        acc[field] = z2.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -6170,8 +6163,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(z3.enum(nonRelationFields), true) : z3.never();
-    const baseSchema = z3.strictObject({
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(z2.enum(nonRelationFields), true) : z2.never();
+    const baseSchema = z2.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -6245,10 +6238,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 = z3.record(z3.string(), z3.unknown());
+      schema = z2.record(z2.string(), z2.unknown());
     } else {
       schema = this.makeScalarSchema(param.type);
-      if (schema instanceof z3.ZodUnknown) {
+      if (schema instanceof z2.ZodUnknown) {
         throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
       }
     }
@@ -6280,10 +6273,10 @@ var InputValidator = class {
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return z3.number().int().nonnegative();
+    return z2.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return z3.number().int();
+    return z2.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -6295,9 +6288,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? z3.union([
+    return canBeArray ? z2.union([
       schema,
-      z3.array(schema)
+      z2.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -6338,7 +6331,7 @@ _ts_decorate([
   _ts_metadata("design:paramtypes", [
     String
   ]),
-  _ts_metadata("design:returntype", typeof z3 === "undefined" || typeof z3.ZodType === "undefined" ? Object : z3.ZodType)
+  _ts_metadata("design:returntype", typeof z2 === "undefined" || typeof z2.ZodType === "undefined" ? Object : z2.ZodType)
 ], InputValidator.prototype, "makeTypeDefSchema", null);
 _ts_decorate([
   cache(),
@@ -6698,7 +6691,7 @@ _ts_decorate([
   _ts_metadata("design:paramtypes", [
     Object
   ]),
-  _ts_metadata("design:returntype", typeof z3 === "undefined" || typeof z3.ZodType === "undefined" ? Object : z3.ZodType)
+  _ts_metadata("design:returntype", typeof z2 === "undefined" || typeof z2.ZodType === "undefined" ? Object : z2.ZodType)
 ], InputValidator.prototype, "makeProcedureParamSchema", null);
 _ts_decorate([
   cache(),
@@ -6903,7 +6896,7 @@ import { match as match15 } from "ts-pattern";
 
 // src/client/executor/name-mapper.ts
 import { invariant as invariant10 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode2, ColumnNode as ColumnNode2, ColumnUpdateNode, expressionBuilder as expressionBuilder6, ExpressionWrapper, FromNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode as ReferenceNode2, SelectAllNode, SelectionNode, TableNode as TableNode2, ValueListNode, ValueNode, ValuesNode } from "kysely";
+import { AliasNode as AliasNode2, ColumnNode as ColumnNode2, ColumnUpdateNode, expressionBuilder as expressionBuilder6, ExpressionWrapper as ExpressionWrapper3, FromNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode as ReferenceNode2, SelectAllNode, SelectionNode, TableNode as TableNode2, ValueListNode as ValueListNode3, ValueNode, ValuesNode } from "kysely";
 var QueryNameMapper = class extends OperationNodeTransformer {
   static {
     __name(this, "QueryNameMapper");
@@ -6911,6 +6904,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
   client;
   modelToTableMap = /* @__PURE__ */ new Map();
   fieldToColumnMap = /* @__PURE__ */ new Map();
+  enumTypeMap = /* @__PURE__ */ new Map();
   scopes = [];
   dialect;
   constructor(client) {
@@ -6928,14 +6922,20 @@ var QueryNameMapper = class extends 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 = [];
@@ -6954,7 +6954,7 @@ var QueryNameMapper = class extends 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: FromNode.create(processedFroms.map((f) => f.node)),
@@ -6963,16 +6963,16 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       };
     });
   }
-  transformInsertQuery(node) {
+  transformInsertQuery(node, queryId) {
     if (!node.into) {
-      return super.transformInsertQuery(node);
+      return super.transformInsertQuery(node, queryId);
     }
     const model = extractModelName(node.into);
     invariant10(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);
@@ -6995,9 +6995,9 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       selections: this.processSelections(node.selections)
     };
   }
-  transformReference(node) {
+  transformReference(node, queryId) {
     if (!ColumnNode2.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) {
@@ -7014,15 +7014,15 @@ var QueryNameMapper = class extends 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 ColumnNode2.create(mappedName);
   }
-  transformBinaryOperation(node) {
+  transformBinaryOperation(node, queryId) {
     if (ReferenceNode2.is(node.leftOperand) && ColumnNode2.is(node.leftOperand.column) && (ValueNode.is(node.rightOperand) || PrimitiveValueListNode.is(node.rightOperand))) {
       const columnNode = node.leftOperand.column;
       const resolvedScope = this.resolveFieldFromScopes(columnNode.column.name, node.leftOperand.table?.table.identifier.name);
@@ -7037,14 +7037,14 @@ var QueryNameMapper = class extends 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 || !TableNode2.is(innerTable)) {
@@ -7056,7 +7056,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       model,
       alias
     }, () => {
-      const baseResult = super.transformUpdateQuery(node);
+      const baseResult = super.transformUpdateQuery(node, queryId);
       const updates = baseResult.updates?.map((update, i) => {
         if (ColumnNode2.is(update.column)) {
           const origColumn = node.updates[i].column;
@@ -7073,7 +7073,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       };
     });
   }
-  transformDeleteQuery(node) {
+  transformDeleteQuery(node, queryId) {
     const scopes = node.from.froms.map((node2) => {
       const { alias, node: innerNode } = stripAlias(node2);
       return {
@@ -7087,12 +7087,12 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       if (TableNode2.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: FromNode.create(froms)
       };
     });
@@ -7394,7 +7394,7 @@ var QueryNameMapper = class extends OperationNodeTransformer {
         if (PrimitiveValueListNode.is(valueItems)) {
           return PrimitiveValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
         } else {
-          return ValueListNode.create(this.processEnumMappingForValues(model, columns, valueItems.values));
+          return ValueListNode3.create(this.processEnumMappingForValues(model, columns, valueItems.values));
         }
       }));
     } else if (PrimitiveValueListNode.is(values)) {
@@ -7465,12 +7465,12 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     let caseWhen;
     for (const [key, value] of Object.entries(enumValueMapping)) {
       if (!caseWhen) {
-        caseWhen = caseBuilder.when(new ExpressionWrapper(node), "=", value).then(key);
+        caseWhen = caseBuilder.when(new ExpressionWrapper3(node), "=", value).then(key);
       } else {
-        caseWhen = caseWhen.when(new ExpressionWrapper(node), "=", value).then(key);
+        caseWhen = caseWhen.when(new ExpressionWrapper3(node), "=", value).then(key);
       }
     }
-    const finalExpr = caseWhen.else(this.dialect.castText(new ExpressionWrapper(node))).end();
+    const finalExpr = caseWhen.else(this.dialect.castText(new ExpressionWrapper3(node))).end();
     if (aliasName) {
       return finalExpr.as(aliasName).toOperationNode();
     } else {
@@ -8001,7 +8001,7 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   ])).exhaustive();
   return sql6`${fieldExpr} ${sql6.raw(op)} ${searchExpr} escape ${sql6.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');
@@ -8009,11 +8009,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');
@@ -8021,9 +8019,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');
@@ -8031,7 +8029,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;
@@ -8094,7 +8092,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) => {
@@ -8110,7 +8108,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();
         }
       }
@@ -8188,6 +8186,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]) {