@m1212e/rumble 0.23.4 → 0.23.7

package/out/index.mjs

@@ -180,12 +180,25 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.23.4";
+var version = "0.23.7";
 //#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();
 										}
@@ -1834,7 +1862,7 @@ const createPubSubInstance = ({ subscriptions }) => {
 //#region lib/query.ts
 const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfig, whereArgImplementer, orderArgImplementer, makePubSubInstance }) => {
 	const registeredQueryFieldNames = /* @__PURE__ */ new Set();
-	return ({ table, readAction = "read", listAction = "read" }) => {
+	return ({ table, readAction = "read", listAction = "read", findFirst, findMany }) => {
 		const WhereArg = whereArgImplementer({ table });
 		const OrderArg = orderArgImplementer({ table });
 		const tableSchema = tableHelper({
@@ -1893,8 +1921,13 @@ const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfi
 						const filter = ctx.abilities[table].filter(listAction).merge(mappedArgs).query.many;
 						if (mappedArgs.offset) filter.offset = mappedArgs.offset;
 						if (mappedArgs.orderBy) filter.orderBy = mappedArgs.orderBy;
-						const queryInstance = query(filter);
-						if (filter.columns) queryInstance.columns = filter.columns;
+						const queryArgs = query(filter);
+						if (filter.columns) queryArgs.columns = filter.columns;
+						const run = findMany ? (tx) => findMany({
+							tx,
+							filter,
+							queryArgs
+						}) : (tx) => tx.query[table].findMany(queryArgs);
 						if (search?.enabled && args.search && args.search.length > 0 && search?.cpu_operator_cost) return db.transaction(async (tx) => {
 							if (isPostgresDB(tx)) await tx.execute(sql.raw(`SET cpu_operator_cost = ${search.cpu_operator_cost};`));
 							else {
@@ -1902,9 +1935,9 @@ const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfi
 								const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
 								log ? log.info({}, msg) : console.info(msg);
 							}
-							return tx.query[table].findMany(queryInstance);
+							return run(tx);
 						});
-						return db.query[table].findMany(queryInstance);
+						return run(db);
 					}
 				}),
 				[singularName]: t.drizzleField({
@@ -1916,9 +1949,13 @@ const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfi
 					resolve: (query, _root, args, ctx, _info) => {
 						deepSetProto(args);
 						const filter = ctx.abilities[table].filter(readAction).merge({ where: { [primaryKeyField.name]: args.id } }).query.single;
-						const q = query(filter);
-						if (filter.columns) q.columns = filter.columns;
-						return db.query[table].findFirst(q).then(assertFindFirstExists);
+						const queryArgs = query(filter);
+						if (filter.columns) queryArgs.columns = filter.columns;
+						return findFirst ? findFirst({
+							tx: db,
+							filter,
+							queryArgs
+						}) : db.query[table].findFirst(queryArgs).then(assertFindFirstExists);
 					}
 				})
 			};