@vantreeseba/drizzle-graphql 11.0.1 → 12.0.0

package/dist/index.js

@@ -520,11 +520,12 @@ const isJsonColumn = (column) => (column.dataType ?? "").includes("json") && col
 *                       StringArray, …) so arrays with different element types never share
 *                       one filter input; membership operators instead of scalar comparisons
 * - "Id"          → uuid-typed columns (no string pattern operators)
-* - "Boolean"     → boolean columns
+* - "Boolean"     → boolean columns (equality and membership only — no ordering, no patterns)
 * - "BigInt"      → bigint columns (BigInt-scalar-typed operators, no string pattern operators)
 * - "Decimal"     → numeric/decimal columns (Decimal-scalar-typed operators, no string pattern operators)
-* - the enum GraphQL type name → enum columns (still unique per enum)
-* - "DateTime"    → timestamp and date columns
+* - the enum GraphQL type name → enum columns (still unique per enum; equality and
+*                       membership only, like Boolean)
+* - "DateTime"    → timestamp and date columns (ordering kept, no string pattern operators)
 * - "Int"         → integer/serial columns (no string pattern operators)
 * - "Float"       → real/double columns (no string pattern operators)
 * - "String"      → all other text/varchar columns
@@ -552,7 +553,8 @@ const resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
 	};
 	if (columnGraphQLType.type instanceof GraphQLEnumType) return {
 		name: columnGraphQLType.type.name,
-		kind: "scalar"
+		kind: "scalar",
+		isEnum: true
 	};
 	if (columnGraphQLType.type === GraphQLBigIntString) return {
 		name: "BigInt",
@@ -776,18 +778,32 @@ const arrayFilterFields = (colType, colArr) => {
 };
 /**
 * Filters whose fields omit the string pattern operators (like/notLike/ilike/notIlike/
-* startsWith/contains/…): they are nonsensical on opaque uuids and invalid SQL on numeric
-* columns. Keyed on the generic filter name (i.e. on column type) — a string-typed column
-* keeps the string operators whatever it is called.
+* startsWith/contains/… and the `insensitive` flag that modifies them): they are nonsensical
+* on opaque uuids, booleans and enum members, invalid SQL on numeric columns, and on a
+* timestamp they match whatever the session happens to render the value as rather than
+* anything in the query. Keyed on the generic filter name (i.e. on column type) — a
+* string-typed column keeps the string operators whatever it is called. Enum filters are
+* named after their enum and are recognised by `isEnum` instead.
 */
 const FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set([
 	"Id",
 	"Int",
 	"Float",
 	"BigInt",
-	"Decimal"
+	"Decimal",
+	"Boolean",
+	"Date",
+	"DateTime"
 ]);
 /**
+* Filters that additionally omit the ordering operators (lt/lte/gt/gte). Ordering two
+* booleans is `eq` spelled as a puzzle (`gt: false` is `eq: true`), and ordering enum members
+* compares their declaration order — an artefact of how the column was written rather than a
+* fact about the domain. Timestamps and the numerics keep them: ranges are the point of
+* having them. Enum filters are recognised by `isEnum`, as above.
+*/
+const FILTERS_WITHOUT_ORDERING_OPS = /* @__PURE__ */ new Set(["Boolean"]);
+/**
 * Scalars the built-in detection itself can produce. A scalar override to one of these
 * shares the built-in filter type for that scalar, so its shape must stay exactly what a
 * natural column of the scalar gets — whichever column builds the cached type first.
@@ -830,14 +846,15 @@ const resolveOverrideFilterDescriptor = (scalar) => {
 const generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
 	const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
 	const inputOverride = getColumnScalarOverride(column, true);
-	const { name: genericName, kind } = inputOverride ? resolveOverrideFilterDescriptor(inputOverride) : resolveGenericFilterDescriptor(column, columnGraphQLType);
+	const { name: genericName, kind, isEnum } = inputOverride ? resolveOverrideFilterDescriptor(inputOverride) : resolveGenericFilterDescriptor(column, columnGraphQLType);
 	const cached = cacheCtx.genericFilterCache.get(genericName);
 	if (cached) return cached;
 	const colType = columnGraphQLType.type;
 	const colArr = new GraphQLList(new GraphQLNonNull(colType));
 	const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
 	const underlying = extractExtendedColumnType(column);
-	const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : FILTERS_WITHOUT_STRING_OPS.has(genericName);
+	const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : isEnum || FILTERS_WITHOUT_STRING_OPS.has(genericName);
+	const omitOrderingOps = !customOverrideFilter && (isEnum || FILTERS_WITHOUT_ORDERING_OPS.has(genericName));
 	const baseFields = kind === "json" ? jsonFilterFields(column, colType, cacheCtx.typeName) : kind === "array" ? arrayFilterFields(colType, colArr) : {
 		eq: {
 			type: colType,
@@ -847,21 +864,23 @@ const generateColumnFilterValues = (column, tableName, columnName, cacheCtx) =>
 			type: colType,
 			description: "Not equal to"
 		},
-		lt: {
-			type: colType,
-			description: "Less than"
-		},
-		lte: {
-			type: colType,
-			description: "Less than or equal to"
-		},
-		gt: {
-			type: colType,
-			description: "Greater than"
-		},
-		gte: {
-			type: colType,
-			description: "Greater than or equal to"
+		...omitOrderingOps ? {} : {
+			lt: {
+				type: colType,
+				description: "Less than"
+			},
+			lte: {
+				type: colType,
+				description: "Less than or equal to"
+			},
+			gt: {
+				type: colType,
+				description: "Greater than"
+			},
+			gte: {
+				type: colType,
+				description: "Greater than or equal to"
+			}
 		},
 		...omitStringOps ? {} : {
 			like: { type: GraphQLString },
@@ -2883,6 +2902,154 @@ const listFieldComplexity = (options, policy) => ({ args, childComplexity }) =>
 */
 const aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
 //#endregion
+//#region src/util/parse-resolve-info.ts
+/** Unwraps `[T]!`-style wrappers down to the named type. `getNamedType` without the realm tie. */
+const namedTypeOf = (type) => {
+	let current = type;
+	while (current?.ofType) current = current.ofType;
+	return current;
+};
+/**
+* Whether a field's named output type has sub-selections. Object types and interfaces expose
+* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
+* also expose `getFields`, but an input type can never be a field's output type, so there is
+* nothing here for that to collide with.
+*/
+const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
+/**
+* The fields declared on a type, or `undefined` when it has none to declare. A union is the
+* case that matters: it has no fields of its own, so a selection directly against one resolves
+* to nothing and is dropped — only the inline fragments underneath contribute.
+*/
+const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
+/**
+* The runtime variable values, in the plain-map form the directive check wants. graphql 17
+* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
+*/
+const coercedVariables = (info) => {
+	const values = info.variableValues;
+	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
+	return values ?? {};
+};
+/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
+const directiveIfValue = (info, value) => {
+	if (value.kind === Kind.VARIABLE) return coercedVariables(info)[value.name.value];
+	if (value.kind === Kind.BOOLEAN) return value.value;
+};
+/**
+* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
+* spreads and inline fragments alike, which is where graphql puts them.
+*/
+const isExcluded = (info, node) => {
+	for (const directive of node.directives ?? []) {
+		const directiveName = directive.name.value;
+		if (directiveName !== "skip" && directiveName !== "include") continue;
+		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
+		if (!ifArgument) continue;
+		const value = directiveIfValue(info, ifArgument.value);
+		if (directiveName === "skip" ? !!value : !value) return true;
+	}
+	return false;
+};
+/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
+const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
+/**
+* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
+* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
+* to declare a field by that name.
+*/
+const isMetaField = (name) => name.startsWith("__") && name !== "__id";
+/**
+* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
+* level, this owns the entries under `parentType`'s name.
+*
+* `activeFragments` is the set of fragment names on the current spread path. A document that
+* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
+* caller assembled by hand, and an unbounded walk would hang rather than fail.
+*/
+const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
+	const parentTypeName = parentType?.name;
+	if (!parentTypeName) return tree;
+	let fields = tree[parentTypeName];
+	if (!fields) {
+		fields = {};
+		tree[parentTypeName] = fields;
+	}
+	const parentFields = fieldsOf(parentType);
+	for (const selection of selections) {
+		if (isExcluded(info, selection)) continue;
+		if (selection.kind === Kind.FIELD) {
+			const name = selection.name.value;
+			if (isMetaField(name)) continue;
+			const fieldDef = parentFields?.[name];
+			if (!fieldDef) continue;
+			const fieldType = namedTypeOf(fieldDef.type);
+			if (!fieldType) continue;
+			const composite = isCompositeLike(fieldType);
+			const alias = selection.alias?.value || name;
+			let node = fields[alias];
+			if (!node) {
+				node = {
+					name,
+					alias,
+					args: { ...getArgumentValues(fieldDef, selection, info.variableValues) },
+					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
+				};
+				fields[alias] = node;
+			}
+			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
+			continue;
+		}
+		if (!deep) continue;
+		if (selection.kind === Kind.FRAGMENT_SPREAD) {
+			const fragmentName = selection.name.value;
+			const fragment = info.fragments?.[fragmentName];
+			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
+			if (activeFragments.has(fragmentName)) continue;
+			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			activeFragments.add(fragmentName);
+			try {
+				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+			} finally {
+				activeFragments.delete(fragmentName);
+			}
+			continue;
+		}
+		if (selection.kind === Kind.INLINE_FRAGMENT) {
+			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+		}
+	}
+	return tree;
+};
+/** The first key of an object, without materializing the whole key array to discard it. */
+const firstKey = (object) => {
+	for (const key in object) return key;
+};
+/**
+* Reads the selection under a resolver's own field out of its `info`, as a tree of
+* {@link ResolveTree} nodes.
+*
+* ```ts
+* const parsed = parseResolveInfo(info, { deep: true })!;
+* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+* ```
+*
+* Returns `undefined` when the resolver's field produced no node at all, which in practice
+* means `info` carried no field nodes.
+*/
+const parseResolveInfo = (info, options = {}) => {
+	const fieldNodes = info.fieldNodes;
+	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
+	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
+	const typeKey = firstKey(tree);
+	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
+	const fieldKey = fields && firstKey(fields);
+	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
+};
+//#endregion
 //#region src/util/builders/field-updates.ts
 /**
 * The scalars arithmetic is offered on. Decimal and BigInt transport as strings but are
@@ -3215,6 +3382,127 @@ 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;
 };
+//#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;
+};
 const createMutationTxCtx = (options) => options ? {
 	timeoutMs: options.timeoutMs,
 	fieldNames: /* @__PURE__ */ new Set(),
@@ -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 {
@@ -3780,8 +4100,8 @@ const identifyRows = (field, args) => {
 * 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, orderCtx, whereArgs) => {
-	const cols = getColumns(targetTable);
+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";
@@ -3827,12 +4147,39 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 		operation: "relation",
 		relation: relationName
 	};
+	/**
+	* The columns one batch reads: the ones the selection names, plus the ones the batch needs
+	* whatever the client asked for — the key it groups the rows by, and the ordering columns a
+	* row cursor is encoded from. Nested relation fields contribute their own join column
+	* through the selection context, the same way the root select path narrows.
+	*
+	* `undefined` means "every column", which is what a resolver with no readable resolve info
+	* has to fall back to.
+	*/
+	const selectedColumns = (info, cursorEntries) => {
+		const parsed = info ? parseResolveInfo(info) : void 0;
+		if (!parsed) return;
+		const tree = Object.assign({}, ...Object.values(parsed.fieldsByTypeName));
+		const columns = extractSelectedColumnsFromTreeSQLFormat(tree, targetTable, {
+			tableName: targetTableName,
+			relationMap: filterCtx?.relationMap ?? {},
+			tables,
+			allRelations: filterCtx?.relationMap
+		});
+		const targetColumns = getColumns(targetTable);
+		columns[foreignColPropName] = foreignCol;
+		for (const [columnName] of cursorEntries ?? []) {
+			const column = targetColumns[columnName];
+			if (column) columns[columnName] = column;
+		}
+		return columns;
+	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
 		const localValue = parent[localColPropName];
 		if (localValue == null) return isOne ? null : [];
 		const { where: whereArg, limit: requestedLimit, offset, after, deleted } = args ?? {};
-		const { orderByArg, limit, distinct, cursorEntries, cursorValues, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
+		const { orderByArg, limit, distinct, cursorEntries, cursorValues, columns, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
 			const orderByArg = isOne ? args?.orderBy : withDefaultOrderBy(args ?? {}, targetTableName, policies?.defaultOrderBy).orderBy;
 			const limit = applyLimitPolicy(requestedLimit, limitPolicy, errorCtx);
 			const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
@@ -3847,6 +4194,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				} else cursorEntries = cursorOrderingEntries(orderByArg, targetPkNames);
 			}
 			const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
+			const columns = selectedColumns(info, cursorEntries);
 			const argsKey = JSON.stringify({
 				where: whereArg ?? null,
 				orderBy: orderByArg ?? null,
@@ -3855,7 +4203,8 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				deleted: deleted ?? defaultDeleted ?? null,
 				after: after ?? null,
 				distinct: distinct ?? null,
-				cursor: cursorEntries ? 1 : 0
+				cursor: cursorEntries ? 1 : 0,
+				columns: columns ? Object.keys(columns).sort() : null
 			});
 			return {
 				orderByArg,
@@ -3863,6 +4212,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				distinct,
 				cursorEntries,
 				cursorValues,
+				columns,
 				loaderKey: `${tableName}::${relationName}::${argsKey}`
 			};
 		});
@@ -3886,9 +4236,9 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				whereCondition = and(whereCondition, primaryKeyRestriction(targetTable, targetPkNames, keys));
 			}
 			let rows;
-			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, relationFilterCtx(filterCtx, targetTableName), whereArg);
+			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, columns, relationFilterCtx(filterCtx, targetTableName), whereArg);
 			else {
-				let q = executor.select().from(targetTable).where(whereCondition);
+				let q = (columns ? executor.select(columns) : executor.select()).from(targetTable).where(whereCondition);
 				const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName), whereArg) : [];
 				if (orderExprs.length) q = q.orderBy(...orderExprs);
 				rows = await q;
@@ -3959,165 +4309,44 @@ const computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes
 	const restoreSingleFieldName = `${restoreBase}${writeSingleSuffix}`;
 	return {
 		typeName,
-		listFieldName,
-		singleFieldName,
-		aggregateFieldName,
-		groupByFieldName,
-		createArrayFieldName,
-		createSingleFieldName,
-		upsertArrayFieldName,
-		upsertSingleFieldName,
-		updateFieldName,
-		updateManyFieldName,
-		updateSingleFieldName,
-		updateCountFieldName: `${prefixes.update}${pluralNoun}Count`,
-		deleteFieldName,
-		deleteSingleFieldName,
-		restoreFieldName,
-		restoreSingleFieldName,
-		deleteCountFieldName: `${prefixes.delete}${pluralNoun}Count`
-	};
-};
-//#endregion
-//#region src/util/builders/common/root-fields.ts
-/**
-* Registers one generated root field, refusing to overwrite a name already taken.
-*
-* A generated name is the table name run through `typeNameMapper`, a prefix and a suffix,
-* and the pluralization each operation applies — so whether two operations collide is a
-* property of the finished names, not of any one piece of the config. `buildSchema` checks
-* what it can up front (identical list and single suffixes with no mapper), but that check
-* compares the suffix *strings*, which cannot see a collision the rest of the naming rules
-* produce: `{ list: 'All', single: '' }` used to give both insert mutations the name
-* `createUsers`, and the array insert simply disappeared from the schema.
-*
-* Assigning into the record silently kept the last registration. Throwing here means a
-* naming config that cannot work says so at build time, naming the field it lost.
-*/
-const defineRootField = (fields, kind, name, config) => {
-	if (Object.getOwnPropertyDescriptor(fields, name) !== void 0) throw new Error(`Drizzle-GraphQL Error: two generated ${kind} fields are both named '${name}'. Generated names come from the table name plus config.prefixes, config.suffixes and config.typeNameMapper — some combination of those gives two operations the same name. Adjust one of them so each operation gets its own.`);
-	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
+		listFieldName,
+		singleFieldName,
+		aggregateFieldName,
+		groupByFieldName,
+		createArrayFieldName,
+		createSingleFieldName,
+		upsertArrayFieldName,
+		upsertSingleFieldName,
+		updateFieldName,
+		updateManyFieldName,
+		updateSingleFieldName,
+		updateCountFieldName: `${prefixes.update}${pluralNoun}Count`,
+		deleteFieldName,
+		deleteSingleFieldName,
+		restoreFieldName,
+		restoreSingleFieldName,
+		deleteCountFieldName: `${prefixes.delete}${pluralNoun}Count`
 	};
-	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);
 };
+//#endregion
+//#region src/util/builders/common/root-fields.ts
 /**
-* 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.
+* Registers one generated root field, refusing to overwrite a name already taken.
 *
-* `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.
+* A generated name is the table name run through `typeNameMapper`, a prefix and a suffix,
+* and the pluralization each operation applies — so whether two operations collide is a
+* property of the finished names, not of any one piece of the config. `buildSchema` checks
+* what it can up front (identical list and single suffixes with no mapper), but that check
+* compares the suffix *strings*, which cannot see a collision the rest of the naming rules
+* produce: `{ list: 'All', single: '' }` used to give both insert mutations the name
+* `createUsers`, and the array insert simply disappeared from the schema.
 *
-* 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.
+* Assigning into the record silently kept the last registration. Throwing here means a
+* naming config that cannot work says so at build time, naming the field it lost.
 */
-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 defineRootField = (fields, kind, name, config) => {
+	if (Object.getOwnPropertyDescriptor(fields, name) !== void 0) throw new Error(`Drizzle-GraphQL Error: two generated ${kind} fields are both named '${name}'. Generated names come from the table name plus config.prefixes, config.suffixes and config.typeNameMapper — some combination of those gives two operations the same name. Adjust one of them so each operation gets its own.`);
+	fields[name] = config;
 };
 //#endregion
 //#region src/util/builders/common/table-inputs.ts
@@ -4903,154 +5132,6 @@ const resolveBuildConfig = (config, schema) => {
 	};
 };
 //#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/aggregates.ts
 /** Operations that aggregate over a set of column values. `count` is handled separately (whole rows). */
 const AGGREGATE_OPS = [
@@ -5935,7 +6016,7 @@ const createNestedWriteRuntime = (params) => {
 	};
 	/** The values the junction stores for the target rows one operand selects. */
 	const selectedTargetKeys = async (executor, plan, filter, operation, scope) => {
-		return (await executor.select().from(plan.targetTable).where(conditionOf(plan, filter, operation, scope))).map((row) => row[plan.foreignColPropName]).filter((value) => value !== void 0 && value !== null);
+		return (await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, filter, operation, scope))).map((row) => row[plan.foreignColPropName]).filter((value) => value !== void 0 && value !== null);
 	};
 	/**
 	* The link half of a many-to-many write: junction rows are inserted and deleted, and both
@@ -5950,7 +6031,7 @@ const createNestedWriteRuntime = (params) => {
 		const through = plan.through;
 		const unlinkAll = () => executor.delete(through.table).where(eq(through.sourceCol, key));
 		const link = async (operands, operation) => {
-			const existing = new Set((await executor.select().from(through.table).where(eq(through.sourceCol, key))).map((row) => row[through.targetColPropName]));
+			const existing = new Set((await executor.select({ [through.targetColPropName]: through.targetCol }).from(through.table).where(eq(through.sourceCol, key))).map((row) => row[through.targetColPropName]));
 			const rows = [];
 			for (const filter of operands) for (const targetKey of await selectedTargetKeys(executor, plan, filter, operation, scope)) if (!existing.has(targetKey)) {
 				existing.add(targetKey);
@@ -6011,11 +6092,11 @@ const createNestedWriteRuntime = (params) => {
 				assertSingleOperation(plan, op);
 				if (op["create"] !== void 0) {
 					const values = applyContextValues(remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable), contextValues?.(plan.targetTableName), context);
-					const created = (await executor.insert(plan.targetTable).values(values).returning())[0];
+					const created = (await executor.insert(plan.targetTable).values(values).returning({ [plan.foreignColPropName]: plan.foreignCol }))[0];
 					if (!created) throw drizzleError(`Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					patch[plan.localColPropName] = created[plan.foreignColPropName];
 				} else if (op["connect"] !== void 0) {
-					const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
+					const rows = await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
 					if (rows.length !== 1) throw drizzleError(`Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows — it attaches a single row, so its filter must match exactly one.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
 				} else if (op["disconnect"] === true) patch[plan.localColPropName] = null;
@@ -6553,7 +6634,14 @@ const generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, si
 		if (!Object.keys(input).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
 		await before();
 		const relationCtx = relationFilterCtx(filterCtx, tableName);
-		const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0);
+		const filters = scopedWhere({
+			scope,
+			tableName,
+			table,
+			where,
+			relationCtx,
+			required: single || requireWhere
+		});
 		if (single) await assertSingleMatch(executor, table, filters);
 		let query = executor.update(table).set(input);
 		if (filters) query = query.where(filters);
@@ -6635,7 +6723,15 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 			const hard = canHardDelete && args.hard === true;
 			const scope = policies?.scope?.(context);
 			const relationCtx = relationFilterCtx(filterCtx, tableName);
-			const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0, restore ? "ONLY" : hard ? "INCLUDE" : void 0);
+			const filters = scopedWhere({
+				scope,
+				tableName,
+				table,
+				where,
+				relationCtx,
+				required: single || requireWhere,
+				deleted: restore ? "ONLY" : hard ? "INCLUDE" : void 0
+			});
 			if (single) await assertSingleMatch(executor, table, filters);
 			let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
 			if (filters) query = query.where(filters);
@@ -6863,8 +6959,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table), contextColumns, context);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -6873,7 +6968,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -6894,7 +6988,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					context
 				}) : await runInsert(executor, input);
 				await after(result);
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
@@ -6918,8 +7012,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntry ? {} : applyContextValues(remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table), contextColumns, context);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -6928,7 +7021,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -6953,7 +7045,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					if (!conflictDoNothing) throw drizzleError("The insert returned no row.", { code: "DRIZZLE_NO_ROW_RETURNED" });
 					return;
 				}
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
 			}
 		});
@@ -6991,8 +7083,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -7001,7 +7092,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7038,7 +7128,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				}) : await runUpsert(executor, input);
 				await after(result);
 				if (single && !result[0]) return;
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
@@ -7062,8 +7152,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const { where, set } = args;
 				const scope = policies?.scope?.(context);
 				await before();
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -7072,7 +7161,6 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7082,7 +7170,14 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const input = stripContextValues(remapUpdateInput(entry ? entry.columns : set, table, tableName), policies?.contextValues?.(tableName));
 				if (!Object.keys(input).length && !nestedOps) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
 				const relationCtx = relationFilterCtx(filterCtx, tableName);
-				const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0);
+				const filters = scopedWhere({
+					scope,
+					tableName,
+					table,
+					where,
+					relationCtx,
+					required: single || requireWhere
+				});
 				if (single) await assertSingleMatch(executor, table, filters);
 				const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
 				const runUpdate = async (target, values) => {
@@ -7104,7 +7199,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				await after(result);
 				if (single && result.length > 1) throw drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
 				if (single && !result[0]) return;
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
@@ -7146,7 +7241,15 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const columns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[applyObjectTypeName(typeName, tableName, resolveName)], table, selectionCtx);
 				const relationCtx = relationFilterCtx(filterCtx, tableName);
-				const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0, restore ? "ONLY" : hard ? "INCLUDE" : void 0);
+				const filters = scopedWhere({
+					scope,
+					tableName,
+					table,
+					where,
+					relationCtx,
+					required: single || requireWhere,
+					deleted: restore ? "ONLY" : hard ? "INCLUDE" : void 0
+				});
 				if (single) await assertSingleMatch(executor, table, filters);
 				let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
 				if (filters) query = query.where(filters);
@@ -7475,8 +7578,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 				await before();
 				const scope = policies?.scope?.(context);
 				const contextColumns = policies?.contextValues?.(tableName);
-				const parsedInfo = parseResolveInfo(info, { deep: true });
-				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
 					tableName,
@@ -7485,7 +7587,6 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					resolveName,
 					table,
 					pkNames,
-					parsedInfo,
 					limits,
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
@@ -7514,7 +7615,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 				});
 				const flatRows = perEntry.flat();
 				await after(flatRows);
-				const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+				const enriched = await withEagerRelations(executor, tableName, flatRows, pkNames, withParams, hasRelations);
 				const output = [];
 				let offset = 0;
 				for (const rows of perEntry) {