@m1212e/rumble 0.23.4 → 0.23.5

package/out/index.mjs

@@ -180,12 +180,25 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.23.4";
+var version = "0.23.5";
 //#endregion
 //#region lib/helpers/mergeFilters.ts
+const EmptyFilter$1 = Symbol.for("drizzle:EmptyFilter");
+/**
+* Normalizes drizzle-orm's `EmptyFilter` sentinel to `undefined` so it's
+* treated as "no filter" rather than a real filter value to combine with
+* AND/OR — otherwise merging an unrestricted (EmptyFilter) base filter with
+* a real `where` would needlessly wrap it as `{ AND: [EmptyFilter, where] }`
+* instead of just `where`.
+*/
+function realWhere(where) {
+	return where === EmptyFilter$1 ? void 0 : where;
+}
 function mergeFilters(filterA, filterB, mode = "AND") {
+	const filterAWhere = realWhere(filterA?.where);
+	const filterBWhere = realWhere(filterB?.where);
 	return {
-		where: filterA?.where && filterB?.where ? mode === "OR" ? { OR: [filterA.where, filterB.where] } : { AND: [filterA.where, filterB.where] } : filterA?.where ?? filterB?.where,
+		where: filterAWhere && filterBWhere ? mode === "OR" ? { OR: [filterAWhere, filterBWhere] } : { AND: [filterAWhere, filterBWhere] } : filterAWhere ?? filterBWhere,
 		columns: filterA?.columns || filterB?.columns ? new Set([Object.entries(filterA?.columns ?? {}), Object.entries(filterB?.columns ?? {})].flat().filter(([, v]) => v === true).map(([k]) => k)).entries().reduce((acc, [key]) => {
 			acc[key] = true;
 			return acc;
@@ -412,6 +425,21 @@ function tableHelper({ db, table }) {
 }
 //#endregion
 //#region lib/abilityBuilder.ts
+/**
+* drizzle-orm's sentinel value for "this filter field is deliberately
+* skipped", as opposed to `undefined`, which some drizzle-orm versions
+* reject when it ends up as an explicit (present but `undefined`) `where`
+* property nested inside a relational `with` query.
+*
+* drizzle-orm defines this via `Symbol.for("drizzle:EmptyFilter")` — a
+* globally registered symbol — so recreating it the same way here yields
+* the exact same value drizzle-orm's relational query engine checks for,
+* without importing it directly: not every drizzle-orm version rumble
+* supports exports it as a named export, and older versions that don't know
+* about it at all still handle it safely (`Object.entries` on a symbol
+* yields no entries, i.e. "no filter").
+*/
+const EmptyFilter = Symbol.for("drizzle:EmptyFilter");
 function isDynamicQueryFilter(filter) {
 	return typeof filter === "function" && filter.constructor.name !== "AsyncFunction";
 }
@@ -580,7 +608,7 @@ by: (explicitFilter) => {
 									*/
 									single: {
 										extras: filters?.extras,
-										where: filters?.where,
+										where: filters?.where ?? EmptyFilter,
 										columns: filters?.columns
 									},
 									/**
@@ -588,7 +616,7 @@ by: (explicitFilter) => {
 									*/
 									many: {
 										extras: filters?.extras,
-										where: filters?.where,
+										where: filters?.where ?? EmptyFilter,
 										columns: filters?.columns,
 										get limit() {
 											return limit();
@@ -634,14 +662,14 @@ by: (explicitFilter) => {
 									*/
 									single: {
 										extras: filters?.extras,
-										where: filters?.where
+										where: filters?.where ?? EmptyFilter
 									},
 									/**
 									* For find many calls
 									*/
 									many: {
 										extras: filters?.extras,
-										where: filters?.where,
+										where: filters?.where ?? EmptyFilter,
 										get limit() {
 											return limit();
 										}