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

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 }) => {
@@ -634,6 +654,32 @@ 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");
 var import_kysely2 = require("kysely");
@@ -905,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);
   }
@@ -981,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) {
@@ -991,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);
@@ -1316,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);
@@ -1512,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;
   }
@@ -1554,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) {
@@ -1731,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 json_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("json_each", [
+      receiver
+    ]).as("$items")).select(this.eb.lit(1).as("$t")).where(buildFilter(this.eb.ref("$items.value"))));
+  }
   get supportsUpdateWithLimit() {
     return false;
   }
@@ -2349,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)) {
@@ -2370,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)) {
@@ -2381,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);
         }
@@ -2402,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({
@@ -2581,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,
@@ -2632,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;
@@ -4136,7 +4430,7 @@ 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) {
@@ -4153,8 +4447,8 @@ var InputValidator = class {
         ]);
       }).with("DateTime", () => import_zod3.z.union([
         import_zod3.z.date(),
-        import_zod3.z.string().datetime()
-      ])).with("Bytes", () => import_zod3.z.instanceof(Uint8Array)).otherwise(() => import_zod3.z.unknown());
+        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) {
@@ -4185,20 +4479,23 @@ var InputValidator = class {
     const typeDef = getTypeDef(this.schema, type);
     (0, import_common_helpers7.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     schema = import_zod3.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
-      let fieldSchema = this.makePrimitiveSchema(def.type);
+      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);
@@ -4238,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);
         }
@@ -4294,6 +4593,52 @@ 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_zod3.z.enum(Object.keys(enumDef.values));
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod3.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
@@ -4313,25 +4658,64 @@ var InputValidator = class {
   }
   makeArrayFilterSchema(type) {
     return import_zod3.z.strictObject({
-      equals: this.makePrimitiveSchema(type).array().optional(),
-      has: this.makePrimitiveSchema(type).optional(),
-      hasEvery: this.makePrimitiveSchema(type).array().optional(),
-      hasSome: this.makePrimitiveSchema(type).array().optional(),
+      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_zod3.z.any()).with("Unsupported", () => import_zod3.z.never()).exhaustive();
+    return (0, import_ts_pattern13.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern13.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.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();
   }
-  makeTypeDefFilterSchema(_type, _optional) {
-    return import_zod3.z.never();
+  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_zod3.z.union([
-      import_zod3.z.string().datetime(),
+      import_zod3.z.iso.datetime(),
       import_zod3.z.date()
     ]), optional, () => import_zod3.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
@@ -4676,7 +5060,7 @@ 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_zod3.z.union([
@@ -4690,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) {
@@ -4739,11 +5130,11 @@ var InputValidator = class {
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
       fields["update"] = array ? this.orArray(import_zod3.z.strictObject({
-        where: this.makeWhereSchema(fieldType, true).optional(),
+        where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional() : import_zod3.z.union([
         import_zod3.z.strictObject({
-          where: this.makeWhereSchema(fieldType, true).optional(),
+          where: this.makeWhereSchema(fieldType, false).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
@@ -4879,7 +5270,7 @@ 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_zod3.z.union([
             fieldSchema,
@@ -4906,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;
@@ -6190,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;
@@ -7432,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,