@m1212e/rumble 0.23.13 → 0.23.15

package/out/index.mjs

@@ -18,6 +18,7 @@ import DrizzlePlugin from "@pothos/plugin-drizzle";
 import SmartSubscriptionsPlugin, { subscribeOptionsFromIterator } from "@pothos/plugin-smart-subscriptions";
 import TracingPlugin, { isRootField, wrapResolver } from "@pothos/plugin-tracing";
 import { BigIntResolver, ByteResolver, DateResolver, DateTimeISOResolver, JSONResolver } from "graphql-scalars";
+import DataLoader from "dataloader";
 //#region lib/types/rumbleError.ts
 /**
 * An error that gets raised by rumble whenever something does not go according to plan.
@@ -180,7 +181,7 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.23.13";
+var version = "0.23.15";
 //#endregion
 //#region lib/helpers/mergeFilters.ts
 const EmptyFilter$1 = Symbol.for("drizzle:EmptyFilter");
@@ -219,7 +220,7 @@ function isPlainObject(value) {
 	return proto === Object.prototype || proto === null;
 }
 function sanitizeFilterValue(value) {
-	if (value === void 0) return EmptyFilter;
+	if (value === void 0 || value === null) return EmptyFilter;
 	if (Array.isArray(value)) return value.map(sanitizeFilterValue);
 	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, sanitizeFilterValue(entry)]));
 	return value;
@@ -2281,6 +2282,30 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 	tracer;
 	tracerEnabled;
 	logger;
+	filterLoaders = /* @__PURE__ */ new WeakMap();
+	getLoader(context, filter) {
+		let perContext = this.filterLoaders.get(context);
+		if (!perContext) {
+			perContext = /* @__PURE__ */ new Map();
+			this.filterLoaders.set(context, perContext);
+		}
+		let loader = perContext.get(filter);
+		if (!loader) {
+			const prefetchPromise = filter.prefetch ? filter.prefetch({ context }) : void 0;
+			loader = new DataLoader(async (entities) => {
+				const prefetched = prefetchPromise ? await prefetchPromise : void 0;
+				const allowed = await filter.filter({
+					context,
+					entities,
+					prefetched
+				});
+				const allowedSet = new Set(allowed);
+				return entities.map((entity) => allowedSet.has(entity) ? entity : null);
+			}, { cache: false });
+			perContext.set(filter, loader);
+		}
+		return loader;
+	}
 	onTypeConfig(typeConfig) {
 		this.tracer = this.builder.options.otel?.tracer;
 		this.tracerEnabled = this.builder.options.otel?.enabled;
@@ -2297,44 +2322,20 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 			const runFilters = async (span) => {
 				const allFilters = Array.isArray(filters) ? filters : [filters];
 				span?.setAttribute("filters.total", allFilters.length);
-				const prefetchedFiltersPromises = Promise.all(allFilters.map(async (filter) => {
-					if (filter.prefetch) {
-						const prefetched = await filter.prefetch({ context });
-						return ({ context, entities }) => filter.filter({
-							context,
-							entities,
-							prefetched
-						});
+				const loaders = allFilters.map((filter) => this.getLoader(context, filter));
+				let resolved;
+				if (this.tracer && this.tracerEnabled) resolved = await this.tracer.startActiveSpan(`rumble.filter.resolve`, async (span) => {
+					span.setAttribute("graphql.field.name", fieldConfig.name);
+					try {
+						return await resolver(parent, args, context, info);
+					} finally {
+						span.end();
 					}
-					return ({ context, entities }) => filter.filter({
-						context,
-						entities
-					});
-				}));
-				let resolved, prefetchedFilters;
-				if (this.tracer && this.tracerEnabled) {
-					const o = await this.tracer.startActiveSpan(`rumble.filter.resolve`, async (span) => {
-						span.setAttribute("graphql.field.name", fieldConfig.name);
-						try {
-							return await Promise.all([resolver(parent, args, context, info), prefetchedFiltersPromises]);
-						} finally {
-							span.end();
-						}
-					});
-					resolved = o[0];
-					prefetchedFilters = o[1];
-				} else {
-					const o = await Promise.all([resolver(parent, args, context, info), prefetchedFiltersPromises]);
-					resolved = o[0];
-					prefetchedFilters = o[1];
-				}
-				const allowed = Array.from((await Promise.all(prefetchedFilters.map((f) => f({
-					context,
-					entities: Array.isArray(resolved) ? resolved : [resolved]
-				})))).reduce((acc, val) => {
-					for (const element of val) acc.add(element);
-					return acc;
-				}, /* @__PURE__ */ new Set()));
+				});
+				else resolved = await resolver(parent, args, context, info);
+				const entities = Array.isArray(resolved) ? resolved : [resolved];
+				const perFilterResults = await Promise.all(loaders.map((loader) => Promise.all(entities.map((entity) => loader.load(entity)))));
+				const allowed = entities.filter((_, index) => perFilterResults.some((results) => results[index] != null));
 				span?.setAttribute("filters.allowed", allowed.length);
 				this.logger?.debug({
 					"graphql.field.name": fieldConfig.name,