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

package/dist/index.cjs

@@ -32,9 +32,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AnyNull: () => AnyNull,
+  AnyNullClass: () => AnyNullClass,
   BaseCrudDialect: () => BaseCrudDialect,
   CRUD: () => CRUD,
   CRUD_EXT: () => CRUD_EXT,
+  DbNull: () => DbNull,
+  DbNullClass: () => DbNullClass,
+  JsonNull: () => JsonNull,
+  JsonNullClass: () => JsonNullClass,
   KyselyUtils: () => kysely_utils_exports,
   ORMError: () => ORMError,
   ORMErrorReason: () => ORMErrorReason,
@@ -83,10 +89,12 @@ __export(query_utils_exports, {
   isInheritedField: () => isInheritedField,
   isRelationField: () => isRelationField,
   isScalarField: () => isScalarField,
+  isTypeDef: () => isTypeDef,
   makeDefaultOrderBy: () => makeDefaultOrderBy,
   requireField: () => requireField,
   requireIdFields: () => requireIdFields,
   requireModel: () => requireModel,
+  requireTypeDef: () => requireTypeDef,
   stripAlias: () => stripAlias
 });
 var import_common_helpers = require("@zenstackhq/common-helpers");
@@ -236,6 +244,14 @@ function requireModel(schema, model) {
   return modelDef;
 }
 __name(requireModel, "requireModel");
+function requireTypeDef(schema, type) {
+  const typeDef = getTypeDef(schema, type);
+  if (!typeDef) {
+    throw createInternalError(`Type "${type}" not found in schema`, type);
+  }
+  return typeDef;
+}
+__name(requireTypeDef, "requireTypeDef");
 function getField(schema, model, field) {
   const modelDef = getModel(schema, model);
   return modelDef?.fields[field];
@@ -383,6 +399,10 @@ function getEnum(schema, type) {
   return schema.enums?.[type];
 }
 __name(getEnum, "getEnum");
+function isTypeDef(schema, type) {
+  return !!schema.typeDefs?.[type];
+}
+__name(isTypeDef, "isTypeDef");
 function buildJoinPairs(schema, model, modelAlias, relationField, relationModelAlias) {
   const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(schema, model, relationField);
   return keyPairs.map(({ fk, pk }) => {
@@ -632,6 +652,33 @@ var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_kysely3 = require("kysely");
 var import_ts_pattern3 = require("ts-pattern");
+var import_zod = __toESM(require("zod"), 1);
+
+// src/common-types.ts
+var DbNullClass = class {
+  static {
+    __name(this, "DbNullClass");
+  }
+  // @ts-ignore
+  __brand = "DbNull";
+};
+var DbNull = new DbNullClass();
+var JsonNullClass = class {
+  static {
+    __name(this, "JsonNullClass");
+  }
+  // @ts-ignore
+  __brand = "JsonNull";
+};
+var JsonNull = new JsonNullClass();
+var AnyNullClass = class {
+  static {
+    __name(this, "AnyNullClass");
+  }
+  // @ts-ignore
+  __brand = "AnyNull";
+};
+var AnyNull = new AnyNullClass();
 
 // src/client/crud/dialects/base-dialect.ts
 var import_common_helpers2 = require("@zenstackhq/common-helpers");
@@ -904,12 +951,174 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(fieldRef, fieldDef, payload);
     }
-    return (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(import_ts_pattern2.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => {
-      throw createNotSupportedError("JSON filters are not supported yet");
-    }).with("Unsupported", () => {
+    if (isTypeDef(this.schema, fieldDef.type)) {
+      return this.buildJsonFilter(fieldRef, payload, fieldDef);
+    }
+    return (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(import_ts_pattern2.P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => this.buildJsonFilter(fieldRef, payload, fieldDef)).with("Unsupported", () => {
       throw createInvalidInputError(`Unsupported field cannot be used in filters`);
     }).exhaustive();
   }
+  buildJsonFilter(receiver, filter, fieldDef) {
+    (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Json filter payload must be an object");
+    if ([
+      "path",
+      "equals",
+      "not",
+      "string_contains",
+      "string_starts_with",
+      "string_ends_with",
+      "array_contains",
+      "array_starts_with",
+      "array_ends_with"
+    ].some((k) => k in filter)) {
+      return this.buildPlainJsonFilter(receiver, filter);
+    } else if (isTypeDef(this.schema, fieldDef.type)) {
+      return this.buildTypedJsonFilter(receiver, filter, fieldDef.type, !!fieldDef.array);
+    } else {
+      throw createInvalidInputError(`Invalid JSON filter payload`);
+    }
+  }
+  buildPlainJsonFilter(receiver, filter) {
+    const clauses = [];
+    const path = filter.path;
+    const jsonReceiver = this.buildJsonPathSelection(receiver, path);
+    const stringReceiver = this.eb.cast(jsonReceiver, "text");
+    const mode = filter.mode ?? "default";
+    (0, import_common_helpers2.invariant)(mode === "default" || mode === "insensitive", "Invalid JSON filter mode");
+    for (const [key, value] of Object.entries(filter)) {
+      switch (key) {
+        case "equals": {
+          clauses.push(this.buildJsonValueFilterClause(jsonReceiver, value));
+          break;
+        }
+        case "not": {
+          clauses.push(this.eb.not(this.buildJsonValueFilterClause(jsonReceiver, value)));
+          break;
+        }
+        case "string_contains": {
+          (0, import_common_helpers2.invariant)(typeof value === "string", "string_contains value must be a string");
+          clauses.push(this.buildJsonStringFilter(stringReceiver, key, value, mode));
+          break;
+        }
+        case "string_starts_with": {
+          (0, import_common_helpers2.invariant)(typeof value === "string", "string_starts_with value must be a string");
+          clauses.push(this.buildJsonStringFilter(stringReceiver, key, value, mode));
+          break;
+        }
+        case "string_ends_with": {
+          (0, import_common_helpers2.invariant)(typeof value === "string", "string_ends_with value must be a string");
+          clauses.push(this.buildJsonStringFilter(stringReceiver, key, value, mode));
+          break;
+        }
+        case "array_contains": {
+          clauses.push(this.buildJsonArrayFilter(jsonReceiver, key, value));
+          break;
+        }
+        case "array_starts_with": {
+          clauses.push(this.buildJsonArrayFilter(jsonReceiver, key, value));
+          break;
+        }
+        case "array_ends_with": {
+          clauses.push(this.buildJsonArrayFilter(jsonReceiver, key, value));
+          break;
+        }
+        case "path":
+        case "mode":
+          break;
+        default:
+          throw createInvalidInputError(`Invalid JSON filter key: ${key}`);
+      }
+    }
+    return this.and(...clauses);
+  }
+  buildTypedJsonFilter(receiver, filter, typeDefName, array) {
+    if (array) {
+      return this.buildTypedJsonArrayFilter(receiver, filter, typeDefName);
+    } else {
+      return this.buildTypeJsonNonArrayFilter(receiver, filter, typeDefName);
+    }
+  }
+  buildTypedJsonArrayFilter(receiver, filter, typeDefName) {
+    (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Typed JSON array filter payload must be an object");
+    const makeExistsPred = /* @__PURE__ */ __name((filter2) => this.buildJsonArrayExistsPredicate(receiver, (elem) => this.buildTypedJsonFilter(elem, filter2, typeDefName, false)), "makeExistsPred");
+    const makeExistsNegatedPred = /* @__PURE__ */ __name((filter2) => this.buildJsonArrayExistsPredicate(receiver, (elem) => this.eb.not(this.buildTypedJsonFilter(elem, filter2, typeDefName, false))), "makeExistsNegatedPred");
+    const clauses = [];
+    for (const [key, value] of Object.entries(filter)) {
+      if (!value || typeof value !== "object") {
+        continue;
+      }
+      switch (key) {
+        case "some":
+          clauses.push(makeExistsPred(value));
+          break;
+        case "none":
+          clauses.push(this.eb.not(makeExistsPred(value)));
+          break;
+        case "every":
+          clauses.push(this.eb.not(makeExistsNegatedPred(value)));
+          break;
+        default:
+          (0, import_common_helpers2.invariant)(false, `Invalid typed JSON array filter key: ${key}`);
+      }
+    }
+    return this.and(...clauses);
+  }
+  buildTypeJsonNonArrayFilter(receiver, filter, typeDefName) {
+    const clauses = [];
+    if (filter === null) {
+      return this.eb(receiver, "=", "null");
+    }
+    (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Typed JSON filter payload must be an object");
+    if ("is" in filter || "isNot" in filter) {
+      if ("is" in filter && filter.is && typeof filter.is === "object") {
+        clauses.push(this.buildTypedJsonFilter(receiver, filter.is, typeDefName, false));
+      }
+      if ("isNot" in filter && filter.isNot && typeof filter.isNot === "object") {
+        clauses.push(this.eb.not(this.buildTypedJsonFilter(receiver, filter.isNot, typeDefName, false)));
+      }
+    } else {
+      const typeDef = requireTypeDef(this.schema, typeDefName);
+      for (const [key, value] of Object.entries(filter)) {
+        const fieldDef = typeDef.fields[key];
+        (0, import_common_helpers2.invariant)(fieldDef, `Field "${key}" not found in type definition "${typeDefName}"`);
+        const fieldReceiver = this.buildJsonPathSelection(receiver, `$.${key}`);
+        if (isTypeDef(this.schema, fieldDef.type)) {
+          clauses.push(this.buildTypedJsonFilter(fieldReceiver, value, fieldDef.type, !!fieldDef.array));
+        } else {
+          if (fieldDef.array) {
+            clauses.push(this.buildArrayFilter(fieldReceiver, fieldDef, value));
+          } else {
+            let _receiver = fieldReceiver;
+            if (fieldDef.type === "String") {
+              _receiver = this.eb.fn("trim", [
+                this.eb.cast(fieldReceiver, "text"),
+                import_kysely2.sql.lit('"')
+              ]);
+            }
+            clauses.push(this.buildPrimitiveFilter(_receiver, fieldDef, value));
+          }
+        }
+      }
+    }
+    return this.and(...clauses);
+  }
+  buildJsonValueFilterClause(lhs, value) {
+    if (value instanceof DbNullClass) {
+      return this.eb(lhs, "is", null);
+    } else if (value instanceof JsonNullClass) {
+      return this.eb.and([
+        this.eb(lhs, "=", "null"),
+        this.eb(lhs, "is not", null)
+      ]);
+    } else if (value instanceof AnyNullClass) {
+      return this.eb.or([
+        this.eb(lhs, "is", null),
+        this.eb(lhs, "=", "null")
+      ]);
+    } else {
+      return this.buildLiteralFilter(lhs, "Json", value);
+    }
+  }
   buildLiteralFilter(lhs, type, rhs) {
     return this.eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type, false) : rhs);
   }
@@ -980,7 +1189,9 @@ var BaseCrudDialect = class {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = (0, import_ts_pattern2.match)(key).with("contains", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", import_kysely2.sql.val(`%${value}%`)) : this.eb(fieldRef, "like", import_kysely2.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", import_kysely2.sql.val(`${value}%`)) : this.eb(fieldRef, "like", import_kysely2.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", import_kysely2.sql.val(`%${value}`)) : this.eb(fieldRef, "like", import_kysely2.sql.val(`%${value}`))).otherwise(() => {
+        (0, import_common_helpers2.invariant)(typeof value === "string", `${key} value must be a string`);
+        const escapedValue = this.escapeLikePattern(value);
+        const condition = (0, import_ts_pattern2.match)(key).with("contains", () => this.buildStringLike(fieldRef, `%${escapedValue}%`, mode === "insensitive")).with("startsWith", () => this.buildStringLike(fieldRef, `${escapedValue}%`, mode === "insensitive")).with("endsWith", () => this.buildStringLike(fieldRef, `%${escapedValue}`, mode === "insensitive")).otherwise(() => {
           throw createInvalidInputError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
@@ -990,6 +1201,19 @@ var BaseCrudDialect = class {
     }
     return this.and(...conditions);
   }
+  buildJsonStringFilter(receiver, operation, value, mode) {
+    const escapedValue = this.escapeLikePattern(value);
+    const pattern = (0, import_ts_pattern2.match)(operation).with("string_contains", () => `"%${escapedValue}%"`).with("string_starts_with", () => `"${escapedValue}%"`).with("string_ends_with", () => `"%${escapedValue}"`).exhaustive();
+    return this.buildStringLike(receiver, pattern, mode === "insensitive");
+  }
+  escapeLikePattern(pattern) {
+    return pattern.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+  }
+  buildStringLike(receiver, pattern, insensitive) {
+    const { supportsILike } = this.getStringCasingBehavior();
+    const op = insensitive && supportsILike ? "ilike" : "like";
+    return import_kysely2.sql`${receiver} ${import_kysely2.sql.raw(op)} ${import_kysely2.sql.val(pattern)} escape '\\'`;
+  }
   prepStringCasing(eb, value, mode) {
     if (!mode || mode === "default") {
       return value === null ? value : import_kysely2.sql.val(value);
@@ -1301,6 +1525,10 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "PostgresCrudDialect");
   }
+  isoDateSchema = import_zod.default.iso.datetime({
+    local: true,
+    offset: true
+  });
   constructor(schema, options) {
     super(schema, options);
   }
@@ -1311,6 +1539,13 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     if (value === void 0) {
       return value;
     }
+    if (value instanceof JsonNullClass) {
+      return "null";
+    } else if (value instanceof DbNullClass) {
+      return null;
+    } else if (value instanceof AnyNullClass) {
+      (0, import_common_helpers3.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+    }
     if (Array.isArray(value)) {
       if (type === "Json" && !forArrayField) {
         return JSON.stringify(value);
@@ -1349,7 +1584,12 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   }
   transformOutputDate(value) {
     if (typeof value === "string") {
-      return new Date(value);
+      if (this.isoDateSchema.safeParse(value).success) {
+        const hasOffset = value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
+        return new Date(hasOffset ? value : `${value}Z`);
+      } else {
+        return value;
+      }
     } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
       return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
     } else {
@@ -1502,6 +1742,35 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       return `ARRAY[${values.map((v) => typeof v === "string" ? `'${v}'` : v)}]`;
     }
   }
+  buildJsonPathSelection(receiver, path) {
+    if (path) {
+      return this.eb.fn("jsonb_path_query_first", [
+        receiver,
+        this.eb.val(path)
+      ]);
+    } else {
+      return receiver;
+    }
+  }
+  buildJsonArrayFilter(lhs, operation, value) {
+    return (0, import_ts_pattern3.match)(operation).with("array_contains", () => {
+      const v = Array.isArray(value) ? value : [
+        value
+      ];
+      return import_kysely3.sql`${lhs} @> ${import_kysely3.sql.val(JSON.stringify(v))}::jsonb`;
+    }).with("array_starts_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
+      lhs,
+      this.eb.val("0")
+    ]), "=", this.transformPrimitive(value, "Json", false))).with("array_ends_with", () => this.eb(this.eb.fn("jsonb_extract_path", [
+      lhs,
+      import_kysely3.sql`(jsonb_array_length(${lhs}) - 1)::text`
+    ]), "=", this.transformPrimitive(value, "Json", false))).exhaustive();
+  }
+  buildJsonArrayExistsPredicate(receiver, buildFilter) {
+    return this.eb.exists(this.eb.selectFrom(this.eb.fn("jsonb_array_elements", [
+      receiver
+    ]).as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
+  }
   get supportInsertWithDefault() {
     return true;
   }
@@ -1544,14 +1813,20 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (value === void 0) {
       return value;
     }
+    if (value instanceof JsonNullClass) {
+      return "null";
+    } else if (value instanceof DbNullClass) {
+      return null;
+    } else if (value instanceof AnyNullClass) {
+      (0, import_common_helpers4.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+    }
+    if (type === "Json" || this.schema.typeDefs && type in this.schema.typeDefs) {
+      return JSON.stringify(value);
+    }
     if (Array.isArray(value)) {
       return value.map((v) => this.transformPrimitive(v, type, false));
     } else {
-      if (this.schema.typeDefs && type in this.schema.typeDefs) {
-        return JSON.stringify(value);
-      } else {
-        return (0, import_ts_pattern4.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
-      }
+      return (0, import_ts_pattern4.match)(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
     }
   }
   transformOutput(value, type) {
@@ -1721,6 +1996,30 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       value2
     ]));
   }
+  buildJsonPathSelection(receiver, path) {
+    if (!path) {
+      return receiver;
+    } else {
+      return import_kysely4.sql`${receiver} -> ${this.eb.val(path)}`;
+    }
+  }
+  buildJsonArrayFilter(lhs, operation, value) {
+    return (0, import_ts_pattern4.match)(operation).with("array_contains", () => {
+      if (Array.isArray(value)) {
+        throw createNotSupportedError('SQLite "array_contains" only supports checking for a single value, not an array of values');
+      } else {
+        return import_kysely4.sql`EXISTS (SELECT 1 FROM jsonb_each(${lhs}) WHERE value = ${value})`;
+      }
+    }).with("array_starts_with", () => this.eb(this.eb.fn("json_extract", [
+      lhs,
+      this.eb.val("$[0]")
+    ]), "=", value)).with("array_ends_with", () => this.eb(import_kysely4.sql`json_extract(${lhs}, '$[' || (json_array_length(${lhs}) - 1) || ']')`, "=", value)).exhaustive();
+  }
+  buildJsonArrayExistsPredicate(receiver, buildFilter) {
+    return this.eb.exists(this.eb.selectFrom(this.eb.fn("jsonb_each", [
+      receiver
+    ]).as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
+  }
   get supportsUpdateWithLimit() {
     return false;
   }
@@ -2339,8 +2638,16 @@ var BaseOperationHandler = class {
         autoUpdatedFields.push(fieldName);
       }
     }
+    const thisEntity = await this.getEntityIds(kysely, model, combinedWhere);
+    if (!thisEntity) {
+      if (throwIfNotFound) {
+        throw createNotFoundError(model);
+      } else {
+        return null;
+      }
+    }
     if (Object.keys(finalData).length === 0) {
-      return combinedWhere;
+      return thisEntity;
     }
     let needIdRead = false;
     if (modelDef.baseModel && !this.isIdFilter(model, combinedWhere)) {
@@ -2360,9 +2667,15 @@ var BaseOperationHandler = class {
       const baseUpdateResult = await this.processBaseModelUpdate(kysely, modelDef.baseModel, combinedWhere, finalData, throwIfNotFound);
       finalData = baseUpdateResult.remainingFields;
       combinedWhere = baseUpdateResult.baseEntity;
+      if (baseUpdateResult.baseEntity) {
+        for (const [key, value] of Object.entries(baseUpdateResult.baseEntity)) {
+          if (key in thisEntity) {
+            thisEntity[key] = value;
+          }
+        }
+      }
     }
     const updateFields = {};
-    let thisEntity = void 0;
     for (const field in finalData) {
       const fieldDef = this.requireField(model, field);
       if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) {
@@ -2371,17 +2684,7 @@ var BaseOperationHandler = class {
         if (!allowRelationUpdate) {
           throw createNotSupportedError(`Relation update not allowed for field "${field}"`);
         }
-        if (!thisEntity) {
-          thisEntity = await this.getEntityIds(kysely, model, combinedWhere);
-          if (!thisEntity) {
-            if (throwIfNotFound) {
-              throw createNotFoundError(model);
-            } else {
-              return null;
-            }
-          }
-        }
-        const parentUpdates = await this.processRelationUpdates(kysely, model, field, fieldDef, thisEntity, finalData[field], throwIfNotFound);
+        const parentUpdates = await this.processRelationUpdates(kysely, model, field, fieldDef, thisEntity, finalData[field]);
         if (Object.keys(parentUpdates).length > 0) {
           Object.assign(updateFields, parentUpdates);
         }
@@ -2392,7 +2695,7 @@ var BaseOperationHandler = class {
       hasFieldUpdate = Object.keys(updateFields).some((f) => !autoUpdatedFields.includes(f));
     }
     if (!hasFieldUpdate) {
-      return combinedWhere;
+      return thisEntity;
     } else {
       fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);
       const query = kysely.updateTable(model).where(() => this.dialect.buildFilter(model, model, combinedWhere)).set(updateFields).returning(fieldsToReturn).modifyEnd(this.makeContextComment({
@@ -2571,7 +2874,7 @@ var BaseOperationHandler = class {
     const idFields = requireIdFields(this.schema, model);
     return idFields.map((f) => kysely.dynamic.ref(`${model}.${f}`));
   }
-  async processRelationUpdates(kysely, model, field, fieldDef, parentIds, args, throwIfNotFound) {
+  async processRelationUpdates(kysely, model, field, fieldDef, parentIds, args) {
     const fieldModel = fieldDef.type;
     const fromRelationContext = {
       model,
@@ -2622,6 +2925,7 @@ var BaseOperationHandler = class {
               where = void 0;
               data = item;
             }
+            const throwIfNotFound = !fieldDef.array || !!where;
             await this.update(kysely, fieldModel, where, data, fromRelationContext, true, throwIfNotFound);
           }
           break;
@@ -3631,7 +3935,7 @@ var import_common_helpers7 = require("@zenstackhq/common-helpers");
 var import_decimal4 = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
 var import_ts_pattern13 = require("ts-pattern");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/utils/zod-utils.ts
 var import_v4 = require("zod-validation-error/v4");
@@ -3644,7 +3948,7 @@ __name(formatError, "formatError");
 var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_decimal3 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern12 = require("ts-pattern");
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var import_v3 = require("zod/v3");
 function getArgValue(expr) {
   if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
@@ -3753,13 +4057,13 @@ function addBigIntValidation(schema, attributes) {
 __name(addBigIntValidation, "addBigIntValidation");
 function addDecimalValidation(schema, attributes, addExtraValidation) {
   let result = schema;
-  if (schema instanceof import_zod.z.ZodString) {
+  if (schema instanceof import_zod2.z.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
         new import_decimal3.default(v);
       } catch (err) {
         ctx.addIssue({
-          code: import_zod.z.ZodIssueCode.custom,
+          code: import_zod2.z.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
@@ -3767,7 +4071,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
-      const base = import_zod.z.number();
+      const base = import_zod2.z.number();
       const { error } = base[op](value).safeParse(v.toNumber());
       error?.issues.forEach((issue) => {
         if (op === "gt" || op === "gte") {
@@ -3972,7 +4276,7 @@ function evalCall(data, expr) {
     }
     (0, import_common_helpers6.invariant)(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const fn = (0, import_ts_pattern12.match)(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return import_zod.z.string()[fn]().safeParse(fieldArg).success;
+    return import_zod2.z.string()[fn]().safeParse(fieldArg).success;
   }).with(import_ts_pattern12.P.union("has", "hasEvery", "hasSome"), (f) => {
     (0, import_common_helpers6.invariant)(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
@@ -4110,7 +4414,7 @@ var InputValidator = class {
     if (!options.unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (options.findOne) {
-        fields["take"] = import_zod2.z.literal(1).optional();
+        fields["take"] = import_zod3.z.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
       }
@@ -4118,7 +4422,7 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    let result = import_zod2.z.strictObject(fields);
+    let result = import_zod3.z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4126,25 +4430,25 @@ var InputValidator = class {
     }
     return result;
   }
-  makePrimitiveSchema(type, attributes) {
+  makeScalarSchema(type, attributes) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefSchema(type);
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod2.z.string(), attributes) : import_zod2.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number()).with("Boolean", () => import_zod2.z.boolean()).with("BigInt", () => import_zod2.z.union([
-        this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number().int(), attributes) : import_zod2.z.number().int(),
-        this.extraValidationsEnabled ? addBigIntValidation(import_zod2.z.bigint(), attributes) : import_zod2.z.bigint()
+      return (0, import_ts_pattern13.match)(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(import_zod3.z.string(), attributes) : import_zod3.z.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number()).with("Boolean", () => import_zod3.z.boolean()).with("BigInt", () => import_zod3.z.union([
+        this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number().int(), attributes) : import_zod3.z.number().int(),
+        this.extraValidationsEnabled ? addBigIntValidation(import_zod3.z.bigint(), attributes) : import_zod3.z.bigint()
       ])).with("Decimal", () => {
-        return import_zod2.z.union([
-          this.extraValidationsEnabled ? addNumberValidation(import_zod2.z.number(), attributes) : import_zod2.z.number(),
-          addDecimalValidation(import_zod2.z.instanceof(import_decimal4.default), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(import_zod2.z.string(), attributes, this.extraValidationsEnabled)
+        return import_zod3.z.union([
+          this.extraValidationsEnabled ? addNumberValidation(import_zod3.z.number(), attributes) : import_zod3.z.number(),
+          addDecimalValidation(import_zod3.z.instanceof(import_decimal4.default), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(import_zod3.z.string(), attributes, this.extraValidationsEnabled)
         ]);
-      }).with("DateTime", () => import_zod2.z.union([
-        import_zod2.z.date(),
-        import_zod2.z.string().datetime()
-      ])).with("Bytes", () => import_zod2.z.instanceof(Uint8Array)).otherwise(() => import_zod2.z.unknown());
+      }).with("DateTime", () => import_zod3.z.union([
+        import_zod3.z.date(),
+        import_zod3.z.iso.datetime()
+      ])).with("Bytes", () => import_zod3.z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => import_zod3.z.unknown());
     }
   }
   makeEnumSchema(type) {
@@ -4158,7 +4462,7 @@ var InputValidator = class {
     }
     const enumDef = getEnum(this.schema, type);
     (0, import_common_helpers7.invariant)(enumDef, `Enum "${type}" not found in schema`);
-    schema = import_zod2.z.enum(Object.keys(enumDef.values));
+    schema = import_zod3.z.enum(Object.keys(enumDef.values));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4174,21 +4478,24 @@ var InputValidator = class {
     }
     const typeDef = getTypeDef(this.schema, type);
     (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
-    schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
-      let fieldSchema = this.makePrimitiveSchema(def.type);
+    schema = import_zod3.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+      let fieldSchema = this.makeScalarSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
       }
       if (def.optional) {
-        fieldSchema = fieldSchema.optional();
+        fieldSchema = fieldSchema.nullish();
       }
       return [
         field,
         fieldSchema
       ];
     })));
-    this.setSchemaCache(key, schema);
-    return schema;
+    const finalSchema = import_zod3.z.custom((v) => {
+      return schema.safeParse(v).success;
+    });
+    this.setSchemaCache(key, finalSchema);
+    return finalSchema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
     const modelDef = requireModel(this.schema, model);
@@ -4200,21 +4507,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = import_zod3.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4228,6 +4535,8 @@ var InputValidator = class {
           }
         } else if (fieldDef.array) {
           fieldSchema = this.makeArrayFilterSchema(fieldDef.type);
+        } else if (this.isTypeDefType(fieldDef.type)) {
+          fieldSchema = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array);
         } else {
           fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations);
         }
@@ -4240,7 +4549,7 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = import_zod2.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+          fields[uniqueField.name] = import_zod3.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
             (0, import_common_helpers7.invariant)(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
@@ -4248,7 +4557,7 @@ var InputValidator = class {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
               } else {
-                fieldSchema = import_zod2.z.never();
+                fieldSchema = import_zod3.z.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
@@ -4261,11 +4570,11 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = import_zod2.z.custom((v) => typeof v === "function").optional();
-    fields["AND"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = import_zod2.z.strictObject(fields);
+    fields["$expr"] = import_zod3.z.custom((v) => typeof v === "function").optional();
+    fields["AND"] = this.orArray(import_zod3.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    fields["OR"] = import_zod3.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
+    fields["NOT"] = this.orArray(import_zod3.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    const baseWhere = import_zod3.z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4284,9 +4593,55 @@ var InputValidator = class {
     }
     return result;
   }
+  makeTypedJsonFilterSchema(type, optional, array) {
+    const typeDef = getTypeDef(this.schema, type);
+    (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    const candidates = [];
+    if (!array) {
+      const fieldSchemas = {};
+      for (const [fieldName, fieldDef] of Object.entries(typeDef.fields)) {
+        if (this.isTypeDefType(fieldDef.type)) {
+          fieldSchemas[fieldName] = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array).optional();
+        } else {
+          if (fieldDef.array) {
+            fieldSchemas[fieldName] = this.makeArrayFilterSchema(fieldDef.type).optional();
+          } else {
+            const enumDef = getEnum(this.schema, fieldDef.type);
+            if (enumDef) {
+              fieldSchemas[fieldName] = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, false).optional();
+            } else {
+              fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, false).optional();
+            }
+          }
+        }
+      }
+      candidates.push(import_zod3.z.strictObject(fieldSchemas));
+    }
+    const recursiveSchema = import_zod3.z.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
+    if (array) {
+      candidates.push(import_zod3.z.strictObject({
+        some: recursiveSchema,
+        every: recursiveSchema,
+        none: recursiveSchema
+      }));
+    } else {
+      candidates.push(import_zod3.z.strictObject({
+        is: recursiveSchema,
+        isNot: recursiveSchema
+      }));
+    }
+    candidates.push(this.makeJsonFilterSchema(optional));
+    if (optional) {
+      candidates.push(import_zod3.z.null());
+    }
+    return import_zod3.z.union(candidates);
+  }
+  isTypeDefType(type) {
+    return this.schema.typeDefs && type in this.schema.typeDefs;
+  }
   makeEnumFilterSchema(enumDef, optional, withAggregations) {
-    const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+    const baseSchema = import_zod3.z.enum(Object.keys(enumDef.values));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -4296,41 +4651,80 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod2.z.union([
+    return import_zod3.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(components)
+      import_zod3.z.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
-    return import_zod2.z.strictObject({
-      equals: this.makePrimitiveSchema(type).array().optional(),
-      has: this.makePrimitiveSchema(type).optional(),
-      hasEvery: this.makePrimitiveSchema(type).array().optional(),
-      hasSome: this.makePrimitiveSchema(type).array().optional(),
-      isEmpty: import_zod2.z.boolean().optional()
+    return import_zod3.z.strictObject({
+      equals: this.makeScalarSchema(type).array().optional(),
+      has: this.makeScalarSchema(type).optional(),
+      hasEvery: this.makeScalarSchema(type).array().optional(),
+      hasSome: this.makeScalarSchema(type).array().optional(),
+      isEmpty: import_zod3.z.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
-    if (this.schema.typeDefs && type in this.schema.typeDefs) {
-      return this.makeTypeDefFilterSchema(type, optional);
-    }
-    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => import_zod2.z.any()).with("Unsupported", () => import_zod2.z.never()).exhaustive();
-  }
-  makeTypeDefFilterSchema(_type, _optional) {
-    return import_zod2.z.never();
+    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.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();
+  }
+  makeJsonValueSchema(nullable, forFilter) {
+    const options = [
+      import_zod3.z.string(),
+      import_zod3.z.number(),
+      import_zod3.z.boolean(),
+      import_zod3.z.instanceof(JsonNullClass)
+    ];
+    if (forFilter) {
+      options.push(import_zod3.z.instanceof(DbNullClass));
+    } else {
+      if (nullable) {
+        options.push(import_zod3.z.instanceof(DbNullClass));
+      }
+    }
+    if (forFilter) {
+      options.push(import_zod3.z.instanceof(AnyNullClass));
+    }
+    const schema = import_zod3.z.union([
+      ...options,
+      import_zod3.z.lazy(() => import_zod3.z.union([
+        this.makeJsonValueSchema(false, false),
+        import_zod3.z.null()
+      ]).array()),
+      import_zod3.z.record(import_zod3.z.string(), import_zod3.z.lazy(() => import_zod3.z.union([
+        this.makeJsonValueSchema(false, false),
+        import_zod3.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(),
+      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(),
+      mode: this.makeStringModeSchema().optional(),
+      array_contains: valueSchema.optional(),
+      array_starts_with: valueSchema.optional(),
+      array_ends_with: valueSchema.optional()
+    });
   }
   makeDateTimeFilterSchema(optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod2.z.union([
-      import_zod2.z.string().datetime(),
-      import_zod2.z.date()
-    ]), optional, () => import_zod2.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(import_zod3.z.union([
+      import_zod3.z.iso.datetime(),
+      import_zod3.z.date()
+    ]), optional, () => import_zod3.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0);
   }
   makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(import_zod2.z.boolean(), optional, () => import_zod2.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(import_zod3.z.boolean(), optional, () => import_zod3.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -4338,14 +4732,14 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod2.z.union([
-      this.nullableIf(import_zod2.z.boolean(), optional),
-      import_zod2.z.strictObject(components)
+    return import_zod3.z.union([
+      this.nullableIf(import_zod3.z.boolean(), optional),
+      import_zod3.z.strictObject(components)
     ]);
   }
   makeBytesFilterSchema(optional, withAggregations) {
-    const baseSchema = import_zod2.z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.instanceof(Uint8Array), [
+    const baseSchema = import_zod3.z.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -4355,9 +4749,9 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return import_zod2.z.union([
+    return import_zod3.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(components)
+      import_zod3.z.strictObject(components)
     ]);
   }
   makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
@@ -4373,7 +4767,7 @@ var InputValidator = class {
       gte: baseSchema.optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(import_zod2.z.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(import_zod3.z.number().int(), false, false).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -4398,13 +4792,13 @@ var InputValidator = class {
     return result;
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return import_zod2.z.union([
+    return import_zod3.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
+      import_zod3.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -4413,17 +4807,17 @@ var InputValidator = class {
     ] : void 0);
   }
   makeStringFilterSchema(optional, withAggregations) {
-    return import_zod2.z.union([
-      this.nullableIf(import_zod2.z.string(), optional),
-      import_zod2.z.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(import_zod2.z.string(), optional, () => import_zod2.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+    return import_zod3.z.union([
+      this.nullableIf(import_zod3.z.string(), optional),
+      import_zod3.z.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(import_zod3.z.string(), optional, () => import_zod3.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
           "_count",
           "_min",
           "_max"
         ] : void 0),
-        startsWith: import_zod2.z.string().optional(),
-        endsWith: import_zod2.z.string().optional(),
-        contains: import_zod2.z.string().optional(),
+        startsWith: import_zod3.z.string().optional(),
+        endsWith: import_zod3.z.string().optional(),
+        contains: import_zod3.z.string().optional(),
         ...this.providerSupportsCaseSensitivity ? {
           mode: this.makeStringModeSchema().optional()
         } : {}
@@ -4431,9 +4825,9 @@ var InputValidator = class {
     ]);
   }
   makeStringModeSchema() {
-    return import_zod2.z.union([
-      import_zod2.z.literal("default"),
-      import_zod2.z.literal("insensitive")
+    return import_zod3.z.union([
+      import_zod3.z.literal("default"),
+      import_zod3.z.literal("insensitive")
     ]);
   }
   makeSelectSchema(model) {
@@ -4444,26 +4838,26 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
       } else {
-        fields[field] = import_zod2.z.boolean().optional();
+        fields[field] = import_zod3.z.boolean().optional();
       }
     }
     const _countSchema = this.makeCountSelectionSchema(modelDef);
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeCountSelectionSchema(modelDef) {
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
-      return import_zod2.z.union([
-        import_zod2.z.literal(true),
-        import_zod2.z.strictObject({
-          select: import_zod2.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      return import_zod3.z.union([
+        import_zod3.z.literal(true),
+        import_zod3.z.strictObject({
+          select: import_zod3.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: import_zod2.z.union([
-              import_zod2.z.boolean(),
-              import_zod2.z.strictObject({
+            [fieldDef.name]: import_zod3.z.union([
+              import_zod3.z.boolean(),
+              import_zod3.z.strictObject({
                 where: this.makeWhereSchema(fieldDef.type, false, false)
               })
             ]).optional()
@@ -4475,17 +4869,17 @@ var InputValidator = class {
     }
   }
   makeRelationSelectIncludeSchema(fieldDef) {
-    let objSchema = import_zod2.z.strictObject({
+    let objSchema = import_zod3.z.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: import_zod3.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
       } : {},
-      select: import_zod2.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: import_zod2.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
-      omit: import_zod2.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+      select: import_zod3.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
+      include: import_zod3.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
+      omit: import_zod3.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: import_zod2.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: import_zod3.z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
         skip: this.makeSkipSchema().optional(),
         take: this.makeTakeSchema().optional(),
         cursor: this.makeCursorSchema(fieldDef.type).optional(),
@@ -4494,8 +4888,8 @@ var InputValidator = class {
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
-    return import_zod2.z.union([
-      import_zod2.z.boolean(),
+    return import_zod3.z.union([
+      import_zod3.z.boolean(),
       objSchema
     ]);
   }
@@ -4506,13 +4900,13 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
-          fields[field] = import_zod2.z.boolean().optional();
+          fields[field] = import_zod3.z.boolean().optional();
         } else {
-          fields[field] = import_zod2.z.literal(true).optional();
+          fields[field] = import_zod3.z.literal(true).optional();
         }
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4527,20 +4921,20 @@ var InputValidator = class {
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = import_zod2.z.union([
-      import_zod2.z.literal("asc"),
-      import_zod2.z.literal("desc")
+    const sort = import_zod3.z.union([
+      import_zod3.z.literal("asc"),
+      import_zod3.z.literal("desc")
     ]);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = import_zod2.z.lazy(() => {
+          fields[field] = import_zod3.z.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
@@ -4552,13 +4946,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = import_zod2.z.union([
+          fields[field] = import_zod3.z.union([
             sort,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               sort,
-              nulls: import_zod2.z.union([
-                import_zod2.z.literal("first"),
-                import_zod2.z.literal("last")
+              nulls: import_zod3.z.union([
+                import_zod3.z.literal("first"),
+                import_zod3.z.literal("last")
               ])
             })
           ]).optional();
@@ -4576,15 +4970,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = import_zod2.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = import_zod3.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    return this.orArray(import_zod2.z.enum(nonRelationFields), true);
+    return this.orArray(import_zod3.z.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -4593,7 +4987,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4643,7 +5037,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
+        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -4666,12 +5060,12 @@ var InputValidator = class {
           uncheckedVariantFields[field] = fieldSchema;
         }
       } else {
-        let fieldSchema = this.makePrimitiveSchema(fieldDef.type, fieldDef.attributes);
+        let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
           fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.strictObject({
+            import_zod3.z.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -4680,7 +5074,14 @@ var InputValidator = class {
           fieldSchema = fieldSchema.optional();
         }
         if (fieldDef.optional) {
-          fieldSchema = fieldSchema.nullable();
+          if (fieldDef.type === "Json") {
+            fieldSchema = import_zod3.z.union([
+              fieldSchema,
+              import_zod3.z.instanceof(DbNullClass)
+            ]);
+          } else {
+            fieldSchema = fieldSchema.nullable();
+          }
         }
         uncheckedVariantFields[field] = fieldSchema;
         if (!fieldDef.foreignKeyFor) {
@@ -4688,19 +5089,19 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return import_zod2.z.union([
+      return import_zod3.z.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          import_zod2.z.array(uncheckedCreateSchema)
+          import_zod3.z.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          import_zod2.z.array(checkedCreateSchema)
+          import_zod3.z.array(checkedCreateSchema)
         ] : []
       ]);
     }
@@ -4728,12 +5129,12 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(import_zod2.z.strictObject({
-        where: this.makeWhereSchema(fieldType, true).optional(),
+      fields["update"] = array ? this.orArray(import_zod3.z.strictObject({
+        where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : import_zod2.z.union([
-        import_zod2.z.strictObject({
-          where: this.makeWhereSchema(fieldType, true).optional(),
+      }), true).optional() : import_zod3.z.union([
+        import_zod3.z.strictObject({
+          where: this.makeWhereSchema(fieldType, false).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
@@ -4742,21 +5143,21 @@ var InputValidator = class {
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
-      fields["upsert"] = this.orArray(import_zod2.z.strictObject({
+      fields["upsert"] = this.orArray(import_zod3.z.strictObject({
         where: upsertWhere,
         create: this.makeCreateDataSchema(fieldType, false, withoutFields),
         update: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional();
       if (array) {
         fields["set"] = this.makeSetDataSchema(fieldType, true).optional();
-        fields["updateMany"] = this.orArray(import_zod2.z.strictObject({
+        fields["updateMany"] = this.orArray(import_zod3.z.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return import_zod2.z.strictObject(fields);
+    return import_zod3.z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4768,36 +5169,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return import_zod2.z.union([
-        import_zod2.z.boolean(),
+      return import_zod3.z.union([
+        import_zod3.z.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod2.z.union([
-      import_zod2.z.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod3.z.union([
+      import_zod3.z.boolean(),
       this.makeWhereSchema(model, uniqueFilter)
     ]);
   }
   makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
     const whereSchema = this.makeWhereSchema(model, true);
     const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(import_zod2.z.strictObject({
+    return this.orArray(import_zod3.z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return import_zod2.z.strictObject({
+    return import_zod3.z.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: import_zod2.z.boolean().optional()
+      skipDuplicates: import_zod3.z.boolean().optional()
     });
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
@@ -4809,10 +5210,10 @@ var InputValidator = class {
     return schema;
   }
   makeUpdateManySchema(model) {
-    return import_zod2.z.strictObject({
+    return import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: import_zod2.z.number().int().nonnegative().optional()
+      limit: import_zod3.z.number().int().nonnegative().optional()
     });
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -4825,7 +5226,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -4860,7 +5261,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod2.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
+        let fieldSchema = import_zod3.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -4869,26 +5270,26 @@ var InputValidator = class {
           uncheckedVariantFields[field] = fieldSchema;
         }
       } else {
-        let fieldSchema = this.makePrimitiveSchema(fieldDef.type, fieldDef.attributes);
+        let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             fieldSchema,
-            import_zod2.z.object({
-              set: this.nullableIf(import_zod2.z.number().optional(), !!fieldDef.optional).optional(),
-              increment: import_zod2.z.number().optional(),
-              decrement: import_zod2.z.number().optional(),
-              multiply: import_zod2.z.number().optional(),
-              divide: import_zod2.z.number().optional()
+            import_zod3.z.object({
+              set: this.nullableIf(import_zod3.z.number().optional(), !!fieldDef.optional).optional(),
+              increment: import_zod3.z.number().optional(),
+              decrement: import_zod3.z.number().optional(),
+              multiply: import_zod3.z.number().optional(),
+              divide: import_zod3.z.number().optional()
             }).refine((v) => Object.keys(v).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided')
           ]);
         }
         if (fieldDef.array) {
           const arraySchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = import_zod2.z.union([
+          fieldSchema = import_zod3.z.union([
             arraySchema,
-            import_zod2.z.object({
+            import_zod3.z.object({
               set: arraySchema.optional(),
-              push: import_zod2.z.union([
+              push: import_zod3.z.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -4896,7 +5297,14 @@ var InputValidator = class {
           ]);
         }
         if (fieldDef.optional) {
-          fieldSchema = fieldSchema.nullable();
+          if (fieldDef.type === "Json") {
+            fieldSchema = import_zod3.z.union([
+              fieldSchema,
+              import_zod3.z.instanceof(DbNullClass)
+            ]);
+          } else {
+            fieldSchema = fieldSchema.nullable();
+          }
         }
         fieldSchema = fieldSchema.optional();
         uncheckedVariantFields[field] = fieldSchema;
@@ -4905,12 +5313,12 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod2.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod2.z.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(uncheckedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(import_zod3.z.strictObject(checkedVariantFields), modelDef.attributes) : import_zod3.z.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return import_zod2.z.union([
+      return import_zod3.z.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -4919,7 +5327,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    let schema = import_zod2.z.strictObject({
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4930,15 +5338,15 @@ var InputValidator = class {
     return schema;
   }
   makeDeleteManySchema(model) {
-    return import_zod2.z.object({
+    return import_zod3.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: import_zod2.z.number().int().nonnegative().optional()
+      limit: import_zod3.z.number().int().nonnegative().optional()
     }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return import_zod2.z.object({
+    return import_zod3.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4948,12 +5356,12 @@ var InputValidator = class {
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.union([
-      import_zod2.z.literal(true),
-      import_zod2.z.strictObject({
-        _all: import_zod2.z.literal(true).optional(),
+    return import_zod3.z.union([
+      import_zod3.z.literal(true),
+      import_zod3.z.strictObject({
+        _all: import_zod3.z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = import_zod2.z.literal(true).optional();
+          acc[field] = import_zod3.z.literal(true).optional();
           return acc;
         }, {})
       })
@@ -4962,7 +5370,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return import_zod2.z.object({
+    return import_zod3.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4976,20 +5384,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod3.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = import_zod2.z.literal(true).optional();
+        acc[field] = import_zod3.z.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod2.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod3.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = import_zod2.z.literal(true).optional();
+        acc[field] = import_zod3.z.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -4997,8 +5405,8 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod2.z.enum(nonRelationFields), true) : import_zod2.z.never();
-    let schema = import_zod2.z.strictObject({
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod3.z.enum(nonRelationFields), true) : import_zod3.z.never();
+    let schema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -5065,10 +5473,10 @@ var InputValidator = class {
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return import_zod2.z.number().int().nonnegative();
+    return import_zod3.z.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return import_zod2.z.number().int();
+    return import_zod3.z.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -5080,9 +5488,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? import_zod2.z.union([
+    return canBeArray ? import_zod3.z.union([
       schema,
-      import_zod2.z.array(schema)
+      import_zod3.z.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -6180,18 +6588,19 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   } else {
     op = "like";
   }
+  const escapedSearch = import_kysely8.sql`REPLACE(REPLACE(REPLACE(CAST(${searchExpr} as text), '\\', '\\\\'), '%', '\\%'), '_', '\\_')`;
   searchExpr = (0, import_ts_pattern15.match)(method).with("contains", () => eb.fn("CONCAT", [
     import_kysely8.sql.lit("%"),
-    import_kysely8.sql`CAST(${searchExpr} as text)`,
+    escapedSearch,
     import_kysely8.sql.lit("%")
   ])).with("startsWith", () => eb.fn("CONCAT", [
-    import_kysely8.sql`CAST(${searchExpr} as text)`,
+    escapedSearch,
     import_kysely8.sql.lit("%")
   ])).with("endsWith", () => eb.fn("CONCAT", [
     import_kysely8.sql.lit("%"),
-    import_kysely8.sql`CAST(${searchExpr} as text)`
+    escapedSearch
   ])).exhaustive();
-  return eb(fieldExpr, op, searchExpr);
+  return import_kysely8.sql`${fieldExpr} ${import_kysely8.sql.raw(op)} ${searchExpr} escape '\\'`;
 }, "textMatch");
 var has = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2] = args;
@@ -7422,9 +7831,15 @@ var MatchingExpressionVisitor = class extends ExpressionVisitor {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AnyNull,
+  AnyNullClass,
   BaseCrudDialect,
   CRUD,
   CRUD_EXT,
+  DbNull,
+  DbNullClass,
+  JsonNull,
+  JsonNullClass,
   KyselyUtils,
   ORMError,
   ORMErrorReason,