@vantreeseba/drizzle-graphql 11.0.2 → 12.0.1

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 {
@@ -3768,196 +4088,48 @@ const identifyRows = (field, args) => {
 	};
 };
 //#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;
+//#region src/util/builders/common/relation-resolvers.ts
 /**
-* 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.
+* Fetches a to-many relation with per-parent limit/offset for ALL parents in a
+* single query, using a window function (ROW_NUMBER() OVER (PARTITION BY fk ...)).
+*
+* This replaces the previous per-parent fallback that issued one query per parent
+* (true N+1) whenever pagination args were present. Each parent gets its own
+* limit/offset window while the database is hit exactly once for the whole batch.
+*
+* Window functions require PostgreSQL, MySQL >= 8.0, or SQLite >= 3.25.
+* Returns raw rows (NOT remapped); the caller groups + remaps them.
 */
-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;
+const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs) => {
+	const cols = columns ?? getColumns(targetTable);
+	const orderExprs = [...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx, whereArgs) : [], ...primaryKeyOrderExprs(targetTable, pkNames)];
+	const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
+	const RN = "__drizzle_graphql_rn";
+	const rowNumber = sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
+	const sub = db.select({
+		...cols,
+		[RN]: rowNumber
+	}).from(targetTable).where(whereCondition).as("__paginated");
+	const lower = offset ?? 0;
+	const windowConds = [gt(sub[RN], lower)];
+	if (limit != null) windowConds.push(lte(sub[RN], lower + limit));
+	const rows = await db.select().from(sub).where(and(...windowConds)).orderBy(sub[RN]);
+	for (const row of rows) delete row[RN];
+	return rows;
 };
 /**
-* 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/common/relation-resolvers.ts
-/**
-* Fetches a to-many relation with per-parent limit/offset for ALL parents in a
-* single query, using a window function (ROW_NUMBER() OVER (PARTITION BY fk ...)).
-*
-* This replaces the previous per-parent fallback that issued one query per parent
-* (true N+1) whenever pagination args were present. Each parent gets its own
-* limit/offset window while the database is hit exactly once for the whole batch.
-*
-* Window functions require PostgreSQL, MySQL >= 8.0, or SQLite >= 3.25.
-* Returns raw rows (NOT remapped); the caller groups + remaps them.
-*/
-const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs) => {
-	const cols = columns ?? getColumns(targetTable);
-	const orderExprs = [...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx, whereArgs) : [], ...primaryKeyOrderExprs(targetTable, pkNames)];
-	const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
-	const RN = "__drizzle_graphql_rn";
-	const rowNumber = sql`row_number() over (partition by ${foreignCol}${orderClause})`.as(RN);
-	const sub = db.select({
-		...cols,
-		[RN]: rowNumber
-	}).from(targetTable).where(whereCondition).as("__paginated");
-	const lower = offset ?? 0;
-	const windowConds = [gt(sub[RN], lower)];
-	if (limit != null) windowConds.push(lte(sub[RN], lower + limit));
-	const rows = await db.select().from(sub).where(and(...windowConds)).orderBy(sub[RN]);
-	for (const row of rows) delete row[RN];
-	return rows;
-};
-/**
-* Creates a RelationResolverFactory that generates field-level resolvers for each relation.
-* Each resolver:
-*   1. Returns pre-fetched data if the parent resolver already included it (eager path, zero cost).
-*   2. When limit/offset args are present, falls back to a direct per-item query.
-*   3. Otherwise batches all sibling resolver calls within the same GraphQL execution tick
-*      into a single IN-clause query, eliminating N+1 database round-trips.
-*
-* `nullOrdering` is the dialect's native `ORDER BY` placement for `NULL` — the keyset
-* predicate behind a relation's `after` argument has to match it, or rows with a `NULL` in an
-* ordered column would be skipped instead of paged through. It has no sensible default, so
-* each dialect builder states it: `'nulls-largest'` for PostgreSQL, `'nulls-smallest'` for
-* MySQL and SQLite.
+* Creates a RelationResolverFactory that generates field-level resolvers for each relation.
+* Each resolver:
+*   1. Returns pre-fetched data if the parent resolver already included it (eager path, zero cost).
+*   2. When limit/offset args are present, falls back to a direct per-item query.
+*   3. Otherwise batches all sibling resolver calls within the same GraphQL execution tick
+*      into a single IN-clause query, eliminating N+1 database round-trips.
+*
+* `nullOrdering` is the dialect's native `ORDER BY` placement for `NULL` — the keyset
+* predicate behind a relation's `after` argument has to match it, or rows with a `NULL` in an
+* ordered column would be skipped instead of paged through. It has no sensible default, so
+* each dialect builder states it: `'nulls-largest'` for PostgreSQL, `'nulls-smallest'` for
+* MySQL and SQLite.
 */
 const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limits, policies) => ({ tableName, relationName, relEntry, isOne }) => {
 	const parentTable = tables[tableName];
@@ -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) => {
@@ -6455,6 +6506,72 @@ const createSchemaBuilder = (adapter) => {
 			havingInput
 		};
 	};
+	/**
+	* The per-table loop, run once for every table the build covers.
+	*
+	* The dialect's callback receives the values the loop has already worked out — the feature
+	* flags, the extension factory, the field names, the table's generated types and its
+	* soft-delete config — and answers with the mutations it generated. Registering them, and
+	* registering the inputs and outputs those mutations reference, happens here: both sides
+	* did it identically, down to the `description` strings on the count mutations, so a gate
+	* changed on one side and forgotten on the other used to be a silent dialect divergence.
+	*
+	* What stays in the dialect is what genuinely differs — which generators run, what each
+	* mutation returns, and (on MySQL) that a write cannot report the rows it touched.
+	*/
+	const forEachTable = (ctx, perTable) => {
+		const { schema, featureOf, softDeleteOf, typeNameMapper, gqlSchemaTypes, mutations, inputs, outputs } = ctx;
+		const { prefixes, suffixes } = ctx.options;
+		for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
+			const tableFeatures = featureOf(tableName);
+			const drizzleMeta = tableFieldExtensions(tableName, primaryKeyPropNames(schema[tableName]));
+			const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+			const softDeleteInfo = softDeleteOf?.(tableName);
+			const readTypes = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
+			const built = perTable({
+				tableName,
+				table: schema[tableName],
+				tableFeatures,
+				drizzleMeta,
+				names,
+				types: tableTypes,
+				softDeleteInfo
+			});
+			for (const { generated, type, meta, description } of built.mutations) if (generated) defineRootField(mutations, "mutation", generated.name, {
+				type,
+				args: generated.args,
+				resolve: generated.resolver,
+				...meta ? { extensions: { drizzle: drizzleMeta({
+					kind: "mutation",
+					...meta
+				}) } } : {},
+				...description ? { description } : {}
+			});
+			const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
+			[
+				...tableFeatures.insert || built.onConflictInput ? [insertInput] : [],
+				...built.onConflictInput ? [built.onConflictInput] : [],
+				...tableFeatures.update ? [updateInput] : [],
+				...built.updateManyInput ? [built.updateManyInput] : [],
+				tableFilters,
+				tableOrder
+			].forEach((e) => {
+				inputs[e.name] = e;
+			});
+			const { selectSingleOutput } = tableTypes.outputs;
+			outputs[selectSingleOutput.name] = selectSingleOutput;
+			if (adapter.returnsRows) {
+				const { singleTableItemOutput } = tableTypes.outputs;
+				outputs[singleTableItemOutput.name] = singleTableItemOutput;
+			}
+			const { aggregateType, groupByType, havingInput } = readTypes;
+			if (aggregateType) outputs[aggregateType.name] = aggregateType;
+			if (groupByType && havingInput) {
+				outputs[groupByType.name] = groupByType;
+				inputs[havingInput.name] = havingInput;
+			}
+		}
+	};
 	/** The relation field resolvers and the transaction roster, once every root field exists. */
 	const finalizeBuild = (ctx) => {
 		if (ctx.mutationTxCtx) for (const name of Object.keys(ctx.mutations)) ctx.mutationTxCtx.fieldNames.add(name);
@@ -6485,7 +6602,7 @@ const createSchemaBuilder = (adapter) => {
 		primaryKeyPropNames,
 		uniqueColumnSets,
 		prepareBuild,
-		addReadFields,
+		forEachTable,
 		finalizeBuild
 	};
 };
@@ -6583,7 +6700,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 +6789,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);
@@ -6679,7 +6811,7 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 const getTableConfig$5 = memoizeTableConfig(getTableConfig);
 /** Primary-key property names for a MySQL table, including table-level composite keys. */
 const mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$5);
-const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder({
+const { prepareBuild, forEachTable, finalizeBuild } = createSchemaBuilder({
 	tableClass: MySqlTable,
 	getTableConfig: getTableConfig$5,
 	primaryKeyPropNames: mysqlPrimaryKeyPropNames,
@@ -6690,9 +6822,9 @@ const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder({
 	}
 });
 const generateSchemaData$2 = (db, schema, relations, options) => {
-	const { prefixes, suffixes, typeNameMapper } = options;
+	const { prefixes } = options;
 	const ctx = prepareBuild(db, schema, relations, options);
-	const { featureOf, anyTable, filterCtx, policies, softDeleteOf, cacheCtx, mutationTxCtx, gqlSchemaTypes, mutations, inputs, outputs } = ctx;
+	const { anyTable, filterCtx, policies, cacheCtx, mutationTxCtx, outputs } = ctx;
 	const mutationReturnType = new GraphQLObjectType({
 		name: cacheCtx.typeName({
 			kind: "shared",
@@ -6706,15 +6838,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 		"update",
 		"delete"
 	].some((feature) => anyTable(feature))) outputs["MutationReturn"] = mutationReturnType;
-	for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-		const tableFeatures = featureOf(tableName);
-		const drizzleMeta = tableFieldExtensions(tableName, mysqlPrimaryKeyPropNames(schema[tableName]));
-		const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-		const { selectSingleOutput } = tableTypes.outputs;
-		const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+	forEachTable(ctx, ({ tableName, tableFeatures, names, types, softDeleteInfo }) => {
+		const { insertInput, updateInput, tableFilters } = types.inputs;
 		const { typeName, createArrayFieldName, createSingleFieldName, upsertArrayFieldName, upsertSingleFieldName, updateFieldName, updateManyFieldName, updateSingleFieldName, updateCountFieldName, deleteFieldName, deleteSingleFieldName, restoreFieldName, restoreSingleFieldName, deleteCountFieldName } = names;
-		const softDeleteInfo = softDeleteOf?.(tableName);
-		const { aggregateType, groupByType, havingInput } = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
 		const insertArrGenerated = tableFeatures.insert ? generateInsertArray(db, tableName, schema[tableName], insertInput, createArrayFieldName, mutationTxCtx, policies) : void 0;
 		const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(db, tableName, schema[tableName], insertInput, createSingleFieldName, mutationTxCtx, policies) : void 0;
 		const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
@@ -6767,103 +6893,85 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			txCtx: mutationTxCtx
 		}) : void 0;
 		const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
-		const generatedMutations = [
-			[insertArrGenerated, {
-				operation: "insert",
-				single: false,
-				targetArg: "values"
-			}],
-			[insertSingleGenerated, {
-				operation: "insert",
-				single: true,
-				targetArg: "values"
-			}],
-			[upsertArrGenerated, {
-				operation: "upsert",
-				single: false,
-				targetArg: "values"
-			}],
-			[upsertSingleGenerated, {
-				operation: "upsert",
-				single: true,
-				targetArg: "values"
-			}],
-			[updateGenerated, {
-				operation: "update",
-				single: false,
-				targetArg: "where"
-			}],
-			[updateManyGenerated, {
-				operation: "updateMany",
-				single: false,
-				targetArg: "updates"
-			}],
-			[updateSingleGenerated, {
-				operation: "update",
-				single: true,
-				targetArg: "where"
-			}],
-			[deleteGenerated, {
-				operation: "delete",
-				single: false,
-				targetArg: "where",
-				...hardDeleteMeta
-			}],
-			[deleteSingleGenerated, {
-				operation: "delete",
-				single: true,
-				targetArg: "where",
-				...hardDeleteMeta
-			}],
-			[restoreGenerated, {
-				operation: "restore",
-				single: false,
-				targetArg: "where"
-			}],
-			[restoreSingleGenerated, {
-				operation: "restore",
-				single: true,
-				targetArg: "where"
-			}]
-		];
-		for (const [generated, meta] of generatedMutations) if (generated) defineRootField(mutations, "mutation", generated.name, {
+		const withMeta = (generated, meta) => ({
+			generated,
 			type: mutationReturnType,
-			args: generated.args,
-			resolve: generated.resolver,
-			extensions: { drizzle: drizzleMeta({
-				kind: "mutation",
-				...meta
-			}) }
-		});
-		if (updateCountGenerated) defineRootField(mutations, "mutation", updateCountGenerated.name, {
-			type: new GraphQLNonNull(GraphQLInt),
-			args: updateCountGenerated.args,
-			resolve: updateCountGenerated.resolver,
-			description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+			meta
 		});
-		if (deleteCountGenerated) defineRootField(mutations, "mutation", deleteCountGenerated.name, {
-			type: new GraphQLNonNull(GraphQLInt),
-			args: deleteCountGenerated.args,
-			resolve: deleteCountGenerated.resolver,
-			description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
-		});
-		[
-			...tableFeatures.insert || onConflictInput ? [insertInput] : [],
-			...onConflictInput ? [onConflictInput] : [],
-			...tableFeatures.update ? [updateInput] : [],
-			...updateManyInput ? [updateManyInput] : [],
-			tableFilters,
-			tableOrder
-		].forEach((e) => {
-			inputs[e.name] = e;
-		});
-		outputs[selectSingleOutput.name] = selectSingleOutput;
-		if (aggregateType) outputs[aggregateType.name] = aggregateType;
-		if (groupByType && havingInput) {
-			outputs[groupByType.name] = groupByType;
-			inputs[havingInput.name] = havingInput;
-		}
-	}
+		return {
+			mutations: [
+				withMeta(insertArrGenerated, {
+					operation: "insert",
+					single: false,
+					targetArg: "values"
+				}),
+				withMeta(insertSingleGenerated, {
+					operation: "insert",
+					single: true,
+					targetArg: "values"
+				}),
+				withMeta(upsertArrGenerated, {
+					operation: "upsert",
+					single: false,
+					targetArg: "values"
+				}),
+				withMeta(upsertSingleGenerated, {
+					operation: "upsert",
+					single: true,
+					targetArg: "values"
+				}),
+				withMeta(updateGenerated, {
+					operation: "update",
+					single: false,
+					targetArg: "where"
+				}),
+				withMeta(updateManyGenerated, {
+					operation: "updateMany",
+					single: false,
+					targetArg: "updates"
+				}),
+				withMeta(updateSingleGenerated, {
+					operation: "update",
+					single: true,
+					targetArg: "where"
+				}),
+				withMeta(deleteGenerated, {
+					operation: "delete",
+					single: false,
+					targetArg: "where",
+					...hardDeleteMeta
+				}),
+				withMeta(deleteSingleGenerated, {
+					operation: "delete",
+					single: true,
+					targetArg: "where",
+					...hardDeleteMeta
+				}),
+				withMeta(restoreGenerated, {
+					operation: "restore",
+					single: false,
+					targetArg: "where"
+				}),
+				withMeta(restoreSingleGenerated, {
+					operation: "restore",
+					single: true,
+					targetArg: "where"
+				}),
+				{
+					generated: updateCountGenerated,
+					type: new GraphQLNonNull(GraphQLInt),
+					description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+				},
+				{
+					generated: deleteCountGenerated,
+					type: new GraphQLNonNull(GraphQLInt),
+					description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+				}
+			],
+			onConflictInput,
+			updateManyInput
+		};
+	});
 	return finalizeBuild(ctx);
 };
 //#endregion
@@ -6873,28 +6981,37 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 * result, so the generator call sites read exactly as they did when the functions were local.
 */
 const buildWriteResolvers = (primaryKeyPropNames) => {
-	const generateInsertArray = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies, resolveName) => {
-		const queryArgs = { values: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(baseType))) } };
+	/**
+	* `insert<Table>` / `insert<Table>Single` — one generator for both shapes, the way
+	* {@link generateUpsert} handles its pair. `single` decides the argument type, whether the
+	* result is remapped as a row or a list, and whether an empty return is an error; the write
+	* itself is the same multi-row statement either way, with the single variant supplying a
+	* one-element list.
+	*/
+	const generateInsert = (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, baseType, fieldName, typeName, single, conflictDoNothing = false } = opts;
+		const queryArgs = { values: { type: single ? new GraphQLNonNull(baseType) : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(baseType))) } };
 		const pkNames = primaryKeyPropNames(table);
 		return writeResolver({
 			db,
 			tableName,
 			operation: "insert",
-			single: false,
+			single,
 			fieldName,
 			txCtx,
 			policies,
 			args: queryArgs,
 			run: async ({ executor, args, context, info, before, after }) => {
-				if (!args.values.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
+				const supplied = single ? [args.values] : args.values;
+				if (!supplied.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
 				await before();
-				const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+				const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
 				const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
 				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 input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -6903,7 +7020,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -6924,67 +7040,12 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					context
 				}) : await runInsert(executor, input);
 				await after(result);
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-				return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
-			}
-		});
-	};
-	const generateInsertSingle = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies, resolveName) => {
-		const queryArgs = { values: { type: new GraphQLNonNull(baseType) } };
-		const pkNames = primaryKeyPropNames(table);
-		return writeResolver({
-			db,
-			tableName,
-			operation: "insert",
-			single: true,
-			fieldName,
-			txCtx,
-			policies,
-			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
-				await before();
-				const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
-				const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
-				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({
-					relationMap,
-					tables,
-					tableName,
-					typeName,
-					typeNameMapper,
-					resolveName,
-					table,
-					pkNames,
-					parsedInfo,
-					limits,
-					scope,
-					defaultOrderBy: policies?.defaultOrderBy
-				});
-				const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
-				const runInsert = async (target, values) => {
-					let query = target.insert(table).values(values).returning(returning);
-					if (conflictDoNothing) query = query.onConflictDoNothing();
-					return await query;
-				};
-				const result = nestedEntry ? await writeWithNestedOps({
-					executor,
-					runtime: nested,
-					tableName,
-					entries: [nestedEntry],
-					remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-					write: runInsert,
-					context
-				}) : await runInsert(executor, input);
-				await after(result);
-				if (!result[0]) {
+				if (single && !result[0]) {
 					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;
-				return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
+				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
 	};
@@ -6994,7 +7055,9 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 	*
 	* Shares the insert input: an upsert supplies a whole row, same as a create.
 	*/
-	const generateUpsert = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
+	const generateUpsert = (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, baseType, onConflictType, uniqueSets, fieldName, typeName, single } = opts;
 		const queryArgs = {
 			values: { type: single ? new GraphQLNonNull(baseType) : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(baseType))) },
 			onConflict: {
@@ -7021,8 +7084,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 +7093,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7068,12 +7129,14 @@ 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);
 			}
 		});
 	};
-	const generateUpdate = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
+	const generateUpdate = (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, setArgs, filterArgs, fieldName, typeName, single, requireWhere } = opts;
 		const queryArgs = {
 			set: { type: new GraphQLNonNull(setArgs) },
 			where: { type: single || requireWhere ? new GraphQLNonNull(filterArgs) : filterArgs }
@@ -7092,8 +7155,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 +7164,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7112,7 +7173,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 +7202,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);
 			}
 		});
@@ -7151,7 +7219,10 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 	* `DELETE` — emptying the trash, reclaiming a unique key. It reads at `INCLUDE`, since the
 	* rows it mostly exists to remove are the ones already marked; a `scope` still confines it.
 	*/
-	const generateDelete = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies, restore = false, resolveName) => {
+	const generateDelete = (build, opts) => {
+		const { db, filterCtx, txCtx, policies, resolveName } = build;
+		const { tableName, table, filterArgs, fieldName, typeName, single, requireWhere, selectionCtx } = opts;
+		const restore = opts.restore ?? false;
 		const softDelete = policies?.softDelete?.(tableName);
 		const operation = restore ? "restore" : "delete";
 		const canHardDelete = !restore && softDelete?.hardDelete === true;
@@ -7176,7 +7247,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);
@@ -7190,8 +7269,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 		});
 	};
 	return {
-		generateInsertArray,
-		generateInsertSingle,
+		generateInsert,
 		generateUpsert,
 		generateUpdate,
 		generateDelete
@@ -7208,23 +7286,46 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 const createSchemaDataGenerator = (adapter) => {
 	const primaryKeyPropNames = adapter.primaryKeyPropNames;
 	const uniqueColumnSets = (table) => getUniqueColumnSets(table, adapter.getTableConfig);
-	const { generateInsertArray, generateInsertSingle, generateUpsert, generateUpdate, generateDelete } = buildWriteResolvers(primaryKeyPropNames);
-	const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder(adapter);
+	const { generateInsert, generateUpsert, generateUpdate, generateDelete } = buildWriteResolvers(primaryKeyPropNames);
+	const { prepareBuild, forEachTable, finalizeBuild } = createSchemaBuilder(adapter);
 	return (db, schema, relations, options) => {
-		const { prefixes, suffixes, conflictDoNothing, typeNameMapper, limits } = options;
+		const { prefixes, conflictDoNothing, typeNameMapper, limits } = options;
 		const ctx = prepareBuild(db, schema, relations, options);
-		const { tables, featureOf, eagerRelations, filterCtx, policies, softDeleteOf, namedRelations, cacheCtx, nestedRuntime, mutationTxCtx, gqlSchemaTypes, mutations, inputs, outputs } = ctx;
-		for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-			const tableFeatures = featureOf(tableName);
-			const drizzleMeta = tableFieldExtensions(tableName, primaryKeyPropNames(schema[tableName]));
-			const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-			const { selectSingleOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
-			const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+		const { tables, eagerRelations, filterCtx, policies, namedRelations, cacheCtx, nestedRuntime, mutationTxCtx } = ctx;
+		const writeBuild = {
+			db,
+			tables,
+			relationMap: eagerRelations,
+			typeNameMapper,
+			filterCtx,
+			txCtx: mutationTxCtx,
+			nested: nestedRuntime,
+			limits,
+			policies,
+			resolveName: cacheCtx.typeName
+		};
+		forEachTable(ctx, ({ tableName, tableFeatures, names, types, softDeleteInfo }) => {
+			const { insertInput, updateInput, tableFilters } = types.inputs;
+			const { singleTableItemOutput, arrTableItemOutput } = types.outputs;
 			const { typeName, createArrayFieldName, createSingleFieldName, upsertArrayFieldName, upsertSingleFieldName, updateFieldName, updateManyFieldName, updateSingleFieldName, updateCountFieldName, deleteFieldName, deleteSingleFieldName, restoreFieldName, restoreSingleFieldName, deleteCountFieldName } = names;
-			const softDeleteInfo = softDeleteOf?.(tableName);
-			const { aggregateType, groupByType, havingInput } = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
-			const insertArrGenerated = tableFeatures.insert ? generateInsertArray(db, tableName, schema[tableName], tables, eagerRelations, insertInput, createArrayFieldName, typeName, typeNameMapper, conflictDoNothing, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(db, tableName, schema[tableName], tables, eagerRelations, insertInput, createSingleFieldName, typeName, typeNameMapper, conflictDoNothing, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
+			const insertArrGenerated = tableFeatures.insert ? generateInsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				fieldName: createArrayFieldName,
+				typeName,
+				single: false,
+				conflictDoNothing
+			}) : void 0;
+			const insertSingleGenerated = tableFeatures.insert ? generateInsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				fieldName: createSingleFieldName,
+				typeName,
+				single: true,
+				conflictDoNothing
+			}) : void 0;
 			const uniqueSets = tableFeatures.upsert ? uniqueColumnSets(schema[tableName]) : [];
 			const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
 				table: schema[tableName],
@@ -7235,10 +7336,46 @@ const createSchemaDataGenerator = (adapter) => {
 				withTarget: true,
 				cacheCtx
 			}) : void 0;
-			const upsertArrGenerated = onConflictInput ? generateUpsert(db, tableName, schema[tableName], tables, eagerRelations, insertInput, onConflictInput, uniqueSets, upsertArrayFieldName, typeName, false, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const upsertSingleGenerated = onConflictInput ? generateUpsert(db, tableName, schema[tableName], tables, eagerRelations, insertInput, onConflictInput, uniqueSets, upsertSingleFieldName, typeName, true, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const updateGenerated = tableFeatures.update ? generateUpdate(db, tableName, schema[tableName], tables, eagerRelations, updateInput, tableFilters, updateFieldName, typeName, false, tableFeatures.requireWhere, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const updateSingleGenerated = tableFeatures.update ? generateUpdate(db, tableName, schema[tableName], tables, eagerRelations, updateInput, tableFilters, updateSingleFieldName, typeName, true, tableFeatures.requireWhere, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
+			const upsertArrGenerated = onConflictInput ? generateUpsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				onConflictType: onConflictInput,
+				uniqueSets,
+				fieldName: upsertArrayFieldName,
+				typeName,
+				single: false
+			}) : void 0;
+			const upsertSingleGenerated = onConflictInput ? generateUpsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				onConflictType: onConflictInput,
+				uniqueSets,
+				fieldName: upsertSingleFieldName,
+				typeName,
+				single: true
+			}) : void 0;
+			const updateGenerated = tableFeatures.update ? generateUpdate(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				setArgs: updateInput,
+				filterArgs: tableFilters,
+				fieldName: updateFieldName,
+				typeName,
+				single: false,
+				requireWhere: tableFeatures.requireWhere
+			}) : void 0;
+			const updateSingleGenerated = tableFeatures.update ? generateUpdate(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				setArgs: updateInput,
+				filterArgs: tableFilters,
+				fieldName: updateSingleFieldName,
+				typeName,
+				single: true,
+				requireWhere: tableFeatures.requireWhere
+			}) : void 0;
 			const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({
 				tableName,
 				typeName,
@@ -7247,27 +7384,73 @@ const createSchemaDataGenerator = (adapter) => {
 				tableFilters,
 				cacheCtx
 			}) : void 0;
-			const updateManyGenerated = updateManyInput ? adapter.generateUpdateMany(db, tableName, schema[tableName], tables, eagerRelations, updateManyInput, updateManyFieldName, typeName, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const deleteGenerated = tableFeatures.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteFieldName, typeName, false, tableFeatures.requireWhere, filterCtx, {
+			const updateManyGenerated = updateManyInput ? adapter.generateUpdateMany(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				updateManyInput,
+				fieldName: updateManyFieldName,
+				typeName
+			}) : void 0;
+			const deleteGenerated = tableFeatures.delete ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, false, cacheCtx.typeName) : void 0;
-			const deleteSingleGenerated = tableFeatures.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteSingleFieldName, typeName, true, tableFeatures.requireWhere, filterCtx, {
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: deleteFieldName,
+				typeName,
+				single: false,
+				requireWhere: tableFeatures.requireWhere,
+				restore: false,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
+			const deleteSingleGenerated = tableFeatures.delete ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, false, cacheCtx.typeName) : void 0;
-			const restoreGenerated = softDeleteInfo ? generateDelete(db, tableName, schema[tableName], tableFilters, restoreFieldName, typeName, false, tableFeatures.requireWhere, filterCtx, {
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: deleteSingleFieldName,
+				typeName,
+				single: true,
+				requireWhere: tableFeatures.requireWhere,
+				restore: false,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
+			const restoreGenerated = softDeleteInfo ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, true, cacheCtx.typeName) : void 0;
-			const restoreSingleGenerated = softDeleteInfo ? generateDelete(db, tableName, schema[tableName], tableFilters, restoreSingleFieldName, typeName, true, tableFeatures.requireWhere, filterCtx, {
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: restoreFieldName,
+				typeName,
+				single: false,
+				requireWhere: tableFeatures.requireWhere,
+				restore: true,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
+			const restoreSingleGenerated = softDeleteInfo ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, true, cacheCtx.typeName) : void 0;
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: restoreSingleFieldName,
+				typeName,
+				single: true,
+				requireWhere: tableFeatures.requireWhere,
+				restore: true,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
 			const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
 				db,
 				tableName,
@@ -7292,160 +7475,126 @@ const createSchemaDataGenerator = (adapter) => {
 				filterCtx,
 				txCtx: mutationTxCtx
 			}) : void 0;
-			if (insertArrGenerated) defineRootField(mutations, "mutation", insertArrGenerated.name, {
-				type: arrTableItemOutput,
-				args: insertArrGenerated.args,
-				resolve: insertArrGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "insert",
-					single: false,
-					targetArg: "values"
-				}) }
-			});
-			if (insertSingleGenerated) defineRootField(mutations, "mutation", insertSingleGenerated.name, {
-				type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull(singleTableItemOutput),
-				args: insertSingleGenerated.args,
-				resolve: insertSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "insert",
-					single: true,
-					targetArg: "values"
-				}) }
-			});
-			if (upsertArrGenerated) defineRootField(mutations, "mutation", upsertArrGenerated.name, {
-				type: arrTableItemOutput,
-				args: upsertArrGenerated.args,
-				resolve: upsertArrGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "upsert",
-					single: false,
-					targetArg: "values"
-				}) }
-			});
-			if (upsertSingleGenerated) defineRootField(mutations, "mutation", upsertSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: upsertSingleGenerated.args,
-				resolve: upsertSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "upsert",
-					single: true,
-					targetArg: "values"
-				}) }
-			});
-			if (updateGenerated) defineRootField(mutations, "mutation", updateGenerated.name, {
-				type: arrTableItemOutput,
-				args: updateGenerated.args,
-				resolve: updateGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "update",
-					single: false,
-					targetArg: "where"
-				}) }
-			});
-			if (updateManyGenerated) defineRootField(mutations, "mutation", updateManyGenerated.name, {
-				type: new GraphQLNonNull(new GraphQLList(singleTableItemOutput)),
-				args: updateManyGenerated.args,
-				resolve: updateManyGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "updateMany",
-					single: false,
-					targetArg: "updates"
-				}) },
-				description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
-			});
-			if (updateSingleGenerated) defineRootField(mutations, "mutation", updateSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: updateSingleGenerated.args,
-				resolve: updateSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "update",
-					single: true,
-					targetArg: "where"
-				}) }
-			});
-			if (deleteGenerated) defineRootField(mutations, "mutation", deleteGenerated.name, {
-				type: arrTableItemOutput,
-				args: deleteGenerated.args,
-				resolve: deleteGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "delete",
-					single: false,
-					targetArg: "where",
-					...softDeleteInfo?.hardDelete ? { hardDelete: true } : {}
-				}) }
-			});
-			if (deleteSingleGenerated) defineRootField(mutations, "mutation", deleteSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: deleteSingleGenerated.args,
-				resolve: deleteSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "delete",
-					single: true,
-					targetArg: "where",
-					...softDeleteInfo?.hardDelete ? { hardDelete: true } : {}
-				}) }
-			});
-			if (restoreGenerated) defineRootField(mutations, "mutation", restoreGenerated.name, {
-				type: arrTableItemOutput,
-				args: restoreGenerated.args,
-				resolve: restoreGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "restore",
-					single: false,
-					targetArg: "where"
-				}) }
-			});
-			if (restoreSingleGenerated) defineRootField(mutations, "mutation", restoreSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: restoreSingleGenerated.args,
-				resolve: restoreSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "restore",
-					single: true,
-					targetArg: "where"
-				}) }
-			});
-			if (updateCountGenerated) defineRootField(mutations, "mutation", updateCountGenerated.name, {
-				type: new GraphQLNonNull(GraphQLInt),
-				args: updateCountGenerated.args,
-				resolve: updateCountGenerated.resolver,
-				description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
-			});
-			if (deleteCountGenerated) defineRootField(mutations, "mutation", deleteCountGenerated.name, {
-				type: new GraphQLNonNull(GraphQLInt),
-				args: deleteCountGenerated.args,
-				resolve: deleteCountGenerated.resolver,
-				description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
-			});
-			[
-				...tableFeatures.insert || onConflictInput ? [insertInput] : [],
-				...onConflictInput ? [onConflictInput] : [],
-				...tableFeatures.update ? [updateInput] : [],
-				...updateManyInput ? [updateManyInput] : [],
-				tableFilters,
-				tableOrder
-			].forEach((e) => {
-				inputs[e.name] = e;
-			});
-			outputs[selectSingleOutput.name] = selectSingleOutput;
-			outputs[singleTableItemOutput.name] = singleTableItemOutput;
-			if (aggregateType) outputs[aggregateType.name] = aggregateType;
-			if (groupByType && havingInput) {
-				outputs[groupByType.name] = groupByType;
-				inputs[havingInput.name] = havingInput;
-			}
-		}
+			const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
+			return {
+				mutations: [
+					{
+						generated: insertArrGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "insert",
+							single: false,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: insertSingleGenerated,
+						type: conflictDoNothing ? singleTableItemOutput : new GraphQLNonNull(singleTableItemOutput),
+						meta: {
+							operation: "insert",
+							single: true,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: upsertArrGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "upsert",
+							single: false,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: upsertSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "upsert",
+							single: true,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: updateGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "update",
+							single: false,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: updateManyGenerated,
+						type: new GraphQLNonNull(new GraphQLList(singleTableItemOutput)),
+						meta: {
+							operation: "updateMany",
+							single: false,
+							targetArg: "updates"
+						},
+						description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
+					},
+					{
+						generated: updateSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "update",
+							single: true,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: deleteGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "delete",
+							single: false,
+							targetArg: "where",
+							...hardDeleteMeta
+						}
+					},
+					{
+						generated: deleteSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "delete",
+							single: true,
+							targetArg: "where",
+							...hardDeleteMeta
+						}
+					},
+					{
+						generated: restoreGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "restore",
+							single: false,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: restoreSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "restore",
+							single: true,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: updateCountGenerated,
+						type: new GraphQLNonNull(GraphQLInt),
+						description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+					},
+					{
+						generated: deleteCountGenerated,
+						type: new GraphQLNonNull(GraphQLInt),
+						description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+					}
+				],
+				onConflictInput,
+				updateManyInput
+			};
+		});
 		return finalizeBuild(ctx);
 	};
 };
@@ -7487,7 +7636,9 @@ const runUpdateManyBatch = ({ executor, entries, table, returning, nested, table
 * @param runBatch how the entries execute; defaults to {@link runUpdateManyBatch}
 */
 const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateManyBatch) => {
-	return (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
+	return (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, updateManyInput, fieldName, typeName } = opts;
 		const queryArgs = { updates: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(updateManyInput))) } };
 		const pkNames = primaryKeyPropNames(table);
 		return writeResolver({
@@ -7505,8 +7656,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 +7665,6 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7532,11 +7681,12 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					};
 				});
 				const anyNested = entries.some((entry) => entry.ops);
+				const returning = anyNested ? nested.withJoinColumns(tableName, mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))), { ...columns }, table) : columns;
 				const perEntry = await runBatch({
 					executor,
 					entries,
 					table,
-					returning: anyNested ? nested.withJoinColumns(tableName, mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))), { ...columns }, table) : columns,
+					returning,
 					anyNested,
 					nested,
 					tableName,
@@ -7544,7 +7694,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) {