@vantreeseba/drizzle-graphql 11.0.2 → 12.0.0

package/dist/index.js

@@ -520,11 +520,12 @@ const isJsonColumn = (column) => (column.dataType ?? "").includes("json") && col
 *                       StringArray, …) so arrays with different element types never share
 *                       one filter input; membership operators instead of scalar comparisons
 * - "Id"          → uuid-typed columns (no string pattern operators)
-* - "Boolean"     → boolean columns
+* - "Boolean"     → boolean columns (equality and membership only — no ordering, no patterns)
 * - "BigInt"      → bigint columns (BigInt-scalar-typed operators, no string pattern operators)
 * - "Decimal"     → numeric/decimal columns (Decimal-scalar-typed operators, no string pattern operators)
-* - the enum GraphQL type name → enum columns (still unique per enum)
-* - "DateTime"    → timestamp and date columns
+* - the enum GraphQL type name → enum columns (still unique per enum; equality and
+*                       membership only, like Boolean)
+* - "DateTime"    → timestamp and date columns (ordering kept, no string pattern operators)
 * - "Int"         → integer/serial columns (no string pattern operators)
 * - "Float"       → real/double columns (no string pattern operators)
 * - "String"      → all other text/varchar columns
@@ -552,7 +553,8 @@ const resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
 	};
 	if (columnGraphQLType.type instanceof GraphQLEnumType) return {
 		name: columnGraphQLType.type.name,
-		kind: "scalar"
+		kind: "scalar",
+		isEnum: true
 	};
 	if (columnGraphQLType.type === GraphQLBigIntString) return {
 		name: "BigInt",
@@ -776,18 +778,32 @@ const arrayFilterFields = (colType, colArr) => {
 };
 /**
 * Filters whose fields omit the string pattern operators (like/notLike/ilike/notIlike/
-* startsWith/contains/…): they are nonsensical on opaque uuids and invalid SQL on numeric
-* columns. Keyed on the generic filter name (i.e. on column type) — a string-typed column
-* keeps the string operators whatever it is called.
+* startsWith/contains/… and the `insensitive` flag that modifies them): they are nonsensical
+* on opaque uuids, booleans and enum members, invalid SQL on numeric columns, and on a
+* timestamp they match whatever the session happens to render the value as rather than
+* anything in the query. Keyed on the generic filter name (i.e. on column type) — a
+* string-typed column keeps the string operators whatever it is called. Enum filters are
+* named after their enum and are recognised by `isEnum` instead.
 */
 const FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set([
 	"Id",
 	"Int",
 	"Float",
 	"BigInt",
-	"Decimal"
+	"Decimal",
+	"Boolean",
+	"Date",
+	"DateTime"
 ]);
 /**
+* Filters that additionally omit the ordering operators (lt/lte/gt/gte). Ordering two
+* booleans is `eq` spelled as a puzzle (`gt: false` is `eq: true`), and ordering enum members
+* compares their declaration order — an artefact of how the column was written rather than a
+* fact about the domain. Timestamps and the numerics keep them: ranges are the point of
+* having them. Enum filters are recognised by `isEnum`, as above.
+*/
+const FILTERS_WITHOUT_ORDERING_OPS = /* @__PURE__ */ new Set(["Boolean"]);
+/**
 * Scalars the built-in detection itself can produce. A scalar override to one of these
 * shares the built-in filter type for that scalar, so its shape must stay exactly what a
 * natural column of the scalar gets — whichever column builds the cached type first.
@@ -830,14 +846,15 @@ const resolveOverrideFilterDescriptor = (scalar) => {
 const generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
 	const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
 	const inputOverride = getColumnScalarOverride(column, true);
-	const { name: genericName, kind } = inputOverride ? resolveOverrideFilterDescriptor(inputOverride) : resolveGenericFilterDescriptor(column, columnGraphQLType);
+	const { name: genericName, kind, isEnum } = inputOverride ? resolveOverrideFilterDescriptor(inputOverride) : resolveGenericFilterDescriptor(column, columnGraphQLType);
 	const cached = cacheCtx.genericFilterCache.get(genericName);
 	if (cached) return cached;
 	const colType = columnGraphQLType.type;
 	const colArr = new GraphQLList(new GraphQLNonNull(colType));
 	const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
 	const underlying = extractExtendedColumnType(column);
-	const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : FILTERS_WITHOUT_STRING_OPS.has(genericName);
+	const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : isEnum || FILTERS_WITHOUT_STRING_OPS.has(genericName);
+	const omitOrderingOps = !customOverrideFilter && (isEnum || FILTERS_WITHOUT_ORDERING_OPS.has(genericName));
 	const baseFields = kind === "json" ? jsonFilterFields(column, colType, cacheCtx.typeName) : kind === "array" ? arrayFilterFields(colType, colArr) : {
 		eq: {
 			type: colType,
@@ -847,21 +864,23 @@ const generateColumnFilterValues = (column, tableName, columnName, cacheCtx) =>
 			type: colType,
 			description: "Not equal to"
 		},
-		lt: {
-			type: colType,
-			description: "Less than"
-		},
-		lte: {
-			type: colType,
-			description: "Less than or equal to"
-		},
-		gt: {
-			type: colType,
-			description: "Greater than"
-		},
-		gte: {
-			type: colType,
-			description: "Greater than or equal to"
+		...omitOrderingOps ? {} : {
+			lt: {
+				type: colType,
+				description: "Less than"
+			},
+			lte: {
+				type: colType,
+				description: "Less than or equal to"
+			},
+			gt: {
+				type: colType,
+				description: "Greater than"
+			},
+			gte: {
+				type: colType,
+				description: "Greater than or equal to"
+			}
 		},
 		...omitStringOps ? {} : {
 			like: { type: GraphQLString },
@@ -2883,6 +2902,154 @@ const listFieldComplexity = (options, policy) => ({ args, childComplexity }) =>
 */
 const aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
 //#endregion
+//#region src/util/parse-resolve-info.ts
+/** Unwraps `[T]!`-style wrappers down to the named type. `getNamedType` without the realm tie. */
+const namedTypeOf = (type) => {
+	let current = type;
+	while (current?.ofType) current = current.ofType;
+	return current;
+};
+/**
+* Whether a field's named output type has sub-selections. Object types and interfaces expose
+* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
+* also expose `getFields`, but an input type can never be a field's output type, so there is
+* nothing here for that to collide with.
+*/
+const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
+/**
+* The fields declared on a type, or `undefined` when it has none to declare. A union is the
+* case that matters: it has no fields of its own, so a selection directly against one resolves
+* to nothing and is dropped — only the inline fragments underneath contribute.
+*/
+const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
+/**
+* The runtime variable values, in the plain-map form the directive check wants. graphql 17
+* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
+*/
+const coercedVariables = (info) => {
+	const values = info.variableValues;
+	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
+	return values ?? {};
+};
+/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
+const directiveIfValue = (info, value) => {
+	if (value.kind === Kind.VARIABLE) return coercedVariables(info)[value.name.value];
+	if (value.kind === Kind.BOOLEAN) return value.value;
+};
+/**
+* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
+* spreads and inline fragments alike, which is where graphql puts them.
+*/
+const isExcluded = (info, node) => {
+	for (const directive of node.directives ?? []) {
+		const directiveName = directive.name.value;
+		if (directiveName !== "skip" && directiveName !== "include") continue;
+		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
+		if (!ifArgument) continue;
+		const value = directiveIfValue(info, ifArgument.value);
+		if (directiveName === "skip" ? !!value : !value) return true;
+	}
+	return false;
+};
+/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
+const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
+/**
+* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
+* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
+* to declare a field by that name.
+*/
+const isMetaField = (name) => name.startsWith("__") && name !== "__id";
+/**
+* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
+* level, this owns the entries under `parentType`'s name.
+*
+* `activeFragments` is the set of fragment names on the current spread path. A document that
+* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
+* caller assembled by hand, and an unbounded walk would hang rather than fail.
+*/
+const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
+	const parentTypeName = parentType?.name;
+	if (!parentTypeName) return tree;
+	let fields = tree[parentTypeName];
+	if (!fields) {
+		fields = {};
+		tree[parentTypeName] = fields;
+	}
+	const parentFields = fieldsOf(parentType);
+	for (const selection of selections) {
+		if (isExcluded(info, selection)) continue;
+		if (selection.kind === Kind.FIELD) {
+			const name = selection.name.value;
+			if (isMetaField(name)) continue;
+			const fieldDef = parentFields?.[name];
+			if (!fieldDef) continue;
+			const fieldType = namedTypeOf(fieldDef.type);
+			if (!fieldType) continue;
+			const composite = isCompositeLike(fieldType);
+			const alias = selection.alias?.value || name;
+			let node = fields[alias];
+			if (!node) {
+				node = {
+					name,
+					alias,
+					args: { ...getArgumentValues(fieldDef, selection, info.variableValues) },
+					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
+				};
+				fields[alias] = node;
+			}
+			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
+			continue;
+		}
+		if (!deep) continue;
+		if (selection.kind === Kind.FRAGMENT_SPREAD) {
+			const fragmentName = selection.name.value;
+			const fragment = info.fragments?.[fragmentName];
+			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
+			if (activeFragments.has(fragmentName)) continue;
+			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			activeFragments.add(fragmentName);
+			try {
+				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+			} finally {
+				activeFragments.delete(fragmentName);
+			}
+			continue;
+		}
+		if (selection.kind === Kind.INLINE_FRAGMENT) {
+			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+		}
+	}
+	return tree;
+};
+/** The first key of an object, without materializing the whole key array to discard it. */
+const firstKey = (object) => {
+	for (const key in object) return key;
+};
+/**
+* Reads the selection under a resolver's own field out of its `info`, as a tree of
+* {@link ResolveTree} nodes.
+*
+* ```ts
+* const parsed = parseResolveInfo(info, { deep: true })!;
+* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+* ```
+*
+* Returns `undefined` when the resolver's field produced no node at all, which in practice
+* means `info` carried no field nodes.
+*/
+const parseResolveInfo = (info, options = {}) => {
+	const fieldNodes = info.fieldNodes;
+	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
+	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
+	const typeKey = firstKey(tree);
+	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
+	const fieldKey = fields && firstKey(fields);
+	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
+};
+//#endregion
 //#region src/util/builders/field-updates.ts
 /**
 * The scalars arithmetic is offered on. Decimal and BigInt transport as strings but are
@@ -3215,75 +3382,196 @@ const pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
 	for (const [tableName, rels] of Object.entries(relationMap)) out[tableName] = Object.fromEntries(Object.entries(rels).filter(([relationName]) => shouldEagerLoad(tableName, relationName)));
 	return out;
 };
-const createMutationTxCtx = (options) => options ? {
-	timeoutMs: options.timeoutMs,
-	fieldNames: /* @__PURE__ */ new Set(),
-	states: /* @__PURE__ */ new WeakMap()
-} : void 0;
-const includedByDirectives = (node, variables) => {
-	for (const directive of node.directives ?? []) {
-		const name = directive.name.value;
-		if (name !== "skip" && name !== "include") continue;
-		const ifArg = directive.arguments?.find((arg) => arg.name.value === "if");
-		let value;
-		if (ifArg?.value.kind === "BooleanValue") value = ifArg.value.value;
-		else if (ifArg?.value.kind === "Variable") value = variables?.[ifArg.value.name.value];
-		if (name === "skip" && value === true) return false;
-		if (name === "include" && value !== true) return false;
-	}
-	return true;
-};
+//#endregion
+//#region src/util/builders/common/select-runtime.ts
 /**
-* Collects the response keys of every root mutation field the executor will run, expanding
-* fragments and honoring `@skip` / `@include`. Distinct response keys (alias ?? name) are
-* counted, matching graphql-js field collection, so a field selected twice under one key is
-* still one resolver call. Returns `false` when the document selects a root mutation field
-* this build did not generate — its completion cannot be tracked, so the caller must not
-* open a transaction it might never be able to close.
+* Runs the relational-query-builder select shared by every dialect's `generateSelect*`
+* resolver: selected columns + offset/limit + aliased orderBy/where callbacks + the eager
+* `with:` relation params, then remaps the result. `single` switches between
+* findFirst/findMany (and the single path omits `limit`). The PG fallback for tables
+* without RQB support stays in pg.ts; this covers the common RQB path for all three.
 */
-const collectRootMutationKeys = (selectionSet, fragments, variables, known, keys, visitedFragments) => {
-	for (const selection of selectionSet.selections) {
-		if (!includedByDirectives(selection, variables)) continue;
-		if (selection.kind === "Field") {
-			const name = selection.name.value;
-			if (name === "__typename") continue;
-			if (!known.has(name)) return false;
-			keys.add(selection.alias?.value ?? name);
-		} else if (selection.kind === "InlineFragment") {
-			if (!collectRootMutationKeys(selection.selectionSet, fragments, variables, known, keys, visitedFragments)) return false;
-		} else if (selection.kind === "FragmentSpread") {
-			const fragmentName = selection.name.value;
-			if (visitedFragments.has(fragmentName)) continue;
-			visitedFragments.add(fragmentName);
-			const fragment = fragments?.[fragmentName];
-			if (!fragment) return false;
-			if (!collectRootMutationKeys(fragment.selectionSet, fragments, variables, known, keys, visitedFragments)) return false;
-		}
+const runRelationalSelect = async (opts) => {
+	const { queryBase, tables, tableName, table, relationMap, typeName, typeNameMapper, parsedInfo, offset, orderBy, where, single, filterCtx, pkNames, after, scope, deleted } = opts;
+	const distinct = opts.distinct?.length ? opts.distinct : void 0;
+	const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
+	let cursorEntries;
+	if (!single && (after != null || cursorSelected)) {
+		if (after != null && distinct) throw drizzleError("'after' cannot be combined with 'distinct'.", { code: "DRIZZLE_INVALID_CURSOR" });
+		const cursorObstacle = orderByCursorObstacle(orderBy);
+		if (cursorObstacle) {
+			if (after != null) throw drizzleError(cursorObstacle, { code: "DRIZZLE_INVALID_CURSOR" });
+		} else if (!pkNames?.length) {
+			if (after != null) throw drizzleError(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`, { code: "DRIZZLE_INVALID_CURSOR" });
+		} else cursorEntries = cursorOrderingEntries(orderBy, pkNames);
 	}
-	return true;
-};
-const abortedBatchError = () => drizzleError("Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back.", { code: "DRIZZLE_TRANSACTION_ABORTED" });
-/** Opens the request-wide transaction and wires up latch, inactivity timer and cleanup. */
-const openSharedTx = (db, context, txCtx, stateKey, expected) => {
-	let release;
-	let rejectLatch;
-	const latch = new Promise((resolve, reject) => {
-		release = resolve;
-		rejectLatch = reject;
-	});
-	let readyResolve;
-	let readyReject;
-	const ready = new Promise((resolve, reject) => {
-		readyResolve = resolve;
-		readyReject = reject;
-	});
-	ready.catch(() => {});
-	const canStash = context !== null && typeof context === "object" && !Object.isFrozen(context);
-	const settled = db.transaction(async (tx) => {
-		if (canStash) context[drizzleExecutorKey] = tx;
-		readyResolve(tx);
-		await latch;
-	});
+	const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
+	const needsDefaultOrder = single || offset != null || opts.limit != null;
+	let distinctKeys;
+	if (distinct) {
+		distinctKeys = await selectDistinctKeys({
+			db: opts.db,
+			table,
+			tableName,
+			distinct,
+			pkNames: pkNames ?? [],
+			where: withScope(scope, tableName, table, where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0, deleted),
+			orderBy,
+			limit: single ? 1 : opts.limit,
+			offset
+		});
+		if (!distinctKeys.length) return single ? void 0 : [];
+	}
+	const params = {
+		columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table, {
+			tableName,
+			relationMap,
+			tables,
+			allRelations: filterCtx?.relationMap
+		}),
+		offset: distinctKeys ? void 0 : offset,
+		orderBy: distinctKeys ? (aliasedTable) => [...orderBy ? extractOrderBy(aliasedTable, orderBy, relationFilterCtx(filterCtx, tableName), where) : [], ...primaryKeyOrderExprs(aliasedTable, pkNames)] : cursorEntries ? (aliasedTable) => cursorOrderExprs(aliasedTable, cursorEntries) : orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy, relationFilterCtx(filterCtx, tableName), where) : needsDefaultOrder && pkNames?.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0,
+		where: distinctKeys ? { RAW: (aliasedTable) => primaryKeyRestriction(aliasedTable, pkNames, distinctKeys) } : where || cursorValues || scope?.has(tableName, deleted) ? { RAW: (aliasedTable) => withScope(scope, tableName, aliasedTable, and(where ? extractFilters(aliasedTable, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0, cursorValues ? buildCursorCondition(aliasedTable, cursorEntries, cursorValues, opts.nullOrdering ?? "nulls-smallest") : void 0), deleted) } : void 0,
+		with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, {
+			typeNameMapper,
+			filterCtx,
+			limits: opts.limits,
+			scope,
+			defaultOrderBy: opts.defaultOrderBy,
+			resolveName: opts.resolveName
+		}) : void 0
+	};
+	if (single) {
+		const result = await queryBase.findFirst(params);
+		return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
+	}
+	if (cursorEntries && cursorSelected) for (const [column] of cursorEntries) params.columns[column] = true;
+	params.limit = distinctKeys ? void 0 : opts.limit;
+	const result = await queryBase.findMany(params);
+	if (cursorEntries && cursorSelected) attachRowCursors(result, cursorEntries);
+	return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
+};
+/**
+* After a mutation, re-fetch the mutated rows through the relational query builder so the
+* selected relations are eagerly loaded in a single query, then merge those relations onto
+* the `.returning()` rows — making the per-field BatchLoader fallback unnecessary.
+*
+* `withParams` is the pre-computed relation selection (from extractRelationsParams); the
+* caller only invokes this when relations are actually selected, so it also gates whether
+* the PK was forced into RETURNING.
+*
+* Falls back to the original `.returning()` rows (relations then resolve via the
+* field-level BatchLoader) when the table has no RQB support, no primary key columns can be
+* determined, or the re-fetch fails. Supports single- and multi-column primary keys.
+*/
+const eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams) => {
+	if (!rows.length || !pkNames.length || !withParams || !Object.keys(withParams).length) return rows;
+	const queryBase = db.query?.[tableName];
+	if (!queryBase) return rows;
+	const keyableRows = rows.filter((row) => pkNames.every((n) => row[n] != null));
+	if (!keyableRows.length) return rows;
+	const pkColumns = {};
+	for (const pk of pkNames) pkColumns[pk] = true;
+	const relationNames = Object.keys(withParams);
+	const keyOf = (row) => JSON.stringify(pkNames.map((n) => typeof row[n] === "bigint" ? row[n].toString() : row[n]));
+	let whereRaw;
+	if (pkNames.length === 1) {
+		const pkName = pkNames[0];
+		const ids = keyableRows.map((r) => r[pkName]);
+		whereRaw = (aliased) => inArray(aliased[pkName], ids);
+	} else whereRaw = (aliased) => {
+		const lhs = sql.join(pkNames.map((n) => sql`${aliased[n]}`), sql`, `);
+		const tuples = sql.join(keyableRows.map((row) => sql`(${sql.join(pkNames.map((n) => sql`${row[n]}`), sql`, `)})`), sql`, `);
+		return sql`(${lhs}) in (${tuples})`;
+	};
+	let enriched;
+	try {
+		enriched = await queryBase.findMany({
+			columns: pkColumns,
+			where: { RAW: whereRaw },
+			with: withParams
+		});
+	} catch (err) {
+		console.warn(`[drizzle-graphql] eager-loading relations for a "${tableName}" mutation failed; falling back to lazy resolution.`, err);
+		return rows;
+	}
+	const byKey = new Map(enriched.map((e) => [keyOf(e), e]));
+	for (const row of rows) {
+		const match = byKey.get(keyOf(row));
+		if (!match) continue;
+		for (const rel of relationNames) row[rel] = match[rel];
+	}
+	return rows;
+};
+const createMutationTxCtx = (options) => options ? {
+	timeoutMs: options.timeoutMs,
+	fieldNames: /* @__PURE__ */ new Set(),
+	states: /* @__PURE__ */ new WeakMap()
+} : void 0;
+const includedByDirectives = (node, variables) => {
+	for (const directive of node.directives ?? []) {
+		const name = directive.name.value;
+		if (name !== "skip" && name !== "include") continue;
+		const ifArg = directive.arguments?.find((arg) => arg.name.value === "if");
+		let value;
+		if (ifArg?.value.kind === "BooleanValue") value = ifArg.value.value;
+		else if (ifArg?.value.kind === "Variable") value = variables?.[ifArg.value.name.value];
+		if (name === "skip" && value === true) return false;
+		if (name === "include" && value !== true) return false;
+	}
+	return true;
+};
+/**
+* Collects the response keys of every root mutation field the executor will run, expanding
+* fragments and honoring `@skip` / `@include`. Distinct response keys (alias ?? name) are
+* counted, matching graphql-js field collection, so a field selected twice under one key is
+* still one resolver call. Returns `false` when the document selects a root mutation field
+* this build did not generate — its completion cannot be tracked, so the caller must not
+* open a transaction it might never be able to close.
+*/
+const collectRootMutationKeys = (selectionSet, fragments, variables, known, keys, visitedFragments) => {
+	for (const selection of selectionSet.selections) {
+		if (!includedByDirectives(selection, variables)) continue;
+		if (selection.kind === "Field") {
+			const name = selection.name.value;
+			if (name === "__typename") continue;
+			if (!known.has(name)) return false;
+			keys.add(selection.alias?.value ?? name);
+		} else if (selection.kind === "InlineFragment") {
+			if (!collectRootMutationKeys(selection.selectionSet, fragments, variables, known, keys, visitedFragments)) return false;
+		} else if (selection.kind === "FragmentSpread") {
+			const fragmentName = selection.name.value;
+			if (visitedFragments.has(fragmentName)) continue;
+			visitedFragments.add(fragmentName);
+			const fragment = fragments?.[fragmentName];
+			if (!fragment) return false;
+			if (!collectRootMutationKeys(fragment.selectionSet, fragments, variables, known, keys, visitedFragments)) return false;
+		}
+	}
+	return true;
+};
+const abortedBatchError = () => drizzleError("Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back.", { code: "DRIZZLE_TRANSACTION_ABORTED" });
+/** Opens the request-wide transaction and wires up latch, inactivity timer and cleanup. */
+const openSharedTx = (db, context, txCtx, stateKey, expected) => {
+	let release;
+	let rejectLatch;
+	const latch = new Promise((resolve, reject) => {
+		release = resolve;
+		rejectLatch = reject;
+	});
+	let readyResolve;
+	let readyReject;
+	const ready = new Promise((resolve, reject) => {
+		readyResolve = resolve;
+		readyReject = reject;
+	});
+	ready.catch(() => {});
+	const canStash = context !== null && typeof context === "object" && !Object.isFrozen(context);
+	const settled = db.transaction(async (tx) => {
+		if (canStash) context[drizzleExecutorKey] = tx;
+		readyResolve(tx);
+		await latch;
+	});
 	let timer;
 	const clearTimer = () => {
 		if (timer !== void 0) {
@@ -3393,12 +3681,6 @@ const hardDeleteArg = {
 	defaultValue: false,
 	description: "Remove the matched rows instead of marking them deleted. Reads at `INCLUDE`, so it reaches rows that are already marked; a `scope` still confines what it can reach."
 };
-/**
-* Computes the RETURNING columns and relation selection for a mutation resolver: extracts
-* the selected scalar columns, determines whether any relations were selected, and only
-* then forces the primary key into the column set (so the post-mutation eager-load can
-* re-key rows). Returns everything the resolver needs to decide whether to eager-load.
-*/
 const prepareMutationRelationColumns = (params) => {
 	const { relationMap, tables, tableName, typeNameMapper, table, pkNames, parsedInfo, resolveName } = params;
 	const typeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
@@ -3422,6 +3704,38 @@ const prepareMutationRelationColumns = (params) => {
 	};
 };
 /**
+* The prologue every write resolver runs: parse the resolve info, then work out the columns
+* to return and the relations to eager-load from it. `parsedInfo` comes back too — the delete
+* resolver reads its own columns off the tree rather than taking the prepared set.
+*/
+const mutationSelection = (info, params) => {
+	const parsedInfo = parseResolveInfo(info, { deep: true });
+	return {
+		parsedInfo,
+		...prepareMutationRelationColumns({
+			...params,
+			parsedInfo
+		})
+	};
+};
+/**
+* The `where` a write runs under: the caller's filters — required when the mutation refuses to
+* run unbounded — with the row scope ANDed on last, so a supplied filter can only narrow the
+* scope and never widen it. An out-of-scope row is simply not matched.
+*
+* `deleted` states which soft-delete mode the match reads at, for the writes that need one:
+* `restore` sees only marked rows, a hard delete has to see them too.
+*/
+const scopedWhere = (params) => {
+	const { scope, tableName, table, where, relationCtx, required, deleted } = params;
+	return withScope(scope, tableName, table, required ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0, deleted);
+};
+/**
+* The epilogue: the written rows with their selected relations attached, or the rows as they
+* came back when the selection asked for no relation at all.
+*/
+const withEagerRelations = (executor, tableName, rows, pkNames, withParams, hasRelations) => hasRelations ? eagerLoadMutationRelations(executor, tableName, rows, pkNames, withParams) : rows;
+/**
 * The per-entry input of `update<Table>Many`: `{ where, set }`, reusing the table's
 * update `set` input and filter input. Shared by all three dialect builders.
 */
@@ -3521,8 +3835,14 @@ const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, f
 			try {
 				return await runMutation(db, context, info, txCtx, async (executor) => {
 					const { where, set } = args;
-					const relationCtx = relationFilterCtx(filterCtx, tableName);
-					const filters = requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+					const filters = scopedWhere({
+						scope: void 0,
+						tableName,
+						table,
+						where,
+						relationCtx: relationFilterCtx(filterCtx, tableName),
+						required: requireWhere
+					});
 					let query;
 					if (kind === "delete") query = executor.delete(table);
 					else {
@@ -3660,260 +3980,112 @@ const relationFieldExtension = (params) => ({
 });
 /** Pulls the primary-key values out of one `values` entry; `undefined` if any are missing. */
 const keyFromValues = (entry, primaryKey) => {
-	if (!entry || typeof entry !== "object") return;
-	const row = {};
-	for (const column of primaryKey) {
-		const value = entry[column];
-		if (value === void 0 || value === null) return;
-		row[column] = value;
-	}
-	return row;
-};
-/**
-* Pulls primary-key values out of a filter argument.
-*
-* Only top-level equality counts: `{ id: { eq } }` names one row, `{ id: { inArray } }`
-* names a list, and a composite key needs `eq` on every one of its columns. A boolean
-* group (`OR` / `AND` / `NOT`) or any other operator on a key column means the filter is
-* not a key lookup, and the rows are reported as not identified.
-*/
-const keysFromWhere = (where, primaryKey) => {
-	const none = {
-		rows: [],
-		complete: false
-	};
-	if (!where || typeof where !== "object" || Array.isArray(where)) return none;
-	const filters = where;
-	if (filters.OR || filters.AND || filters.NOT) return none;
-	if (primaryKey.length > 1) {
-		const row = {};
-		for (const column of primaryKey) {
-			const operators = filters[column];
-			if (!operators || typeof operators !== "object" || operators.eq === void 0) return none;
-			row[column] = operators.eq;
-		}
-		return {
-			rows: [row],
-			complete: Object.keys(filters).length === primaryKey.length
-		};
-	}
-	const column = primaryKey[0];
-	if (!column) return none;
-	const operators = filters[column];
-	if (!operators || typeof operators !== "object") return none;
-	const exact = Object.keys(filters).length === 1 && Object.keys(operators).length === 1;
-	if (operators.eq !== void 0) return {
-		rows: [{ [column]: operators.eq }],
-		complete: exact
-	};
-	if (Array.isArray(operators.inArray)) return {
-		rows: operators.inArray.map((value) => ({ [column]: value })),
-		complete: exact
-	};
-	return none;
-};
-/**
-* The rows a generated field's arguments are about, as primary-key values.
-*
-* The row identity of a mutation lives in a different argument for every operation —
-* `where` for update and delete, `values` for insert and upsert, a per-entry `where` inside
-* `updates` for the batch update — and each of those has both a one-row and a many-row
-* spelling. This reads whichever one applies:
-*
-* ```ts
-* const field = info.parentType.getFields()[info.fieldName];
-* const target = identifyRows(field, args);
-* if (target?.complete) await invalidate(target.table, target.rows);
-* ```
-*
-* Returns `undefined` for a field this library did not generate, or an object type. Check
-* `complete` before treating `rows` as the affected set — see {@link IdentifiedRows}.
-*/
-const identifyRows = (field, args) => {
-	const meta = drizzleExtension(field);
-	if (!isDrizzleFieldExtension(meta)) return;
-	const { table, primaryKey, targetArg } = meta;
-	const empty = {
-		table,
-		primaryKey,
-		rows: [],
-		complete: false
-	};
-	if (!primaryKey.length || !targetArg) return empty;
-	const target = args?.[targetArg];
-	if (targetArg === "values") {
-		const entries = Array.isArray(target) ? target : target === void 0 ? [] : [target];
-		const rows = entries.map((entry) => keyFromValues(entry, primaryKey));
-		return {
-			table,
-			primaryKey,
-			rows: rows.filter((row) => !!row),
-			complete: entries.length > 0 && rows.every(Boolean)
-		};
-	}
-	if (targetArg === "updates") {
-		if (!Array.isArray(target)) return empty;
-		const perEntry = target.map((entry) => keysFromWhere(entry?.where, primaryKey));
-		return {
-			table,
-			primaryKey,
-			rows: perEntry.flatMap((entry) => entry.rows),
-			complete: target.length > 0 && perEntry.every((entry) => entry.complete)
-		};
-	}
-	return {
-		table,
-		primaryKey,
-		...keysFromWhere(target, primaryKey)
-	};
-};
-//#endregion
-//#region src/util/parse-resolve-info.ts
-/** Unwraps `[T]!`-style wrappers down to the named type. `getNamedType` without the realm tie. */
-const namedTypeOf = (type) => {
-	let current = type;
-	while (current?.ofType) current = current.ofType;
-	return current;
-};
-/**
-* Whether a field's named output type has sub-selections. Object types and interfaces expose
-* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
-* also expose `getFields`, but an input type can never be a field's output type, so there is
-* nothing here for that to collide with.
-*/
-const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
-/**
-* The fields declared on a type, or `undefined` when it has none to declare. A union is the
-* case that matters: it has no fields of its own, so a selection directly against one resolves
-* to nothing and is dropped — only the inline fragments underneath contribute.
-*/
-const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
-/**
-* The runtime variable values, in the plain-map form the directive check wants. graphql 17
-* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
-*/
-const coercedVariables = (info) => {
-	const values = info.variableValues;
-	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
-	return values ?? {};
-};
-/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
-const directiveIfValue = (info, value) => {
-	if (value.kind === Kind.VARIABLE) return coercedVariables(info)[value.name.value];
-	if (value.kind === Kind.BOOLEAN) return value.value;
-};
-/**
-* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
-* spreads and inline fragments alike, which is where graphql puts them.
-*/
-const isExcluded = (info, node) => {
-	for (const directive of node.directives ?? []) {
-		const directiveName = directive.name.value;
-		if (directiveName !== "skip" && directiveName !== "include") continue;
-		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
-		if (!ifArgument) continue;
-		const value = directiveIfValue(info, ifArgument.value);
-		if (directiveName === "skip" ? !!value : !value) return true;
-	}
-	return false;
-};
-/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
-const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
-/**
-* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
-* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
-* to declare a field by that name.
-*/
-const isMetaField = (name) => name.startsWith("__") && name !== "__id";
-/**
-* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
-* level, this owns the entries under `parentType`'s name.
-*
-* `activeFragments` is the set of fragment names on the current spread path. A document that
-* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
-* caller assembled by hand, and an unbounded walk would hang rather than fail.
-*/
-const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
-	const parentTypeName = parentType?.name;
-	if (!parentTypeName) return tree;
-	let fields = tree[parentTypeName];
-	if (!fields) {
-		fields = {};
-		tree[parentTypeName] = fields;
-	}
-	const parentFields = fieldsOf(parentType);
-	for (const selection of selections) {
-		if (isExcluded(info, selection)) continue;
-		if (selection.kind === Kind.FIELD) {
-			const name = selection.name.value;
-			if (isMetaField(name)) continue;
-			const fieldDef = parentFields?.[name];
-			if (!fieldDef) continue;
-			const fieldType = namedTypeOf(fieldDef.type);
-			if (!fieldType) continue;
-			const composite = isCompositeLike(fieldType);
-			const alias = selection.alias?.value || name;
-			let node = fields[alias];
-			if (!node) {
-				node = {
-					name,
-					alias,
-					args: { ...getArgumentValues(fieldDef, selection, info.variableValues) },
-					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
-				};
-				fields[alias] = node;
-			}
-			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
-			continue;
-		}
-		if (!deep) continue;
-		if (selection.kind === Kind.FRAGMENT_SPREAD) {
-			const fragmentName = selection.name.value;
-			const fragment = info.fragments?.[fragmentName];
-			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
-			if (activeFragments.has(fragmentName)) continue;
-			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
-			if (!isCompositeLike(fragmentType)) continue;
-			activeFragments.add(fragmentName);
-			try {
-				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
-			} finally {
-				activeFragments.delete(fragmentName);
-			}
-			continue;
-		}
-		if (selection.kind === Kind.INLINE_FRAGMENT) {
-			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
-			if (!isCompositeLike(fragmentType)) continue;
-			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
-		}
+	if (!entry || typeof entry !== "object") return;
+	const row = {};
+	for (const column of primaryKey) {
+		const value = entry[column];
+		if (value === void 0 || value === null) return;
+		row[column] = value;
 	}
-	return tree;
+	return row;
 };
-/** The first key of an object, without materializing the whole key array to discard it. */
-const firstKey = (object) => {
-	for (const key in object) return key;
+/**
+* Pulls primary-key values out of a filter argument.
+*
+* Only top-level equality counts: `{ id: { eq } }` names one row, `{ id: { inArray } }`
+* names a list, and a composite key needs `eq` on every one of its columns. A boolean
+* group (`OR` / `AND` / `NOT`) or any other operator on a key column means the filter is
+* not a key lookup, and the rows are reported as not identified.
+*/
+const keysFromWhere = (where, primaryKey) => {
+	const none = {
+		rows: [],
+		complete: false
+	};
+	if (!where || typeof where !== "object" || Array.isArray(where)) return none;
+	const filters = where;
+	if (filters.OR || filters.AND || filters.NOT) return none;
+	if (primaryKey.length > 1) {
+		const row = {};
+		for (const column of primaryKey) {
+			const operators = filters[column];
+			if (!operators || typeof operators !== "object" || operators.eq === void 0) return none;
+			row[column] = operators.eq;
+		}
+		return {
+			rows: [row],
+			complete: Object.keys(filters).length === primaryKey.length
+		};
+	}
+	const column = primaryKey[0];
+	if (!column) return none;
+	const operators = filters[column];
+	if (!operators || typeof operators !== "object") return none;
+	const exact = Object.keys(filters).length === 1 && Object.keys(operators).length === 1;
+	if (operators.eq !== void 0) return {
+		rows: [{ [column]: operators.eq }],
+		complete: exact
+	};
+	if (Array.isArray(operators.inArray)) return {
+		rows: operators.inArray.map((value) => ({ [column]: value })),
+		complete: exact
+	};
+	return none;
 };
 /**
-* Reads the selection under a resolver's own field out of its `info`, as a tree of
-* {@link ResolveTree} nodes.
+* The rows a generated field's arguments are about, as primary-key values.
+*
+* The row identity of a mutation lives in a different argument for every operation —
+* `where` for update and delete, `values` for insert and upsert, a per-entry `where` inside
+* `updates` for the batch update — and each of those has both a one-row and a many-row
+* spelling. This reads whichever one applies:
 *
 * ```ts
-* const parsed = parseResolveInfo(info, { deep: true })!;
-* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+* const field = info.parentType.getFields()[info.fieldName];
+* const target = identifyRows(field, args);
+* if (target?.complete) await invalidate(target.table, target.rows);
 * ```
 *
-* Returns `undefined` when the resolver's field produced no node at all, which in practice
-* means `info` carried no field nodes.
+* Returns `undefined` for a field this library did not generate, or an object type. Check
+* `complete` before treating `rows` as the affected set — see {@link IdentifiedRows}.
 */
-const parseResolveInfo = (info, options = {}) => {
-	const fieldNodes = info.fieldNodes;
-	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
-	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
-	const typeKey = firstKey(tree);
-	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
-	const fieldKey = fields && firstKey(fields);
-	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
+const identifyRows = (field, args) => {
+	const meta = drizzleExtension(field);
+	if (!isDrizzleFieldExtension(meta)) return;
+	const { table, primaryKey, targetArg } = meta;
+	const empty = {
+		table,
+		primaryKey,
+		rows: [],
+		complete: false
+	};
+	if (!primaryKey.length || !targetArg) return empty;
+	const target = args?.[targetArg];
+	if (targetArg === "values") {
+		const entries = Array.isArray(target) ? target : target === void 0 ? [] : [target];
+		const rows = entries.map((entry) => keyFromValues(entry, primaryKey));
+		return {
+			table,
+			primaryKey,
+			rows: rows.filter((row) => !!row),
+			complete: entries.length > 0 && rows.every(Boolean)
+		};
+	}
+	if (targetArg === "updates") {
+		if (!Array.isArray(target)) return empty;
+		const perEntry = target.map((entry) => keysFromWhere(entry?.where, primaryKey));
+		return {
+			table,
+			primaryKey,
+			rows: perEntry.flatMap((entry) => entry.rows),
+			complete: target.length > 0 && perEntry.every((entry) => entry.complete)
+		};
+	}
+	return {
+		table,
+		primaryKey,
+		...keysFromWhere(target, primaryKey)
+	};
 };
 //#endregion
 //#region src/util/builders/common/relation-resolvers.ts
@@ -4177,127 +4349,6 @@ const defineRootField = (fields, kind, name, config) => {
 	fields[name] = config;
 };
 //#endregion
-//#region src/util/builders/common/select-runtime.ts
-/**
-* Runs the relational-query-builder select shared by every dialect's `generateSelect*`
-* resolver: selected columns + offset/limit + aliased orderBy/where callbacks + the eager
-* `with:` relation params, then remaps the result. `single` switches between
-* findFirst/findMany (and the single path omits `limit`). The PG fallback for tables
-* without RQB support stays in pg.ts; this covers the common RQB path for all three.
-*/
-const runRelationalSelect = async (opts) => {
-	const { queryBase, tables, tableName, table, relationMap, typeName, typeNameMapper, parsedInfo, offset, orderBy, where, single, filterCtx, pkNames, after, scope, deleted } = opts;
-	const distinct = opts.distinct?.length ? opts.distinct : void 0;
-	const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
-	let cursorEntries;
-	if (!single && (after != null || cursorSelected)) {
-		if (after != null && distinct) throw drizzleError("'after' cannot be combined with 'distinct'.", { code: "DRIZZLE_INVALID_CURSOR" });
-		const cursorObstacle = orderByCursorObstacle(orderBy);
-		if (cursorObstacle) {
-			if (after != null) throw drizzleError(cursorObstacle, { code: "DRIZZLE_INVALID_CURSOR" });
-		} else if (!pkNames?.length) {
-			if (after != null) throw drizzleError(`Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`, { code: "DRIZZLE_INVALID_CURSOR" });
-		} else cursorEntries = cursorOrderingEntries(orderBy, pkNames);
-	}
-	const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
-	const needsDefaultOrder = single || offset != null || opts.limit != null;
-	let distinctKeys;
-	if (distinct) {
-		distinctKeys = await selectDistinctKeys({
-			db: opts.db,
-			table,
-			tableName,
-			distinct,
-			pkNames: pkNames ?? [],
-			where: withScope(scope, tableName, table, where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0, deleted),
-			orderBy,
-			limit: single ? 1 : opts.limit,
-			offset
-		});
-		if (!distinctKeys.length) return single ? void 0 : [];
-	}
-	const params = {
-		columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table, {
-			tableName,
-			relationMap,
-			tables,
-			allRelations: filterCtx?.relationMap
-		}),
-		offset: distinctKeys ? void 0 : offset,
-		orderBy: distinctKeys ? (aliasedTable) => [...orderBy ? extractOrderBy(aliasedTable, orderBy, relationFilterCtx(filterCtx, tableName), where) : [], ...primaryKeyOrderExprs(aliasedTable, pkNames)] : cursorEntries ? (aliasedTable) => cursorOrderExprs(aliasedTable, cursorEntries) : orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy, relationFilterCtx(filterCtx, tableName), where) : needsDefaultOrder && pkNames?.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0,
-		where: distinctKeys ? { RAW: (aliasedTable) => primaryKeyRestriction(aliasedTable, pkNames, distinctKeys) } : where || cursorValues || scope?.has(tableName, deleted) ? { RAW: (aliasedTable) => withScope(scope, tableName, aliasedTable, and(where ? extractFilters(aliasedTable, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0, cursorValues ? buildCursorCondition(aliasedTable, cursorEntries, cursorValues, opts.nullOrdering ?? "nulls-smallest") : void 0), deleted) } : void 0,
-		with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, {
-			typeNameMapper,
-			filterCtx,
-			limits: opts.limits,
-			scope,
-			defaultOrderBy: opts.defaultOrderBy,
-			resolveName: opts.resolveName
-		}) : void 0
-	};
-	if (single) {
-		const result = await queryBase.findFirst(params);
-		return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
-	}
-	if (cursorEntries && cursorSelected) for (const [column] of cursorEntries) params.columns[column] = true;
-	params.limit = distinctKeys ? void 0 : opts.limit;
-	const result = await queryBase.findMany(params);
-	if (cursorEntries && cursorSelected) attachRowCursors(result, cursorEntries);
-	return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
-};
-/**
-* After a mutation, re-fetch the mutated rows through the relational query builder so the
-* selected relations are eagerly loaded in a single query, then merge those relations onto
-* the `.returning()` rows — making the per-field BatchLoader fallback unnecessary.
-*
-* `withParams` is the pre-computed relation selection (from extractRelationsParams); the
-* caller only invokes this when relations are actually selected, so it also gates whether
-* the PK was forced into RETURNING.
-*
-* Falls back to the original `.returning()` rows (relations then resolve via the
-* field-level BatchLoader) when the table has no RQB support, no primary key columns can be
-* determined, or the re-fetch fails. Supports single- and multi-column primary keys.
-*/
-const eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withParams) => {
-	if (!rows.length || !pkNames.length || !withParams || !Object.keys(withParams).length) return rows;
-	const queryBase = db.query?.[tableName];
-	if (!queryBase) return rows;
-	const keyableRows = rows.filter((row) => pkNames.every((n) => row[n] != null));
-	if (!keyableRows.length) return rows;
-	const pkColumns = {};
-	for (const pk of pkNames) pkColumns[pk] = true;
-	const relationNames = Object.keys(withParams);
-	const keyOf = (row) => JSON.stringify(pkNames.map((n) => typeof row[n] === "bigint" ? row[n].toString() : row[n]));
-	let whereRaw;
-	if (pkNames.length === 1) {
-		const pkName = pkNames[0];
-		const ids = keyableRows.map((r) => r[pkName]);
-		whereRaw = (aliased) => inArray(aliased[pkName], ids);
-	} else whereRaw = (aliased) => {
-		const lhs = sql.join(pkNames.map((n) => sql`${aliased[n]}`), sql`, `);
-		const tuples = sql.join(keyableRows.map((row) => sql`(${sql.join(pkNames.map((n) => sql`${row[n]}`), sql`, `)})`), sql`, `);
-		return sql`(${lhs}) in (${tuples})`;
-	};
-	let enriched;
-	try {
-		enriched = await queryBase.findMany({
-			columns: pkColumns,
-			where: { RAW: whereRaw },
-			with: withParams
-		});
-	} catch (err) {
-		console.warn(`[drizzle-graphql] eager-loading relations for a "${tableName}" mutation failed; falling back to lazy resolution.`, err);
-		return rows;
-	}
-	const byKey = new Map(enriched.map((e) => [keyOf(e), e]));
-	for (const row of rows) {
-		const match = byKey.get(keyOf(row));
-		if (!match) continue;
-		for (const rel of relationNames) row[rel] = match[rel];
-	}
-	return rows;
-};
-//#endregion
 //#region src/util/builders/common/table-inputs.ts
 const orderMap = /* @__PURE__ */ new WeakMap();
 const generateTableOrderCached = (table, innerOrder) => {
@@ -6583,7 +6634,14 @@ const generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, si
 		if (!Object.keys(input).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
 		await before();
 		const relationCtx = relationFilterCtx(filterCtx, tableName);
-		const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0);
+		const filters = scopedWhere({
+			scope,
+			tableName,
+			table,
+			where,
+			relationCtx,
+			required: single || requireWhere
+		});
 		if (single) await assertSingleMatch(executor, table, filters);
 		let query = executor.update(table).set(input);
 		if (filters) query = query.where(filters);
@@ -6665,7 +6723,15 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 			const hard = canHardDelete && args.hard === true;
 			const scope = policies?.scope?.(context);
 			const relationCtx = relationFilterCtx(filterCtx, tableName);
-			const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0, restore ? "ONLY" : hard ? "INCLUDE" : void 0);
+			const filters = scopedWhere({
+				scope,
+				tableName,
+				table,
+				where,
+				relationCtx,
+				required: single || requireWhere,
+				deleted: restore ? "ONLY" : hard ? "INCLUDE" : void 0
+			});
 			if (single) await assertSingleMatch(executor, table, filters);
 			let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
 			if (filters) query = query.where(filters);
@@ -6893,8 +6959,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table), contextColumns, context);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -6903,7 +6968,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -6924,7 +6988,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					context
 				}) : await runInsert(executor, input);
 				await after(result);
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
@@ -6948,8 +7012,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntry ? {} : applyContextValues(remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table), contextColumns, context);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -6958,7 +7021,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -6983,7 +7045,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					if (!conflictDoNothing) throw drizzleError("The insert returned no row.", { code: "DRIZZLE_NO_ROW_RETURNED" });
 					return;
 				}
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
 			}
 		});
@@ -7021,8 +7083,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -7031,7 +7092,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7068,7 +7128,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				}) : await runUpsert(executor, input);
 				await after(result);
 				if (single && !result[0]) return;
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
@@ -7092,8 +7152,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const { where, set } = args;
 				const scope = policies?.scope?.(context);
 				await before();
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -7102,7 +7161,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7112,7 +7170,14 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const input = stripContextValues(remapUpdateInput(entry ? entry.columns : set, table, tableName), policies?.contextValues?.(tableName));
 				if (!Object.keys(input).length && !nestedOps) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
 				const relationCtx = relationFilterCtx(filterCtx, tableName);
-				const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0);
+				const filters = scopedWhere({
+					scope,
+					tableName,
+					table,
+					where,
+					relationCtx,
+					required: single || requireWhere
+				});
 				if (single) await assertSingleMatch(executor, table, filters);
 				const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
 				const runUpdate = async (target, values) => {
@@ -7134,7 +7199,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				await after(result);
 				if (single && result.length > 1) throw drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
 				if (single && !result[0]) return;
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
@@ -7176,7 +7241,15 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const columns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[applyObjectTypeName(typeName, tableName, resolveName)], table, selectionCtx);
 				const relationCtx = relationFilterCtx(filterCtx, tableName);
-				const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0, restore ? "ONLY" : hard ? "INCLUDE" : void 0);
+				const filters = scopedWhere({
+					scope,
+					tableName,
+					table,
+					where,
+					relationCtx,
+					required: single || requireWhere,
+					deleted: restore ? "ONLY" : hard ? "INCLUDE" : void 0
+				});
 				if (single) await assertSingleMatch(executor, table, filters);
 				let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
 				if (filters) query = query.where(filters);
@@ -7505,8 +7578,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 				await before();
 				const scope = policies?.scope?.(context);
 				const contextColumns = policies?.contextValues?.(tableName);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -7515,7 +7587,6 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7544,7 +7615,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 				});
 				const flatRows = perEntry.flat();
 				await after(flatRows);
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+				const enriched = await withEagerRelations(executor, tableName, flatRows, pkNames, withParams, hasRelations);
 				const output = [];
 				let offset = 0;
 				for (const rows of perEntry) {