@zenstackhq/orm 3.5.3 → 3.5.5

package/dist/index.cjs

@@ -65,7 +65,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers14 = require("@zenstackhq/common-helpers");
+var import_common_helpers15 = require("@zenstackhq/common-helpers");
 var import_kysely12 = require("kysely");
 var import_zod3 = __toESM(require("zod"), 1);
 
@@ -119,7 +119,7 @@ __export(query_utils_exports, {
   stripAlias: () => stripAlias,
   tmpAlias: () => tmpAlias
 });
-var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_kysely = require("kysely");
 var import_ts_pattern = require("ts-pattern");
 
@@ -128,6 +128,7 @@ var schema_exports = {};
 __reExport(schema_exports, require("@zenstackhq/schema"));
 
 // src/utils/object-utils.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
 function extractFields(obj, fields) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => fields.includes(key)));
 }
@@ -139,6 +140,10 @@ function fieldsToSelectObject(fields) {
   ]));
 }
 __name(fieldsToSelectObject, "fieldsToSelectObject");
+function isEmptyObject(x) {
+  return (0, import_common_helpers.isPlainObject)(x) && Object.keys(x).length === 0;
+}
+__name(isEmptyObject, "isEmptyObject");
 
 // src/client/executor/error-processor.ts
 function getDbErrorCode(error) {
@@ -507,9 +512,9 @@ function getManyToManyRelation(schema, model, field) {
       ];
     }
     const modelIdFields = requireIdFields(schema, realModel);
-    (0, import_common_helpers.invariant)(modelIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
+    (0, import_common_helpers2.invariant)(modelIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
     const otherIdFields = requireIdFields(schema, fieldDef.type);
-    (0, import_common_helpers.invariant)(otherIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
+    (0, import_common_helpers2.invariant)(otherIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
     return {
       parentFkName: orderedFK[0],
       parentPKName: modelIdFields[0],
@@ -651,7 +656,7 @@ __name(tmpAlias, "tmpAlias");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
-var import_common_helpers7 = require("@zenstackhq/common-helpers");
+var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_cuid = __toESM(require("cuid"), 1);
 var import_kysely6 = require("kysely");
 var import_nanoid = require("nanoid");
@@ -741,7 +746,7 @@ var CRUD_EXT = [
 var import_ts_pattern3 = require("ts-pattern");
 
 // src/client/crud/dialects/mysql.ts
-var import_common_helpers4 = require("@zenstackhq/common-helpers");
+var import_common_helpers5 = require("@zenstackhq/common-helpers");
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_kysely3 = require("kysely");
 
@@ -772,10 +777,10 @@ var AnyNullClass = class {
 var AnyNull = new AnyNullClass();
 
 // src/client/crud/dialects/lateral-join-dialect-base.ts
-var import_common_helpers3 = require("@zenstackhq/common-helpers");
+var import_common_helpers4 = require("@zenstackhq/common-helpers");
 
 // src/client/crud/dialects/base-dialect.ts
-var import_common_helpers2 = require("@zenstackhq/common-helpers");
+var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_kysely2 = require("kysely");
 var import_ts_pattern2 = require("ts-pattern");
 var BaseCrudDialect = class {
@@ -903,7 +908,31 @@ var BaseCrudDialect = class {
     return LOGICAL_COMBINATORS.includes(key);
   }
   buildCompositeFilter(model, modelAlias, key, payload) {
-    return (0, import_ts_pattern2.match)(key).with("AND", () => this.and(...(0, import_common_helpers2.enumerate)(payload).map((subPayload) => this.buildFilter(model, modelAlias, subPayload)))).with("OR", () => this.or(...(0, import_common_helpers2.enumerate)(payload).map((subPayload) => this.buildFilter(model, modelAlias, subPayload)))).with("NOT", () => this.eb.not(this.buildCompositeFilter(model, modelAlias, "AND", payload))).exhaustive();
+    const normalizedPayload = (0, import_common_helpers3.enumerate)(payload).filter((el) => {
+      if (typeof el === "object" && el !== null && !Array.isArray(el)) {
+        const entries = Object.entries(el);
+        return entries.some(([, v]) => v !== void 0);
+      } else {
+        return true;
+      }
+    });
+    const normalizedFilters = normalizedPayload.map((el) => this.buildFilter(model, modelAlias, el));
+    return (0, import_ts_pattern2.match)(key).with("AND", () => {
+      if (normalizedFilters.length === 0) {
+        return this.true();
+      }
+      return this.and(...normalizedFilters);
+    }).with("OR", () => {
+      if (normalizedFilters.length === 0) {
+        return this.false();
+      }
+      return this.or(...normalizedFilters);
+    }).with("NOT", () => {
+      if (normalizedFilters.length === 0) {
+        return this.true();
+      }
+      return this.not(...normalizedFilters);
+    }).exhaustive();
   }
   buildRelationFilter(model, modelAlias, field, fieldDef, payload) {
     if (!fieldDef.array) {
@@ -970,9 +999,9 @@ var BaseCrudDialect = class {
       const m2m = getManyToManyRelation(this.schema, model, field);
       if (m2m) {
         const modelIdFields = requireIdFields(this.schema, model);
-        (0, import_common_helpers2.invariant)(modelIdFields.length === 1, "many-to-many relation must have exactly one id field");
+        (0, import_common_helpers3.invariant)(modelIdFields.length === 1, "many-to-many relation must have exactly one id field");
         const relationIdFields = requireIdFields(this.schema, relationModel);
-        (0, import_common_helpers2.invariant)(relationIdFields.length === 1, "many-to-many relation must have exactly one id field");
+        (0, import_common_helpers3.invariant)(relationIdFields.length === 1, "many-to-many relation must have exactly one id field");
         return eb(this.eb.ref(`${relationFilterSelectAlias}.${relationIdFields[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(this.eb.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", this.eb.ref(`${modelAlias}.${modelIdFields[0]}`)));
       } else {
         const relationKeyPairs = getRelationForeignKeyFieldPairs(this.schema, model, field);
@@ -1021,14 +1050,14 @@ var BaseCrudDialect = class {
       if (_value === void 0) {
         continue;
       }
-      (0, import_common_helpers2.invariant)(fieldDef.array, "Field must be an array type to build array filter");
+      (0, import_common_helpers3.invariant)(fieldDef.array, "Field must be an array type to build array filter");
       const value = this.transformInput(_value, fieldType, true);
       let receiver = fieldRef;
       if (isEnum(this.schema, fieldType)) {
         receiver = this.eb.cast(fieldRef, import_kysely2.sql.raw("text[]"));
       }
       const buildArray = /* @__PURE__ */ __name((value2) => {
-        (0, import_common_helpers2.invariant)(Array.isArray(value2), "Array filter value must be an array");
+        (0, import_common_helpers3.invariant)(Array.isArray(value2), "Array filter value must be an array");
         return this.buildArrayValue(value2.map((v) => this.eb.val(v)), fieldType);
       }, "buildArray");
       switch (key) {
@@ -1067,6 +1096,9 @@ var BaseCrudDialect = class {
       return this.buildEnumFilter(fieldRef, fieldDef, payload);
     }
     if (isTypeDef(this.schema, fieldDef.type)) {
+      if (payload instanceof DbNullClass || payload instanceof JsonNullClass || payload instanceof AnyNullClass) {
+        return this.buildJsonValueFilterClause(fieldRef, payload);
+      }
       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", () => {
@@ -1074,7 +1106,7 @@ var BaseCrudDialect = class {
     }).exhaustive();
   }
   buildJsonFilter(receiver, filter, fieldDef) {
-    (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Json filter payload must be an object");
+    (0, import_common_helpers3.invariant)(filter && typeof filter === "object", "Json filter payload must be an object");
     if ([
       "path",
       "equals",
@@ -1099,7 +1131,7 @@ var BaseCrudDialect = class {
     const jsonReceiver = this.buildJsonPathSelection(receiver, path);
     const stringReceiver = this.castText(jsonReceiver);
     const mode = filter.mode ?? "default";
-    (0, import_common_helpers2.invariant)(mode === "default" || mode === "insensitive", "Invalid JSON filter mode");
+    (0, import_common_helpers3.invariant)(mode === "default" || mode === "insensitive", "Invalid JSON filter mode");
     for (const [key, value] of Object.entries(filter)) {
       switch (key) {
         case "equals": {
@@ -1111,17 +1143,17 @@ var BaseCrudDialect = class {
           break;
         }
         case "string_contains": {
-          (0, import_common_helpers2.invariant)(typeof value === "string", "string_contains value must be a string");
+          (0, import_common_helpers3.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");
+          (0, import_common_helpers3.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");
+          (0, import_common_helpers3.invariant)(typeof value === "string", "string_ends_with value must be a string");
           clauses.push(this.buildJsonStringFilter(stringReceiver, key, value, mode));
           break;
         }
@@ -1154,7 +1186,7 @@ var BaseCrudDialect = class {
     }
   }
   buildTypedJsonArrayFilter(receiver, filter, typeDefName) {
-    (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Typed JSON array filter payload must be an object");
+    (0, import_common_helpers3.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 = [];
@@ -1173,7 +1205,7 @@ var BaseCrudDialect = class {
           clauses.push(this.eb.not(makeExistsNegatedPred(value)));
           break;
         default:
-          (0, import_common_helpers2.invariant)(false, `Invalid typed JSON array filter key: ${key}`);
+          (0, import_common_helpers3.invariant)(false, `Invalid typed JSON array filter key: ${key}`);
       }
     }
     return this.and(...clauses);
@@ -1183,7 +1215,7 @@ var BaseCrudDialect = class {
     if (filter === null) {
       return this.eb(receiver, "=", this.transformInput(null, "Json", false));
     }
-    (0, import_common_helpers2.invariant)(filter && typeof filter === "object", "Typed JSON filter payload must be an object");
+    (0, import_common_helpers3.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));
@@ -1195,7 +1227,7 @@ var BaseCrudDialect = class {
       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}"`);
+        (0, import_common_helpers3.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));
@@ -1244,7 +1276,7 @@ var BaseCrudDialect = class {
     return this.eb(lhs, "=", this.transformInput(rhs, type, false));
   }
   buildStandardFilter(type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
-    if (payload === null || !(0, import_common_helpers2.isPlainObject)(payload)) {
+    if (payload === null || !(0, import_common_helpers3.isPlainObject)(payload)) {
       return {
         conditions: [
           this.buildValueFilter(lhs, type, payload)
@@ -1261,24 +1293,27 @@ var BaseCrudDialect = class {
       if (excludeKeys.includes(op)) {
         continue;
       }
+      if (value === void 0) {
+        continue;
+      }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
       const condition = (0, import_ts_pattern2.match)(op).with("equals", () => rhs === null ? this.eb(lhs, "is", null) : this.eb(lhs, "=", rhs)).with("in", () => {
-        (0, import_common_helpers2.invariant)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers3.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false();
         } else {
           return this.eb(lhs, "in", rhs);
         }
       }).with("notIn", () => {
-        (0, import_common_helpers2.invariant)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers3.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.true();
         } else {
           return this.eb.not(this.eb(lhs, "in", rhs));
         }
       }).with("lt", () => this.eb(lhs, "<", rhs)).with("lte", () => this.eb(lhs, "<=", rhs)).with("gt", () => this.eb(lhs, ">", rhs)).with("gte", () => this.eb(lhs, ">=", rhs)).with("between", () => {
-        (0, import_common_helpers2.invariant)(Array.isArray(rhs), "right hand side must be an array");
-        (0, import_common_helpers2.invariant)(rhs.length === 2, "right hand side must have a length of 2");
+        (0, import_common_helpers3.invariant)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers3.invariant)(rhs.length === 2, "right hand side must have a length of 2");
         const [start, end] = rhs;
         return this.eb.and([
           this.eb(lhs, ">=", start),
@@ -1318,7 +1353,10 @@ var BaseCrudDialect = class {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        (0, import_common_helpers2.invariant)(typeof value === "string", `${key} value must be a string`);
+        if (value === void 0) {
+          continue;
+        }
+        (0, import_common_helpers3.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}`);
@@ -1399,7 +1437,7 @@ var BaseCrudDialect = class {
       const fieldDef = requireField(this.schema, model2, field);
       return fieldDef.originModel ? this.fieldRef(fieldDef.originModel, field, fieldDef.originModel) : this.fieldRef(model2, field, modelAlias2);
     }, "buildFieldRef");
-    (0, import_common_helpers2.enumerate)(orderBy).forEach((orderBy2, index) => {
+    (0, import_common_helpers3.enumerate)(orderBy).forEach((orderBy2, index) => {
       for (const [field, value] of Object.entries(orderBy2)) {
         if (!value) {
           continue;
@@ -1411,9 +1449,9 @@ var BaseCrudDialect = class {
           "_min",
           "_max"
         ].includes(field)) {
-          (0, import_common_helpers2.invariant)(typeof value === "object", `invalid orderBy value for field "${field}"`);
+          (0, import_common_helpers3.invariant)(typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
-            (0, import_common_helpers2.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+            (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
             result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
           }
           continue;
@@ -1433,7 +1471,7 @@ var BaseCrudDialect = class {
               throw createInvalidInputError(`invalid orderBy value for field "${field}"`);
             }
             if ("_count" in value) {
-              (0, import_common_helpers2.invariant)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
+              (0, import_common_helpers3.invariant)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
               const sort = this.negateSort(value._count, negated);
               result = result.orderBy((eb) => {
                 const subQueryAlias = tmpAlias(`${modelAlias}$ob$${field}$ct`);
@@ -1490,7 +1528,7 @@ var BaseCrudDialect = class {
     if (omit && typeof omit === "object" && typeof omit[field] === "boolean") {
       return omit[field];
     }
-    const uncapModel = (0, import_common_helpers2.lowerCaseFirst)(model);
+    const uncapModel = (0, import_common_helpers3.lowerCaseFirst)(model);
     const omitConfig = this.options.omit?.[uncapModel] ?? this.options.omit?.[model];
     if (omitConfig && typeof omitConfig === "object" && typeof omitConfig[field] === "boolean") {
       return omitConfig[field];
@@ -1538,12 +1576,13 @@ var BaseCrudDialect = class {
       const fieldDef = requireField(this.schema, model, field);
       const fieldModel = fieldDef.type;
       let fieldCountQuery;
+      const subQueryAlias = tmpAlias(`${parentAlias}$_${field}$count`);
       const m2m = getManyToManyRelation(this.schema, model, field);
       if (m2m) {
-        fieldCountQuery = this.buildModelSelect(fieldModel, fieldModel, value, false).innerJoin(m2m.joinTable, (join) => join.onRef(`${m2m.joinTable}.${m2m.otherFkName}`, "=", `${fieldModel}.${m2m.otherPKName}`).onRef(`${m2m.joinTable}.${m2m.parentFkName}`, "=", `${parentAlias}.${m2m.parentPKName}`)).select(eb.fn.countAll().as(`_count$${field}`));
+        fieldCountQuery = this.buildModelSelect(fieldModel, subQueryAlias, value, false).innerJoin(m2m.joinTable, (join) => join.onRef(`${m2m.joinTable}.${m2m.otherFkName}`, "=", `${subQueryAlias}.${m2m.otherPKName}`).onRef(`${m2m.joinTable}.${m2m.parentFkName}`, "=", `${parentAlias}.${m2m.parentPKName}`)).select(eb.fn.countAll().as(`_count$${field}`));
       } else {
-        fieldCountQuery = this.buildModelSelect(fieldModel, fieldModel, value, false).select(eb.fn.countAll().as(`_count$${field}`));
-        const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
+        fieldCountQuery = this.buildModelSelect(fieldModel, subQueryAlias, value, false).select(eb.fn.countAll().as(`_count$${field}`));
+        const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, subQueryAlias);
         for (const [left, right] of joinPairs) {
           fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
         }
@@ -1612,7 +1651,7 @@ var BaseCrudDialect = class {
       if ("computedFields" in this.options) {
         const computedFields = this.options.computedFields;
         const computedModel = fieldDef.originModel ?? model;
-        computer = computedFields?.[(0, import_common_helpers2.lowerCaseFirst)(computedModel)]?.[field] ?? computedFields?.[computedModel]?.[field];
+        computer = computedFields?.[(0, import_common_helpers3.lowerCaseFirst)(computedModel)]?.[field] ?? computedFields?.[computedModel]?.[field];
       }
       if (!computer) {
         throw createConfigError(`Computed field "${field}" implementation not provided for model "${model}"`);
@@ -1691,8 +1730,8 @@ var LateralJoinDialectBase = class extends BaseCrudDialect {
     if (m2m) {
       const parentIds = requireIdFields(this.schema, model);
       const relationIds = requireIdFields(this.schema, relationModel);
-      (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-      (0, import_common_helpers3.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers4.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers4.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
       query = query.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
     } else {
       const joinPairs = buildJoinPairs(this.schema, model, parentAlias, relationField, relationModelAlias);
@@ -1846,7 +1885,7 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
     } 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");
+      (0, import_common_helpers5.invariant)(false, "should not reach here: AnyNull is not a valid input value");
     }
     if (isTypeDef(this.schema, type)) {
       if (typeof value !== "string") {
@@ -1909,14 +1948,14 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers5.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformDecimal(value) {
     if (value instanceof import_decimal.default) {
       return value;
     }
-    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers5.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal.default(value);
   }
   transformOutputDate(value) {
@@ -2063,7 +2102,7 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
 };
 
 // src/client/crud/dialects/postgresql.ts
-var import_common_helpers5 = require("@zenstackhq/common-helpers");
+var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
 var import_kysely4 = require("kysely");
 var import_postgres_array = require("postgres-array");
@@ -2183,7 +2222,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     } else if (value instanceof DbNullClass) {
       return null;
     } else if (value instanceof AnyNullClass) {
-      (0, import_common_helpers5.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+      (0, import_common_helpers6.invariant)(false, "should not reach here: AnyNull is not a valid input value");
     }
     if (isTypeDef(this.schema, type)) {
       if (typeof value !== "string") {
@@ -2239,14 +2278,14 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers5.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers6.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformDecimal(value) {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_common_helpers5.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers6.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformOutputDate(value) {
@@ -2296,10 +2335,20 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     return query;
   }
   buildJsonObject(value) {
-    return this.eb.fn("jsonb_build_object", Object.entries(value).flatMap(([key, value2]) => [
-      import_kysely4.sql.lit(key),
-      value2
-    ]));
+    const entries = Object.entries(value);
+    const MAX_PAIRS = 50;
+    const buildChunk = /* @__PURE__ */ __name((chunk) => this.eb.fn("jsonb_build_object", chunk.flatMap(([k, v]) => [
+      import_kysely4.sql.lit(k),
+      v
+    ])), "buildChunk");
+    if (entries.length <= MAX_PAIRS) {
+      return buildChunk(entries);
+    }
+    const chunks = [];
+    for (let i = 0; i < entries.length; i += MAX_PAIRS) {
+      chunks.push(buildChunk(entries.slice(i, i + MAX_PAIRS)));
+    }
+    return chunks.reduce((acc, chunk) => import_kysely4.sql`${acc} || ${chunk}`);
   }
   castInt(expression) {
     return this.eb.cast(expression, "integer");
@@ -2459,7 +2508,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
 };
 
 // src/client/crud/dialects/sqlite.ts
-var import_common_helpers6 = require("@zenstackhq/common-helpers");
+var import_common_helpers7 = require("@zenstackhq/common-helpers");
 var import_decimal3 = __toESM(require("decimal.js"), 1);
 var import_kysely5 = require("kysely");
 var SqliteCrudDialect = class extends BaseCrudDialect {
@@ -2502,7 +2551,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     } else if (value instanceof DbNullClass) {
       return null;
     } else if (value instanceof AnyNullClass) {
-      (0, import_common_helpers6.invariant)(false, "should not reach here: AnyNull is not a valid input value");
+      (0, import_common_helpers7.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);
@@ -2552,14 +2601,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (value instanceof import_decimal3.default) {
       return value;
     }
-    (0, import_common_helpers6.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal3.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers7.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal3.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal3.default(value);
   }
   transformOutputBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_common_helpers6.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers7.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformOutputBoolean(value) {
@@ -2675,8 +2724,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (m2m) {
       const parentIds = requireIdFields(this.schema, model);
       const relationIds = requireIdFields(this.schema, relationModel);
-      (0, import_common_helpers6.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-      (0, import_common_helpers6.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers7.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+      (0, import_common_helpers7.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
       selectModelQuery = selectModelQuery.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
     } else {
       const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
@@ -3109,7 +3158,7 @@ var BaseOperationHandler = class {
       }
     });
     const discriminatorField = getDiscriminatorField(this.schema, model);
-    (0, import_common_helpers7.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    (0, import_common_helpers8.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
     thisCreateFields[discriminatorField] = forModel;
     const baseEntity = await this.create(kysely, model, thisCreateFields, void 0, true);
     const idValues = extractIdFields(baseEntity, this.schema, model);
@@ -3121,8 +3170,8 @@ var BaseOperationHandler = class {
   }
   async buildFkAssignments(kysely, model, relationField, entity) {
     const parentFkFields = {};
-    (0, import_common_helpers7.invariant)(relationField, "parentField must be defined if parentModel is defined");
-    (0, import_common_helpers7.invariant)(entity, "parentEntity must be defined if parentModel is defined");
+    (0, import_common_helpers8.invariant)(relationField, "parentField must be defined if parentModel is defined");
+    (0, import_common_helpers8.invariant)(entity, "parentEntity must be defined if parentModel is defined");
     const { keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
     for (const pair of keyPairs) {
       if (!(pair.pk in entity)) {
@@ -3151,8 +3200,8 @@ var BaseOperationHandler = class {
     const leftFirst = leftModel !== rightModel ? leftModel.localeCompare(rightModel) <= 0 : leftField.localeCompare(rightField) <= 0;
     const leftIdField = requireIdFields(this.schema, leftModel);
     const rightIdField = requireIdFields(this.schema, rightModel);
-    (0, import_common_helpers7.invariant)(leftIdField.length === 1, "many-to-many relation must have exactly one id field");
-    (0, import_common_helpers7.invariant)(rightIdField.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(leftIdField.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(rightIdField.length === 1, "many-to-many relation must have exactly one id field");
     const leftIdValue = leftEntity[leftIdField[0]];
     const rightIdValues = rightEntities.map((e) => e[rightIdField[0]]);
     if (action === "connect") {
@@ -3177,10 +3226,10 @@ var BaseOperationHandler = class {
     }
   }
   resetManyToManyRelation(kysely, model, field, parentIds) {
-    (0, import_common_helpers7.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
+    (0, import_common_helpers8.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
     const parentId = Object.values(parentIds)[0];
     const m2m = getManyToManyRelation(this.schema, model, field);
-    (0, import_common_helpers7.invariant)(m2m, "not a many-to-many relation");
+    (0, import_common_helpers8.invariant)(m2m, "not a many-to-many relation");
     const eb = (0, import_kysely6.expressionBuilder)();
     return kysely.deleteFrom(m2m.joinTable).where(eb(`${m2m.joinTable}.${m2m.parentFkName}`, "=", parentId)).execute();
   }
@@ -3202,7 +3251,7 @@ var BaseOperationHandler = class {
         }
         case "connect": {
           const referencedPkFields = relationField.relation.references;
-          (0, import_common_helpers7.invariant)(referencedPkFields, "relation must have fields info");
+          (0, import_common_helpers8.invariant)(referencedPkFields, "relation must have fields info");
           const extractedFks = extractFields(subPayload, referencedPkFields);
           if (Object.keys(extractedFks).length === referencedPkFields.length) {
             result = extractedFks;
@@ -3249,13 +3298,13 @@ var BaseOperationHandler = class {
       }
       switch (action) {
         case "create": {
-          for (const item of (0, import_common_helpers7.enumerate)(subPayload)) {
+          for (const item of (0, import_common_helpers8.enumerate)(subPayload)) {
             await this.create(kysely, relationModel, item, fromRelationContext);
           }
           break;
         }
         case "createMany": {
-          (0, import_common_helpers7.invariant)(relationFieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers8.invariant)(relationFieldDef.array, "relation must be an array for createMany");
           await this.createMany(kysely, relationModel, subPayload, false, fromRelationContext);
           break;
         }
@@ -3264,7 +3313,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "connectOrCreate": {
-          for (const item of (0, import_common_helpers7.enumerate)(subPayload)) {
+          for (const item of (0, import_common_helpers8.enumerate)(subPayload)) {
             const found = await this.exists(kysely, relationModel, item.where);
             if (!found) {
               await this.create(kysely, relationModel, item.create, fromRelationContext);
@@ -3294,11 +3343,11 @@ var BaseOperationHandler = class {
       }
       relationKeyPairs.push(...keyPairs);
     }
-    let createData = (0, import_common_helpers7.enumerate)(input.data).map((item) => {
+    let createData = (0, import_common_helpers8.enumerate)(input.data).map((item) => {
       const newItem = {};
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
-        (0, import_common_helpers7.invariant)(!fieldDef.relation, "createMany does not support relations");
+        (0, import_common_helpers8.invariant)(!fieldDef.relation, "createMany does not support relations");
         newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
       }
       if (fromRelation) {
@@ -3361,7 +3410,7 @@ var BaseOperationHandler = class {
     const thisCreateRows = [];
     const remainingFieldRows = [];
     const discriminatorField = getDiscriminatorField(this.schema, model);
-    (0, import_common_helpers7.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    (0, import_common_helpers8.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
     for (const createFields of createRows) {
       const thisCreateFields = {};
       const remainingFields = {};
@@ -3400,7 +3449,7 @@ var BaseOperationHandler = class {
   }
   fillGeneratedAndDefaultValues(modelDef, data) {
     const fields = modelDef.fields;
-    const values = (0, import_common_helpers7.clone)(data);
+    const values = (0, import_common_helpers8.clone)(data);
     for (const [field, fieldDef] of Object.entries(fields)) {
       if (fieldDef.originModel) {
         continue;
@@ -3472,7 +3521,7 @@ var BaseOperationHandler = class {
       throw createInvalidInputError("data must be an object");
     }
     const parentWhere = await this.buildUpdateParentRelationFilter(kysely, fromRelation);
-    let combinedWhere = where ?? {};
+    let combinedWhere = where ?? true;
     if (Object.keys(parentWhere).length > 0) {
       combinedWhere = Object.keys(combinedWhere).length > 0 ? {
         AND: [
@@ -3491,7 +3540,7 @@ var BaseOperationHandler = class {
         const hasNonIgnoredFields = Object.keys(data).some((field) => (isScalarField(this.schema, modelDef.name, field) || isForeignKeyField(this.schema, modelDef.name, field)) && !ignoredFields.has(field));
         if (hasNonIgnoredFields) {
           if (finalData === data) {
-            finalData = (0, import_common_helpers7.clone)(data);
+            finalData = (0, import_common_helpers8.clone)(data);
           }
           finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
           autoUpdatedFields.push(fieldName);
@@ -3594,7 +3643,7 @@ var BaseOperationHandler = class {
         const updatingIdFields = idFields.some((idField) => idField in updateFields);
         if (updatingIdFields) {
           const origIdValues = await loadThisEntity();
-          (0, import_common_helpers7.invariant)(origIdValues, "Original entity should have been loaded for update without RETURNING");
+          (0, import_common_helpers8.invariant)(origIdValues, "Original entity should have been loaded for update without RETURNING");
           readFilter = {
             ...origIdValues
           };
@@ -3653,7 +3702,7 @@ var BaseOperationHandler = class {
         }
       } else {
         const fromRelationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_common_helpers7.invariant)(fromRelationFieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fromRelationFieldDef.relation?.opposite);
         parentWhere[fromRelationFieldDef.relation.opposite] = {
           some: fromRelation.ids
         };
@@ -3704,7 +3753,7 @@ var BaseOperationHandler = class {
     };
   }
   transformIncrementalUpdate(model, field, fieldDef, payload) {
-    (0, import_common_helpers7.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
+    (0, import_common_helpers8.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
     const key = Object.keys(payload)[0];
     const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely6.expressionBuilder)();
@@ -3714,7 +3763,7 @@ var BaseOperationHandler = class {
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
-    (0, import_common_helpers7.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
+    (0, import_common_helpers8.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
     const key = Object.keys(payload)[0];
     const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely6.expressionBuilder)();
@@ -3745,7 +3794,7 @@ var BaseOperationHandler = class {
       throw createNotSupportedError("Updating with a limit is not supported for polymorphic models");
     }
     const parentWhere = await this.buildUpdateParentRelationFilter(kysely, fromRelation);
-    let combinedWhere = where ?? {};
+    let combinedWhere = where ?? true;
     if (Object.keys(parentWhere).length > 0) {
       combinedWhere = Object.keys(combinedWhere).length > 0 ? {
         AND: [
@@ -3874,14 +3923,14 @@ var BaseOperationHandler = class {
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
         case "create": {
-          (0, import_common_helpers7.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
-          for (const item of (0, import_common_helpers7.enumerate)(value)) {
+          (0, import_common_helpers8.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
+          for (const item of (0, import_common_helpers8.enumerate)(value)) {
             await this.create(kysely, fieldModel, item, fromRelationContext);
           }
           break;
         }
         case "createMany": {
-          (0, import_common_helpers7.invariant)(fieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array for createMany");
           await this.createMany(kysely, fieldModel, value, false, fromRelationContext);
           break;
         }
@@ -3898,12 +3947,12 @@ var BaseOperationHandler = class {
           break;
         }
         case "set": {
-          (0, import_common_helpers7.invariant)(fieldDef.array, "relation must be an array");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array");
           await this.setRelation(kysely, fieldModel, value, fromRelationContext);
           break;
         }
         case "update": {
-          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers8.enumerate)(value)) {
             const item = _item;
             let where;
             let data;
@@ -3920,7 +3969,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "upsert": {
-          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers8.enumerate)(value)) {
             const item = _item;
             const updated = await this.update(kysely, fieldModel, item.where, item.update, fromRelationContext, true, false);
             if (!updated) {
@@ -3930,18 +3979,18 @@ var BaseOperationHandler = class {
           break;
         }
         case "updateMany": {
-          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers8.enumerate)(value)) {
             const item = _item;
             await this.updateMany(kysely, fieldModel, item.where, item.data, item.limit, false, fieldModel, fromRelationContext);
           }
           break;
         }
         case "delete": {
-          await this.deleteRelation(kysely, fieldModel, value, fromRelationContext, true);
+          await this.deleteRelation(kysely, fieldModel, value, fromRelationContext, true, true);
           break;
         }
         case "deleteMany": {
-          await this.deleteRelation(kysely, fieldModel, value, fromRelationContext, false);
+          await this.deleteRelation(kysely, fieldModel, value, fromRelationContext, false, false);
           break;
         }
         default: {
@@ -3967,7 +4016,7 @@ var BaseOperationHandler = class {
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
-        (0, import_common_helpers7.invariant)(_data.length === 1, "only one entity can be connected");
+        (0, import_common_helpers8.invariant)(_data.length === 1, "only one entity can be connected");
         const target = await this.readUnique(kysely, model, {
           where: _data[0]
         });
@@ -4004,7 +4053,7 @@ var BaseOperationHandler = class {
     }
   }
   async connectOrCreateRelation(kysely, model, data, fromRelation) {
-    const _data = (0, import_common_helpers7.enumerate)(data);
+    const _data = (0, import_common_helpers8.enumerate)(data);
     if (_data.length === 0) {
       return;
     }
@@ -4029,6 +4078,10 @@ var BaseOperationHandler = class {
           true
         ];
       }
+    } else if (isEmptyObject(data)) {
+      disconnectConditions = [
+        true
+      ];
     } else {
       disconnectConditions = this.normalizeRelationManipulationInput(model, data);
       if (disconnectConditions.length === 0) {
@@ -4048,7 +4101,7 @@ var BaseOperationHandler = class {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       const eb = (0, import_kysely6.expressionBuilder)();
       if (ownedByModel) {
-        (0, import_common_helpers7.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
+        (0, import_common_helpers8.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
         const condition = disconnectConditions[0];
         if (condition === true) {
           for (const { fk } of keyPairs) {
@@ -4151,9 +4204,9 @@ var BaseOperationHandler = class {
       }
     }
   }
-  async deleteRelation(kysely, model, data, fromRelation, throwForNotFound) {
+  async deleteRelation(kysely, model, data, fromRelation, uniqueDelete, throwForNotFound) {
     let deleteConditions = [];
-    let expectedDeleteCount;
+    let expectedDeleteCount = -1;
     if (typeof data === "boolean") {
       if (data === false) {
         return;
@@ -4161,6 +4214,15 @@ var BaseOperationHandler = class {
         deleteConditions = [
           true
         ];
+        if (uniqueDelete) {
+          expectedDeleteCount = 1;
+        }
+      }
+    } else if (isEmptyObject(data)) {
+      deleteConditions = [
+        true
+      ];
+      if (uniqueDelete) {
         expectedDeleteCount = 1;
       }
     } else {
@@ -4168,7 +4230,9 @@ var BaseOperationHandler = class {
       if (deleteConditions.length === 0) {
         return;
       }
-      expectedDeleteCount = deleteConditions.length;
+      if (uniqueDelete) {
+        expectedDeleteCount = deleteConditions.length;
+      }
     }
     let deleteResult;
     let deleteFromModel;
@@ -4176,7 +4240,7 @@ var BaseOperationHandler = class {
     if (m2m) {
       deleteFromModel = model;
       const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-      (0, import_common_helpers7.invariant)(fieldDef.relation?.opposite);
+      (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
         AND: [
           {
@@ -4200,7 +4264,7 @@ var BaseOperationHandler = class {
           throw createNotFoundError(fromRelation.model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_common_helpers7.invariant)(fieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
         deleteResult = await this.delete(kysely, model, {
           AND: [
             // filter for parent
@@ -4228,12 +4292,12 @@ var BaseOperationHandler = class {
         });
       }
     }
-    if (throwForNotFound && expectedDeleteCount > (deleteResult.numAffectedRows ?? 0)) {
+    if (throwForNotFound && expectedDeleteCount >= 0 && expectedDeleteCount > (deleteResult.numAffectedRows ?? 0)) {
       throw createNotFoundError(deleteFromModel);
     }
   }
   normalizeRelationManipulationInput(model, data) {
-    return (0, import_common_helpers7.enumerate)(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
+    return (0, import_common_helpers8.enumerate)(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
   }
   // #endregion
   async delete(kysely, model, where, limit, filterModel, fieldsToReturn) {
@@ -4354,7 +4418,7 @@ var BaseOperationHandler = class {
     if (!args) {
       return;
     }
-    const newArgs = (0, import_common_helpers7.clone)(args);
+    const newArgs = (0, import_common_helpers8.clone)(args);
     this.doNormalizeArgs(newArgs);
     return newArgs;
   }
@@ -4363,7 +4427,7 @@ var BaseOperationHandler = class {
       for (const [key, value] of Object.entries(args)) {
         if (value === void 0) {
           delete args[key];
-        } else if (value && (0, import_common_helpers7.isPlainObject)(value)) {
+        } else if (value && (0, import_common_helpers8.isPlainObject)(value)) {
           this.doNormalizeArgs(value);
         }
       }
@@ -4997,11 +5061,11 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator/validator.ts
-var import_common_helpers9 = require("@zenstackhq/common-helpers");
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_ts_pattern11 = require("ts-pattern");
 
 // src/client/zod/factory.ts
-var import_common_helpers8 = require("@zenstackhq/common-helpers");
+var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_zod = require("@zenstackhq/zod");
 var import_decimal4 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern10 = require("ts-pattern");
@@ -5196,12 +5260,12 @@ var ZodSchemaFactory = class {
   }
   makeEnumSchema(_enum) {
     const enumDef = getEnum(this.schema, _enum);
-    (0, import_common_helpers8.invariant)(enumDef, `Enum "${_enum}" not found in schema`);
+    (0, import_common_helpers9.invariant)(enumDef, `Enum "${_enum}" not found in schema`);
     return import_zod2.z.enum(Object.keys(enumDef.values));
   }
   makeTypeDefSchema(type) {
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers8.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const schema = import_zod2.z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makeScalarSchema(def.type);
       if (def.array) {
@@ -5285,7 +5349,7 @@ var ZodSchemaFactory = class {
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
           fields[uniqueField.name] = import_zod2.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
-            (0, import_common_helpers8.invariant)(!def.relation, "unique field cannot be a relation");
+            (0, import_common_helpers9.invariant)(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
@@ -5336,7 +5400,7 @@ var ZodSchemaFactory = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers8.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
     if (!array) {
       const fieldSchemas = {};
@@ -5377,9 +5441,28 @@ var ZodSchemaFactory = class {
     candidates.push(this.makeJsonFilterSchema(contextModel, field, optional));
     if (optional) {
       candidates.push(import_zod2.z.null());
+      candidates.push(import_zod2.z.instanceof(DbNullClass));
+      candidates.push(import_zod2.z.instanceof(JsonNullClass));
+      candidates.push(import_zod2.z.instanceof(AnyNullClass));
     }
     return import_zod2.z.union(candidates);
   }
+  // For optional typed JSON fields, allow DbNull, JsonNull, and null.
+  // z.union doesn't work here because `z.any()` (returned by `makeScalarSchema`)
+  // always wins, so we create a wrapper superRefine instead.
+  // The caller must pass the already-built fieldSchema so that array/list
+  // mutation shapes (set, push, etc.) are preserved.
+  makeNullableTypedJsonMutationSchema(fieldSchema) {
+    return import_zod2.z.any().superRefine((value, ctx) => {
+      if (value instanceof DbNullClass || value instanceof JsonNullClass || value === null || value === void 0) {
+        return;
+      }
+      const parseResult = fieldSchema.safeParse(value);
+      if (!parseResult.success) {
+        parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
+      }
+    }).optional();
+  }
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
   }
@@ -5388,7 +5471,7 @@ var ZodSchemaFactory = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const enumDef = getEnum(this.schema, enumName);
-    (0, import_common_helpers8.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
+    (0, import_common_helpers9.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
     const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
     if (array) {
       return this.internalMakeArrayFilterSchema(model, fieldInfo.name, baseSchema);
@@ -5681,7 +5764,7 @@ var ZodSchemaFactory = class {
     for (const plugin of this.plugins) {
       const resultConfig = plugin.result;
       if (resultConfig) {
-        const modelConfig = resultConfig[(0, import_common_helpers8.lowerCaseFirst)(model)];
+        const modelConfig = resultConfig[(0, import_common_helpers9.lowerCaseFirst)(model)];
         if (modelConfig) {
           for (const field of Object.keys(modelConfig)) {
             fields[field] = import_zod2.z.boolean().optional();
@@ -5871,6 +5954,8 @@ var ZodSchemaFactory = class {
               fieldSchema,
               import_zod2.z.instanceof(DbNullClass)
             ]);
+          } else if (this.isTypeDefType(fieldDef.type)) {
+            fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
           } else {
             fieldSchema = fieldSchema.nullable();
           }
@@ -6107,6 +6192,8 @@ var ZodSchemaFactory = class {
               fieldSchema,
               import_zod2.z.instanceof(DbNullClass)
             ]);
+          } else if (this.isTypeDefType(fieldDef.type)) {
+            fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
           } else {
             fieldSchema = fieldSchema.nullable();
           }
@@ -6224,7 +6311,7 @@ var ZodSchemaFactory = class {
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "groupBy");
     schema = schema.refine((value) => {
-      const bys = (0, import_common_helpers8.enumerate)(value.by);
+      const bys = (0, import_common_helpers9.enumerate)(value.by);
       if (value.having && typeof value.having === "object") {
         for (const [key, val] of Object.entries(value.having)) {
           if (AggregateOperators.includes(key)) {
@@ -6244,8 +6331,8 @@ var ZodSchemaFactory = class {
       return true;
     }, 'fields in "having" must be in "by"');
     schema = schema.refine((value) => {
-      const bys = (0, import_common_helpers8.enumerate)(value.by);
-      for (const orderBy of (0, import_common_helpers8.enumerate)(value.orderBy)) {
+      const bys = (0, import_common_helpers9.enumerate)(value.by);
+      for (const orderBy of (0, import_common_helpers9.enumerate)(value.orderBy)) {
         if (orderBy && Object.keys(orderBy).filter((f) => !AggregateOperators.includes(f)).some((key) => !bys.includes(key))) {
           return false;
         }
@@ -6260,7 +6347,7 @@ var ZodSchemaFactory = class {
         continue;
       }
       if (LOGICAL_COMBINATORS.includes(key)) {
-        if ((0, import_common_helpers8.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
+        if ((0, import_common_helpers9.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
           continue;
         }
       }
@@ -6320,8 +6407,8 @@ var ZodSchemaFactory = class {
       const createSchema = "$create" in plugin.queryArgs && plugin.queryArgs["$create"] ? plugin.queryArgs["$create"] : void 0;
       const updateSchema = "$update" in plugin.queryArgs && plugin.queryArgs["$update"] ? plugin.queryArgs["$update"] : void 0;
       if (createSchema && updateSchema) {
-        (0, import_common_helpers8.invariant)(createSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
-        (0, import_common_helpers8.invariant)(updateSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(createSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(updateSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
         result = createSchema.extend(updateSchema.shape);
       } else if (createSchema) {
         result = createSchema;
@@ -6342,7 +6429,7 @@ var ZodSchemaFactory = class {
     } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
       result = plugin.queryArgs["$all"];
     }
-    (0, import_common_helpers8.invariant)(result === void 0 || result instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+    (0, import_common_helpers9.invariant)(result === void 0 || result instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
     return result;
   }
   // #endregion
@@ -6396,7 +6483,7 @@ var ZodSchemaFactory = class {
       return void 0;
     }
     const modelsRecord = slicing.models;
-    const modelConfig = modelsRecord[(0, import_common_helpers8.lowerCaseFirst)(model)];
+    const modelConfig = modelsRecord[(0, import_common_helpers9.lowerCaseFirst)(model)];
     if (modelConfig?.fields) {
       const fieldConfig = modelConfig.fields[field];
       if (fieldConfig) {
@@ -7003,7 +7090,7 @@ var InputValidator = class {
       return input;
     }
     const procDef = (this.client.$schema.procedures ?? {})[proc];
-    (0, import_common_helpers9.invariant)(procDef, `Procedure "${proc}" not found in schema`);
+    (0, import_common_helpers10.invariant)(procDef, `Procedure "${proc}" not found in schema`);
     const params = Object.values(procDef.params ?? {});
     if (typeof input === "undefined") {
       if (params.length === 0) {
@@ -7264,12 +7351,12 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_kysely9 = require("kysely");
 var import_ts_pattern12 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely7 = require("kysely");
 var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   static {
@@ -7342,7 +7429,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       return super.transformInsertQuery(node, queryId);
     }
     const model = extractModelName(node.into);
-    (0, import_common_helpers10.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
+    (0, import_common_helpers11.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
     return this.withScope({
       model
     }, () => {
@@ -7425,7 +7512,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       return super.transformUpdateQuery(node);
     }
     const model = extractModelName(innerTable);
-    (0, import_common_helpers10.invariant)(model, 'UpdateQueryNode must have a model name in the "table" clause');
+    (0, import_common_helpers11.invariant)(model, 'UpdateQueryNode must have a model name in the "table" clause');
     return this.withScope({
       model,
       alias
@@ -7729,7 +7816,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   }
   requireCurrentScope() {
     const scope = this.scopes[this.scopes.length - 1];
-    (0, import_common_helpers10.invariant)(scope, "No scope available");
+    (0, import_common_helpers11.invariant)(scope, "No scope available");
     return scope;
   }
   // #endregion
@@ -8196,7 +8283,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     for (const valuesItem of values.values) {
       const rowIds = {};
       if (import_kysely9.PrimitiveValueListNode.is(valuesItem)) {
-        (0, import_common_helpers11.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
+        (0, import_common_helpers12.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
         for (const idField of idFields) {
           const colIndex = columns.findIndex((col) => col.column.name === idField);
           if (colIndex === -1) {
@@ -8205,7 +8292,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
           rowIds[idField] = valuesItem.values[colIndex];
         }
       } else {
-        (0, import_common_helpers11.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
+        (0, import_common_helpers12.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
         for (const idField of idFields) {
           const colIndex = columns.findIndex((col) => col.column.name === idField);
           if (colIndex === -1) {
@@ -8262,17 +8349,17 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   }
   getMutationModel(queryNode) {
     return (0, import_ts_pattern12.match)(queryNode).when(import_kysely9.InsertQueryNode.is, (node) => {
-      (0, import_common_helpers11.invariant)(node.into, "InsertQueryNode must have an into clause");
+      (0, import_common_helpers12.invariant)(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(import_kysely9.UpdateQueryNode.is, (node) => {
-      (0, import_common_helpers11.invariant)(node.table, "UpdateQueryNode must have a table");
+      (0, import_common_helpers12.invariant)(node.table, "UpdateQueryNode must have a table");
       const { node: tableNode } = stripAlias(node.table);
-      (0, import_common_helpers11.invariant)(import_kysely9.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
+      (0, import_common_helpers12.invariant)(import_kysely9.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).when(import_kysely9.DeleteQueryNode.is, (node) => {
-      (0, import_common_helpers11.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      (0, import_common_helpers12.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
       const { node: tableNode } = stripAlias(node.from.froms[0]);
-      (0, import_common_helpers11.invariant)(import_kysely9.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
+      (0, import_common_helpers12.invariant)(import_kysely9.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw createInternalError(`Invalid query node: ${node}`);
@@ -8417,7 +8504,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely10 = require("kysely");
 var import_ts_pattern13 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
@@ -8527,8 +8614,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers12.invariant)(import_kysely10.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern13.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers12.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers12.lowerCaseFirst)(result)).otherwise(() => {
+  (0, import_common_helpers13.invariant)(import_kysely10.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = (0, import_ts_pattern13.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers13.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers13.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -8539,13 +8626,13 @@ function readBoolean(expr, defaultValue) {
     return defaultValue;
   }
   const opNode = expr.toOperationNode();
-  (0, import_common_helpers12.invariant)(import_kysely10.ValueNode.is(opNode), "expression must be a literal value");
+  (0, import_common_helpers13.invariant)(import_kysely10.ValueNode.is(opNode), "expression must be a literal value");
   return !!opNode.value;
 }
 __name(readBoolean, "readBoolean");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_common_helpers14 = require("@zenstackhq/common-helpers");
 var import_kysely11 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern14 = require("ts-pattern");
@@ -8571,7 +8658,7 @@ var SchemaDbPusher = class {
                 return f.name;
               } else {
                 const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
-                (0, import_common_helpers13.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+                (0, import_common_helpers14.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
                 return mappedName;
               }
             });
@@ -8698,7 +8785,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers13.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers14.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -8773,7 +8860,7 @@ var SchemaDbPusher = class {
               return f.name;
             } else {
               const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
-              (0, import_common_helpers13.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+              (0, import_common_helpers14.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
               return mappedName;
             }
           });
@@ -8808,7 +8895,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && schema_exports.ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers13.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers14.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -9129,7 +9216,7 @@ var ClientImpl = class _ClientImpl {
     for (const [modelName, modelDef] of Object.entries(this.$schema.models)) {
       if (modelDef.computedFields) {
         for (const fieldName of Object.keys(modelDef.computedFields)) {
-          const modelConfig = computedFieldsConfig?.[(0, import_common_helpers14.lowerCaseFirst)(modelName)] ?? computedFieldsConfig?.[modelName];
+          const modelConfig = computedFieldsConfig?.[(0, import_common_helpers15.lowerCaseFirst)(modelName)] ?? computedFieldsConfig?.[modelName];
           const fieldConfig = modelConfig?.[fieldName];
           if (fieldConfig === null || fieldConfig === void 0) {
             throw createConfigError(`Computed field "${fieldName}" in model "${modelName}" does not have a configuration. Please provide an implementation in the computedFields option.`);
@@ -9161,7 +9248,7 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    (0, import_common_helpers14.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    (0, import_common_helpers15.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
     if (typeof input === "function") {
       return this.interactiveTransaction(input, options);
     } else {
@@ -9560,7 +9647,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
   const slicing = client.$options.slicing;
   if (slicing?.models) {
-    const modelSlicing = slicing.models[(0, import_common_helpers14.lowerCaseFirst)(model)];
+    const modelSlicing = slicing.models[(0, import_common_helpers15.lowerCaseFirst)(model)];
     const allSlicing = slicing.models.$all;
     const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
     const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;
@@ -9611,7 +9698,7 @@ function collectExtResultFieldDefs(model, schema, plugins) {
   for (const plugin of plugins) {
     const resultConfig = plugin.result;
     if (resultConfig) {
-      const modelConfig = resultConfig[(0, import_common_helpers14.lowerCaseFirst)(model)];
+      const modelConfig = resultConfig[(0, import_common_helpers15.lowerCaseFirst)(model)];
       if (modelConfig) {
         for (const [fieldName, fieldDef] of Object.entries(modelConfig)) {
           if (getField(schema, model, fieldName)) {