@zenstackhq/orm 3.5.2 → 3.5.4

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) {
@@ -1074,7 +1103,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 +1128,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 +1140,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 +1183,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 +1202,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 +1212,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 +1224,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 +1273,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 +1290,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 +1350,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 +1434,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 +1446,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 +1468,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 +1525,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];
@@ -1612,7 +1647,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}"`);
@@ -1643,6 +1678,12 @@ var BaseCrudDialect = class {
   buildExistsExpression(innerQuery) {
     return this.eb.exists(innerQuery);
   }
+  /**
+   * Builds a binary comparison expression between two operands.
+   */
+  buildComparison(left, _leftFieldDef, op, right, _rightFieldDef) {
+    return this.eb(left, op, right);
+  }
 };
 
 // src/client/crud/dialects/lateral-join-dialect-base.ts
@@ -1685,8 +1726,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);
@@ -1840,7 +1881,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") {
@@ -1903,14 +1944,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) {
@@ -2057,7 +2098,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");
@@ -2077,6 +2118,33 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     Bytes: "bytea",
     Json: "jsonb"
   };
+  // Maps @db.* attribute names to PostgreSQL SQL types for use in VALUES table casts
+  static dbAttributeToSqlTypeMap = {
+    "@db.Uuid": "uuid",
+    "@db.Citext": "citext",
+    "@db.Inet": "inet",
+    "@db.Bit": "bit",
+    "@db.VarBit": "varbit",
+    "@db.Xml": "xml",
+    "@db.Json": "json",
+    "@db.JsonB": "jsonb",
+    "@db.ByteA": "bytea",
+    "@db.Text": "text",
+    "@db.Char": "bpchar",
+    "@db.VarChar": "varchar",
+    "@db.Date": "date",
+    "@db.Time": "time",
+    "@db.Timetz": "timetz",
+    "@db.Timestamp": "timestamp",
+    "@db.Timestamptz": "timestamptz",
+    "@db.SmallInt": "smallint",
+    "@db.Integer": "integer",
+    "@db.BigInt": "bigint",
+    "@db.Real": "real",
+    "@db.DoublePrecision": "double precision",
+    "@db.Decimal": "decimal",
+    "@db.Boolean": "boolean"
+  };
   constructor(schema, options) {
     super(schema, options);
     this.overrideTypeParsers();
@@ -2150,7 +2218,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") {
@@ -2206,14 +2274,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) {
@@ -2341,13 +2409,55 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
       receiver
     ]).as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  getSqlType(zmodelType) {
+  getSqlType(zmodelType, attributes) {
+    if (attributes) {
+      for (const attr of attributes) {
+        const mapped = _PostgresCrudDialect.dbAttributeToSqlTypeMap[attr.name];
+        if (mapped) {
+          return mapped;
+        }
+      }
+    }
     if (isEnum(this.schema, zmodelType)) {
       return "text";
     } else {
       return this.zmodelToSqlTypeMap[zmodelType] ?? "text";
     }
   }
+  // Resolves the effective SQL type for a field: the native type from any @db.* attribute,
+  // or the base ZModel SQL type if no attribute is present, or undefined if the field is unknown.
+  resolveFieldSqlType(fieldDef) {
+    if (!fieldDef) {
+      return {
+        sqlType: void 0,
+        hasDbOverride: false
+      };
+    }
+    const dbAttr = fieldDef.attributes?.find((a) => a.name.startsWith("@db."));
+    if (dbAttr) {
+      return {
+        sqlType: _PostgresCrudDialect.dbAttributeToSqlTypeMap[dbAttr.name],
+        hasDbOverride: true
+      };
+    }
+    return {
+      sqlType: this.getSqlType(fieldDef.type),
+      hasDbOverride: false
+    };
+  }
+  buildComparison(left, leftFieldDef, op, right, rightFieldDef) {
+    const leftResolved = this.resolveFieldSqlType(leftFieldDef);
+    const rightResolved = this.resolveFieldSqlType(rightFieldDef);
+    if (leftResolved.sqlType !== rightResolved.sqlType && (leftResolved.hasDbOverride || rightResolved.hasDbOverride)) {
+      if (leftResolved.hasDbOverride) {
+        left = this.eb.cast(left, import_kysely4.sql.raw(this.getSqlType(leftFieldDef.type)));
+      }
+      if (rightResolved.hasDbOverride) {
+        right = this.eb.cast(right, import_kysely4.sql.raw(this.getSqlType(rightFieldDef.type)));
+      }
+    }
+    return super.buildComparison(left, leftFieldDef, op, right, rightFieldDef);
+  }
   getStringCasingBehavior() {
     return {
       supportsILike: true,
@@ -2369,7 +2479,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     }
     const eb = (0, import_kysely4.expressionBuilder)();
     return eb.selectFrom(import_kysely4.sql`(VALUES ${import_kysely4.sql.join(rows.map((row) => import_kysely4.sql`(${import_kysely4.sql.join(row.map((v) => import_kysely4.sql.val(v)))})`), import_kysely4.sql.raw(", "))})`.as("$values")).select(fields.map((f, i) => {
-      const mappedType = this.getSqlType(f.type);
+      const mappedType = this.getSqlType(f.type, f.attributes);
       const castType = f.array ? import_kysely4.sql`${import_kysely4.sql.raw(mappedType)}[]` : import_kysely4.sql.raw(mappedType);
       return this.eb.cast(import_kysely4.sql.ref(`$values.column${i + 1}`), castType).as(f.name);
     }));
@@ -2384,7 +2494,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 {
@@ -2427,7 +2537,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);
@@ -2477,14 +2587,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) {
@@ -2600,8 +2710,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);
@@ -3034,7 +3144,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);
@@ -3046,8 +3156,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)) {
@@ -3076,8 +3186,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") {
@@ -3102,10 +3212,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();
   }
@@ -3127,7 +3237,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;
@@ -3174,13 +3284,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;
         }
@@ -3189,7 +3299,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);
@@ -3219,11 +3329,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) {
@@ -3286,7 +3396,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 = {};
@@ -3325,7 +3435,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;
@@ -3397,7 +3507,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: [
@@ -3416,7 +3526,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);
@@ -3519,7 +3629,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
           };
@@ -3578,7 +3688,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
         };
@@ -3629,7 +3739,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)();
@@ -3639,7 +3749,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)();
@@ -3670,7 +3780,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: [
@@ -3799,14 +3909,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;
         }
@@ -3823,12 +3933,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;
@@ -3845,7 +3955,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) {
@@ -3855,18 +3965,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: {
@@ -3892,7 +4002,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]
         });
@@ -3929,7 +4039,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;
     }
@@ -3954,6 +4064,10 @@ var BaseOperationHandler = class {
           true
         ];
       }
+    } else if (isEmptyObject(data)) {
+      disconnectConditions = [
+        true
+      ];
     } else {
       disconnectConditions = this.normalizeRelationManipulationInput(model, data);
       if (disconnectConditions.length === 0) {
@@ -3973,7 +4087,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) {
@@ -4076,9 +4190,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;
@@ -4086,6 +4200,15 @@ var BaseOperationHandler = class {
         deleteConditions = [
           true
         ];
+        if (uniqueDelete) {
+          expectedDeleteCount = 1;
+        }
+      }
+    } else if (isEmptyObject(data)) {
+      deleteConditions = [
+        true
+      ];
+      if (uniqueDelete) {
         expectedDeleteCount = 1;
       }
     } else {
@@ -4093,7 +4216,9 @@ var BaseOperationHandler = class {
       if (deleteConditions.length === 0) {
         return;
       }
-      expectedDeleteCount = deleteConditions.length;
+      if (uniqueDelete) {
+        expectedDeleteCount = deleteConditions.length;
+      }
     }
     let deleteResult;
     let deleteFromModel;
@@ -4101,7 +4226,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: [
           {
@@ -4125,7 +4250,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
@@ -4153,12 +4278,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) {
@@ -4279,7 +4404,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;
   }
@@ -4288,7 +4413,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);
         }
       }
@@ -4922,11 +5047,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");
@@ -5121,12 +5246,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) {
@@ -5210,7 +5335,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) {
@@ -5261,7 +5386,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 = {};
@@ -5313,7 +5438,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);
@@ -5606,7 +5731,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();
@@ -6149,7 +6274,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)) {
@@ -6169,8 +6294,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;
         }
@@ -6185,7 +6310,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;
         }
       }
@@ -6245,8 +6370,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;
@@ -6267,7 +6392,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
@@ -6321,7 +6446,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) {
@@ -6928,7 +7053,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) {
@@ -7189,12 +7314,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 {
@@ -7267,7 +7392,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
     }, () => {
@@ -7350,7 +7475,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
@@ -7654,7 +7779,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
@@ -8121,7 +8246,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) {
@@ -8130,7 +8255,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) {
@@ -8187,17 +8312,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}`);
@@ -8342,7 +8467,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");
@@ -8452,8 +8577,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;
@@ -8464,13 +8589,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");
@@ -8496,7 +8621,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;
               }
             });
@@ -8623,7 +8748,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) {
@@ -8698,7 +8823,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;
             }
           });
@@ -8733,7 +8858,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;
     }
@@ -9054,7 +9179,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.`);
@@ -9086,7 +9211,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 {
@@ -9485,7 +9610,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;
@@ -9536,7 +9661,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)) {