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

package/dist/index.js

@@ -52,10 +52,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
 });
 import { invariant } from "@zenstackhq/common-helpers";
@@ -206,6 +208,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];
@@ -353,6 +363,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 }) => {
@@ -602,6 +616,33 @@ import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
 import { sql as sql2 } from "kysely";
 import { match as match3 } from "ts-pattern";
+import z from "zod";
+
+// 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
 import { enumerate, invariant as invariant2, isPlainObject } from "@zenstackhq/common-helpers";
@@ -874,12 +915,174 @@ var BaseCrudDialect = class {
     if (isEnum(this.schema, fieldDef.type)) {
       return this.buildEnumFilter(fieldRef, fieldDef, payload);
     }
-    return match2(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(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 match2(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(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) {
+    invariant2(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";
+    invariant2(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": {
+          invariant2(typeof value === "string", "string_contains value must be a string");
+          clauses.push(this.buildJsonStringFilter(stringReceiver, key, value, mode));
+          break;
+        }
+        case "string_starts_with": {
+          invariant2(typeof value === "string", "string_starts_with value must be a string");
+          clauses.push(this.buildJsonStringFilter(stringReceiver, key, value, mode));
+          break;
+        }
+        case "string_ends_with": {
+          invariant2(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) {
+    invariant2(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:
+          invariant2(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");
+    }
+    invariant2(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];
+        invariant2(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"),
+                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);
   }
@@ -950,7 +1153,9 @@ var BaseCrudDialect = class {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = match2(key).with("contains", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", sql.val(`%${value}%`)) : this.eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", sql.val(`${value}%`)) : this.eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? this.eb(fieldRef, "ilike", sql.val(`%${value}`)) : this.eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
+        invariant2(typeof value === "string", `${key} value must be a string`);
+        const escapedValue = this.escapeLikePattern(value);
+        const condition = match2(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) {
@@ -960,6 +1165,19 @@ var BaseCrudDialect = class {
     }
     return this.and(...conditions);
   }
+  buildJsonStringFilter(receiver, operation, value, mode) {
+    const escapedValue = this.escapeLikePattern(value);
+    const pattern = match2(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 sql`${receiver} ${sql.raw(op)} ${sql.val(pattern)} escape '\\'`;
+  }
   prepStringCasing(eb, value, mode) {
     if (!mode || mode === "default") {
       return value === null ? value : sql.val(value);
@@ -1271,6 +1489,10 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "PostgresCrudDialect");
   }
+  isoDateSchema = z.iso.datetime({
+    local: true,
+    offset: true
+  });
   constructor(schema, options) {
     super(schema, options);
   }
@@ -1281,6 +1503,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) {
+      invariant3(false, "should not reach here: AnyNull is not a valid input value");
+    }
     if (Array.isArray(value)) {
       if (type === "Json" && !forArrayField) {
         return JSON.stringify(value);
@@ -1319,7 +1548,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 {
@@ -1472,6 +1706,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 match3(operation).with("array_contains", () => {
+      const v = Array.isArray(value) ? value : [
+        value
+      ];
+      return sql2`${lhs} @> ${sql2.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,
+      sql2`(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;
   }
@@ -1514,14 +1777,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) {
+      invariant4(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 match4(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 match4(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) {
@@ -1691,6 +1960,30 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       value2
     ]));
   }
+  buildJsonPathSelection(receiver, path) {
+    if (!path) {
+      return receiver;
+    } else {
+      return sql3`${receiver} -> ${this.eb.val(path)}`;
+    }
+  }
+  buildJsonArrayFilter(lhs, operation, value) {
+    return match4(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 sql3`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(sql3`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;
   }
@@ -2309,8 +2602,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)) {
@@ -2330,9 +2631,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)) {
@@ -2341,17 +2648,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);
         }
@@ -2362,7 +2659,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({
@@ -2541,7 +2838,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,
@@ -2592,6 +2889,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;
@@ -3601,7 +3899,7 @@ import { enumerate as enumerate3, invariant as invariant7 } from "@zenstackhq/co
 import Decimal4 from "decimal.js";
 import stableStringify from "json-stable-stringify";
 import { match as match13, P as P3 } from "ts-pattern";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/utils/zod-utils.ts
 import { fromError } from "zod-validation-error/v4";
@@ -3614,7 +3912,7 @@ __name(formatError, "formatError");
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import Decimal3 from "decimal.js";
 import { match as match12, P as P2 } from "ts-pattern";
-import { z } from "zod";
+import { z as z2 } from "zod";
 import { ZodIssueCode } from "zod/v3";
 function getArgValue(expr) {
   if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
@@ -3723,13 +4021,13 @@ function addBigIntValidation(schema, attributes) {
 __name(addBigIntValidation, "addBigIntValidation");
 function addDecimalValidation(schema, attributes, addExtraValidation) {
   let result = schema;
-  if (schema instanceof z.ZodString) {
+  if (schema instanceof z2.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
         new Decimal3(v);
       } catch (err) {
         ctx.addIssue({
-          code: z.ZodIssueCode.custom,
+          code: z2.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
@@ -3737,7 +4035,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
-      const base = z.number();
+      const base = z2.number();
       const { error } = base[op](value).safeParse(v.toNumber());
       error?.issues.forEach((issue) => {
         if (op === "gt" || op === "gte") {
@@ -3942,7 +4240,7 @@ function evalCall(data, expr) {
     }
     invariant6(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const fn = match12(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return z.string()[fn]().safeParse(fieldArg).success;
+    return z2.string()[fn]().safeParse(fieldArg).success;
   }).with(P2.union("has", "hasEvery", "hasSome"), (f) => {
     invariant6(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
@@ -4080,7 +4378,7 @@ var InputValidator = class {
     if (!options.unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (options.findOne) {
-        fields["take"] = z2.literal(1).optional();
+        fields["take"] = z3.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
       }
@@ -4088,7 +4386,7 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    let result = z2.strictObject(fields);
+    let result = z3.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4096,25 +4394,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 match13(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()
+      return match13(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()
       ])).with("Decimal", () => {
-        return z2.union([
-          this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number(),
-          addDecimalValidation(z2.instanceof(Decimal4), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(z2.string(), attributes, this.extraValidationsEnabled)
+        return z3.union([
+          this.extraValidationsEnabled ? addNumberValidation(z3.number(), attributes) : z3.number(),
+          addDecimalValidation(z3.instanceof(Decimal4), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(z3.string(), attributes, this.extraValidationsEnabled)
         ]);
-      }).with("DateTime", () => z2.union([
-        z2.date(),
-        z2.string().datetime()
-      ])).with("Bytes", () => z2.instanceof(Uint8Array)).otherwise(() => z2.unknown());
+      }).with("DateTime", () => z3.union([
+        z3.date(),
+        z3.iso.datetime()
+      ])).with("Bytes", () => z3.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema(false, false)).otherwise(() => z3.unknown());
     }
   }
   makeEnumSchema(type) {
@@ -4128,7 +4426,7 @@ var InputValidator = class {
     }
     const enumDef = getEnum(this.schema, type);
     invariant7(enumDef, `Enum "${type}" not found in schema`);
-    schema = z2.enum(Object.keys(enumDef.values));
+    schema = z3.enum(Object.keys(enumDef.values));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4144,21 +4442,24 @@ var InputValidator = class {
     }
     const typeDef = getTypeDef(this.schema, type);
     invariant7(typeDef, `Type definition "${type}" not found in schema`);
-    schema = z2.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
-      let fieldSchema = this.makePrimitiveSchema(def.type);
+    schema = z3.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 = z3.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);
@@ -4170,21 +4471,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = z2.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = z3.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.strictObject({
+            z3.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.strictObject({
+            z3.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4198,6 +4499,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);
         }
@@ -4210,7 +4513,7 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = z2.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+          fields[uniqueField.name] = z3.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
             invariant7(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
@@ -4218,7 +4521,7 @@ var InputValidator = class {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
               } else {
-                fieldSchema = z2.never();
+                fieldSchema = z3.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
@@ -4231,11 +4534,11 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = z2.custom((v) => typeof v === "function").optional();
-    fields["AND"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = z2.strictObject(fields);
+    fields["$expr"] = z3.custom((v) => typeof v === "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);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4254,9 +4557,55 @@ var InputValidator = class {
     }
     return result;
   }
+  makeTypedJsonFilterSchema(type, optional, array) {
+    const typeDef = getTypeDef(this.schema, type);
+    invariant7(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(z3.strictObject(fieldSchemas));
+    }
+    const recursiveSchema = z3.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
+    if (array) {
+      candidates.push(z3.strictObject({
+        some: recursiveSchema,
+        every: recursiveSchema,
+        none: recursiveSchema
+      }));
+    } else {
+      candidates.push(z3.strictObject({
+        is: recursiveSchema,
+        isNot: recursiveSchema
+      }));
+    }
+    candidates.push(this.makeJsonFilterSchema(optional));
+    if (optional) {
+      candidates.push(z3.null());
+    }
+    return z3.union(candidates);
+  }
+  isTypeDefType(type) {
+    return this.schema.typeDefs && type in this.schema.typeDefs;
+  }
   makeEnumFilterSchema(enumDef, optional, withAggregations) {
-    const baseSchema = z2.enum(Object.keys(enumDef.values));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+    const baseSchema = z3.enum(Object.keys(enumDef.values));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -4266,41 +4615,80 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z2.union([
+    return z3.union([
       this.nullableIf(baseSchema, optional),
-      z2.strictObject(components)
+      z3.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
-    return z2.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: z2.boolean().optional()
+    return z3.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: z3.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
-    if (this.schema.typeDefs && type in this.schema.typeDefs) {
-      return this.makeTypeDefFilterSchema(type, optional);
-    }
-    return match13(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P3.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", () => z2.any()).with("Unsupported", () => z2.never()).exhaustive();
-  }
-  makeTypeDefFilterSchema(_type, _optional) {
-    return z2.never();
+    return match13(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();
+  }
+  makeJsonValueSchema(nullable, forFilter) {
+    const options = [
+      z3.string(),
+      z3.number(),
+      z3.boolean(),
+      z3.instanceof(JsonNullClass)
+    ];
+    if (forFilter) {
+      options.push(z3.instanceof(DbNullClass));
+    } else {
+      if (nullable) {
+        options.push(z3.instanceof(DbNullClass));
+      }
+    }
+    if (forFilter) {
+      options.push(z3.instanceof(AnyNullClass));
+    }
+    const schema = z3.union([
+      ...options,
+      z3.lazy(() => z3.union([
+        this.makeJsonValueSchema(false, false),
+        z3.null()
+      ]).array()),
+      z3.record(z3.string(), z3.lazy(() => z3.union([
+        this.makeJsonValueSchema(false, false),
+        z3.null()
+      ])))
+    ]);
+    return this.nullableIf(schema, nullable);
+  }
+  makeJsonFilterSchema(optional) {
+    const valueSchema = this.makeJsonValueSchema(optional, true);
+    return z3.strictObject({
+      path: z3.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(),
+      mode: this.makeStringModeSchema().optional(),
+      array_contains: valueSchema.optional(),
+      array_starts_with: valueSchema.optional(),
+      array_ends_with: valueSchema.optional()
+    });
   }
   makeDateTimeFilterSchema(optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(z2.union([
-      z2.string().datetime(),
-      z2.date()
-    ]), optional, () => z2.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(z3.union([
+      z3.iso.datetime(),
+      z3.date()
+    ]), optional, () => z3.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0);
   }
   makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(z2.boolean(), optional, () => z2.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(z3.boolean(), optional, () => z3.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -4308,14 +4696,14 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z2.union([
-      this.nullableIf(z2.boolean(), optional),
-      z2.strictObject(components)
+    return z3.union([
+      this.nullableIf(z3.boolean(), optional),
+      z3.strictObject(components)
     ]);
   }
   makeBytesFilterSchema(optional, withAggregations) {
-    const baseSchema = z2.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.instanceof(Uint8Array), [
+    const baseSchema = z3.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -4325,9 +4713,9 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z2.union([
+    return z3.union([
       this.nullableIf(baseSchema, optional),
-      z2.strictObject(components)
+      z3.strictObject(components)
     ]);
   }
   makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
@@ -4343,7 +4731,7 @@ var InputValidator = class {
       gte: baseSchema.optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(z2.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(z3.number().int(), false, false).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -4368,13 +4756,13 @@ var InputValidator = class {
     return result;
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return z2.union([
+    return z3.union([
       this.nullableIf(baseSchema, optional),
-      z2.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
+      z3.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z2.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z3.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -4383,17 +4771,17 @@ var InputValidator = class {
     ] : void 0);
   }
   makeStringFilterSchema(optional, 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 ? [
+    return z3.union([
+      this.nullableIf(z3.string(), optional),
+      z3.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(z3.string(), optional, () => z3.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
           "_count",
           "_min",
           "_max"
         ] : void 0),
-        startsWith: z2.string().optional(),
-        endsWith: z2.string().optional(),
-        contains: z2.string().optional(),
+        startsWith: z3.string().optional(),
+        endsWith: z3.string().optional(),
+        contains: z3.string().optional(),
         ...this.providerSupportsCaseSensitivity ? {
           mode: this.makeStringModeSchema().optional()
         } : {}
@@ -4401,9 +4789,9 @@ var InputValidator = class {
     ]);
   }
   makeStringModeSchema() {
-    return z2.union([
-      z2.literal("default"),
-      z2.literal("insensitive")
+    return z3.union([
+      z3.literal("default"),
+      z3.literal("insensitive")
     ]);
   }
   makeSelectSchema(model) {
@@ -4414,26 +4802,26 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
       } else {
-        fields[field] = z2.boolean().optional();
+        fields[field] = z3.boolean().optional();
       }
     }
     const _countSchema = this.makeCountSelectionSchema(modelDef);
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeCountSelectionSchema(modelDef) {
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
-      return z2.union([
-        z2.literal(true),
-        z2.strictObject({
-          select: z2.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      return z3.union([
+        z3.literal(true),
+        z3.strictObject({
+          select: z3.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: z2.union([
-              z2.boolean(),
-              z2.strictObject({
+            [fieldDef.name]: z3.union([
+              z3.boolean(),
+              z3.strictObject({
                 where: this.makeWhereSchema(fieldDef.type, false, false)
               })
             ]).optional()
@@ -4445,17 +4833,17 @@ var InputValidator = class {
     }
   }
   makeRelationSelectIncludeSchema(fieldDef) {
-    let objSchema = z2.strictObject({
+    let objSchema = z3.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: z2.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: z3.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
       } : {},
-      select: z2.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: z2.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
-      omit: z2.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+      select: 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(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: z2.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: z3.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(),
@@ -4464,8 +4852,8 @@ var InputValidator = class {
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
-    return z2.union([
-      z2.boolean(),
+    return z3.union([
+      z3.boolean(),
       objSchema
     ]);
   }
@@ -4476,13 +4864,13 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
         if (this.options.allowQueryTimeOmitOverride !== false) {
-          fields[field] = z2.boolean().optional();
+          fields[field] = z3.boolean().optional();
         } else {
-          fields[field] = z2.literal(true).optional();
+          fields[field] = z3.literal(true).optional();
         }
       }
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4497,20 +4885,20 @@ var InputValidator = class {
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = z2.union([
-      z2.literal("asc"),
-      z2.literal("desc")
+    const sort = z3.union([
+      z3.literal("asc"),
+      z3.literal("desc")
     ]);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = z2.lazy(() => {
+          fields[field] = z3.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
@@ -4522,13 +4910,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = z2.union([
+          fields[field] = z3.union([
             sort,
-            z2.strictObject({
+            z3.strictObject({
               sort,
-              nulls: z2.union([
-                z2.literal("first"),
-                z2.literal("last")
+              nulls: z3.union([
+                z3.literal("first"),
+                z3.literal("last")
               ])
             })
           ]).optional();
@@ -4546,15 +4934,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = z2.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = z3.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    return this.orArray(z2.enum(nonRelationFields), true);
+    return this.orArray(z3.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -4563,7 +4951,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4613,7 +5001,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
+        let fieldSchema = z3.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -4636,12 +5024,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 = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.strictObject({
+            z3.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -4650,7 +5038,14 @@ var InputValidator = class {
           fieldSchema = fieldSchema.optional();
         }
         if (fieldDef.optional) {
-          fieldSchema = fieldSchema.nullable();
+          if (fieldDef.type === "Json") {
+            fieldSchema = z3.union([
+              fieldSchema,
+              z3.instanceof(DbNullClass)
+            ]);
+          } else {
+            fieldSchema = fieldSchema.nullable();
+          }
         }
         uncheckedVariantFields[field] = fieldSchema;
         if (!fieldDef.foreignKeyFor) {
@@ -4658,19 +5053,19 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(uncheckedVariantFields), modelDef.attributes) : z3.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(checkedVariantFields), modelDef.attributes) : z3.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return z2.union([
+      return z3.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          z2.array(uncheckedCreateSchema)
+          z3.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          z2.array(checkedCreateSchema)
+          z3.array(checkedCreateSchema)
         ] : []
       ]);
     }
@@ -4698,12 +5093,12 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(z2.strictObject({
-        where: this.makeWhereSchema(fieldType, true).optional(),
+      fields["update"] = array ? this.orArray(z3.strictObject({
+        where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : z2.union([
-        z2.strictObject({
-          where: this.makeWhereSchema(fieldType, true).optional(),
+      }), true).optional() : z3.union([
+        z3.strictObject({
+          where: this.makeWhereSchema(fieldType, false).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
@@ -4712,21 +5107,21 @@ var InputValidator = class {
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
-      fields["upsert"] = this.orArray(z2.strictObject({
+      fields["upsert"] = this.orArray(z3.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(z2.strictObject({
+        fields["updateMany"] = this.orArray(z3.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4738,36 +5133,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return z2.union([
-        z2.boolean(),
+      return z3.union([
+        z3.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z2.union([
-      z2.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z3.union([
+      z3.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(z2.strictObject({
+    return this.orArray(z3.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return z2.strictObject({
+    return z3.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: z2.boolean().optional()
+      skipDuplicates: z3.boolean().optional()
     });
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
@@ -4779,10 +5174,10 @@ var InputValidator = class {
     return schema;
   }
   makeUpdateManySchema(model) {
-    return z2.strictObject({
+    return z3.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: z2.number().int().nonnegative().optional()
+      limit: z3.number().int().nonnegative().optional()
     });
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -4795,7 +5190,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -4830,7 +5225,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
+        let fieldSchema = z3.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -4839,26 +5234,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 = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.object({
-              set: this.nullableIf(z2.number().optional(), !!fieldDef.optional).optional(),
-              increment: z2.number().optional(),
-              decrement: z2.number().optional(),
-              multiply: z2.number().optional(),
-              divide: z2.number().optional()
+            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()
             }).refine((v) => Object.keys(v).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided')
           ]);
         }
         if (fieldDef.array) {
           const arraySchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             arraySchema,
-            z2.object({
+            z3.object({
               set: arraySchema.optional(),
-              push: z2.union([
+              push: z3.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -4866,7 +5261,14 @@ var InputValidator = class {
           ]);
         }
         if (fieldDef.optional) {
-          fieldSchema = fieldSchema.nullable();
+          if (fieldDef.type === "Json") {
+            fieldSchema = z3.union([
+              fieldSchema,
+              z3.instanceof(DbNullClass)
+            ]);
+          } else {
+            fieldSchema = fieldSchema.nullable();
+          }
         }
         fieldSchema = fieldSchema.optional();
         uncheckedVariantFields[field] = fieldSchema;
@@ -4875,12 +5277,12 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(uncheckedVariantFields), modelDef.attributes) : z3.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(checkedVariantFields), modelDef.attributes) : z3.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return z2.union([
+      return z3.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -4889,7 +5291,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4900,15 +5302,15 @@ var InputValidator = class {
     return schema;
   }
   makeDeleteManySchema(model) {
-    return z2.object({
+    return z3.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: z2.number().int().nonnegative().optional()
+      limit: z3.number().int().nonnegative().optional()
     }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return z2.object({
+    return z3.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4918,12 +5320,12 @@ var InputValidator = class {
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.union([
-      z2.literal(true),
-      z2.strictObject({
-        _all: z2.literal(true).optional(),
+    return z3.union([
+      z3.literal(true),
+      z3.strictObject({
+        _all: z3.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = z2.literal(true).optional();
+          acc[field] = z3.literal(true).optional();
           return acc;
         }, {})
       })
@@ -4932,7 +5334,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return z2.object({
+    return z3.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4946,20 +5348,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z3.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = z2.literal(true).optional();
+        acc[field] = z3.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z3.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = z2.literal(true).optional();
+        acc[field] = z3.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -4967,8 +5369,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(z2.enum(nonRelationFields), true) : z2.never();
-    let schema = z2.strictObject({
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(z3.enum(nonRelationFields), true) : z3.never();
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -5035,10 +5437,10 @@ var InputValidator = class {
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return z2.number().int().nonnegative();
+    return z3.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return z2.number().int();
+    return z3.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -5050,9 +5452,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? z2.union([
+    return canBeArray ? z3.union([
       schema,
-      z2.array(schema)
+      z3.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -6150,18 +6552,19 @@ var textMatch = /* @__PURE__ */ __name((eb, args, { dialect }, method) => {
   } else {
     op = "like";
   }
+  const escapedSearch = sql5`REPLACE(REPLACE(REPLACE(CAST(${searchExpr} as text), '\\', '\\\\'), '%', '\\%'), '_', '\\_')`;
   searchExpr = match15(method).with("contains", () => eb.fn("CONCAT", [
     sql5.lit("%"),
-    sql5`CAST(${searchExpr} as text)`,
+    escapedSearch,
     sql5.lit("%")
   ])).with("startsWith", () => eb.fn("CONCAT", [
-    sql5`CAST(${searchExpr} as text)`,
+    escapedSearch,
     sql5.lit("%")
   ])).with("endsWith", () => eb.fn("CONCAT", [
     sql5.lit("%"),
-    sql5`CAST(${searchExpr} as text)`
+    escapedSearch
   ])).exhaustive();
-  return eb(fieldExpr, op, searchExpr);
+  return sql5`${fieldExpr} ${sql5.raw(op)} ${searchExpr} escape '\\'`;
 }, "textMatch");
 var has = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2] = args;
@@ -7391,9 +7794,15 @@ var MatchingExpressionVisitor = class extends ExpressionVisitor {
   }
 };
 export {
+  AnyNull,
+  AnyNullClass,
   BaseCrudDialect,
   CRUD,
   CRUD_EXT,
+  DbNull,
+  DbNullClass,
+  JsonNull,
+  JsonNullClass,
   kysely_utils_exports as KyselyUtils,
   ORMError,
   ORMErrorReason,