@vantreeseba/drizzle-graphql 13.1.0 → 14.0.0

package/dist/index.js

@@ -3724,6 +3724,145 @@ const runMutation = async (db, context, info, txCtx, body, forceTx) => {
 	return runOnSharedTx(state, body);
 };
 //#endregion
+//#region src/util/builders/common/write-hooks.ts
+/**
+* Normalizes the two registration shapes: a bare function is the `after` hook — the position
+* that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
+* names them explicitly.
+*/
+const normalizeWriteHooks = (hooks, tableColumns, where) => {
+	if (!hooks) return;
+	if (typeof hooks === "function") return { after: hooks };
+	const resolved = {
+		before: hooks.before,
+		after: hooks.after
+	};
+	if (hooks.columns !== void 0) resolved.columns = resolveHookColumns(hooks.columns, !!hooks.after, tableColumns, where);
+	return resolved.before || resolved.after ? resolved : void 0;
+};
+/**
+* Resolves a hook's `columns` against the table it runs on. `where` names the registration
+* (`config.onWrite.posts`) and, for a top-level one, the table, so the error says which.
+*/
+const resolveHookColumns = (spec, hasAfter, tableColumns, where) => {
+	if (!hasAfter) throw new Error(`Drizzle-GraphQL Error: ${where}.columns only applies to an 'after' hook, and none is registered.`);
+	if (spec === "all") return { ...tableColumns };
+	if (!Array.isArray(spec)) throw new Error(`Drizzle-GraphQL Error: ${where}.columns must be an array of column names or 'all'.`);
+	const resolved = {};
+	for (const name of spec) {
+		const column = typeof name === "string" && Object.keys(tableColumns).includes(name) ? tableColumns[name] : void 0;
+		if (!column) throw new Error(`Drizzle-GraphQL Error: ${where}.columns names '${String(name)}', which is not a column of that table.`);
+		resolved[name] = column;
+	}
+	return resolved;
+};
+/**
+* Adds a hook's `columns` to a RETURNING column map, and reports which keys it added — the
+* ones the client never asked for, which have to come back off before the rows are mapped.
+* Returns the map untouched, and no keys, when the hook named none or the selection already
+* covers them.
+*/
+const withHookColumns = (hooks, columns) => {
+	const hookColumns = hooks?.columns;
+	if (!hookColumns) return {
+		returning: columns,
+		added: void 0
+	};
+	const selected = new Set(Object.keys(columns));
+	const added = Object.keys(hookColumns).filter((key) => !selected.has(key));
+	if (!added.length) return {
+		returning: columns,
+		added: void 0
+	};
+	const returning = { ...columns };
+	for (const key of added) returning[key] = hookColumns[key];
+	return {
+		returning,
+		added
+	};
+};
+/**
+* The rows with the hook-only keys taken off, as fresh objects: the hook was handed the
+* originals and may still hold them, so they are not mutated under it.
+*/
+const omitHookColumns = (rows, added) => {
+	if (!added) return rows;
+	return rows.map((row) => {
+		const copy = { ...row };
+		for (const key of added) delete copy[key];
+		return copy;
+	});
+};
+/**
+* Invokes one position of a field's hooks. Returns `undefined` rather than a resolved promise
+* when nothing is registered, so the awaiting call site costs nothing on an unhooked build.
+*/
+const runWriteHook = (hooks, position, payload) => {
+	const hook = position === "before" ? hooks?.before : hooks?.after;
+	if (!hook) return;
+	return Promise.resolve(hook({
+		...payload,
+		position,
+		rows: payload.rows ?? []
+	}));
+};
+//#endregion
+//#region src/util/builders/common/write-scaffold.ts
+/**
+* Wraps one mutation body in the scaffolding above and returns the field it becomes.
+*
+* A field carrying a hook is forced into a transaction even when it would have run straight
+* on `db`: a hook exists to write atomically with the mutation, and one that ran outside the
+* transaction could not roll anything back.
+*/
+const writeResolver = ({ db, tableName, operation, single, fieldName, args: queryArgs, txCtx, policies, run }) => {
+	const hooks = policies?.onWrite?.(tableName, operation);
+	const errorCtx = {
+		table: tableName,
+		operation,
+		field: fieldName
+	};
+	return {
+		name: fieldName,
+		resolver: async (_source, args, context, info) => {
+			try {
+				return await runMutation(db, context, info, txCtx, (executor) => {
+					const payload = {
+						table: tableName,
+						operation,
+						single,
+						args,
+						context,
+						info,
+						tx: executor
+					};
+					let added;
+					return run({
+						executor,
+						args,
+						context,
+						info,
+						before: () => runWriteHook(hooks, "before", payload),
+						after: (rows) => runWriteHook(hooks, "after", {
+							...payload,
+							rows: rows ?? []
+						}),
+						returning: (columns) => {
+							const withHook = withHookColumns(hooks, columns);
+							added = withHook.added;
+							return withHook.returning;
+						},
+						output: (rows) => omitHookColumns(rows, added)
+					});
+				}, !!hooks);
+			} catch (e) {
+				throw withErrorContext(toGraphQLError(e), errorCtx);
+			}
+		},
+		args: queryArgs
+	};
+};
+//#endregion
 //#region src/util/builders/common/mutation-helpers.ts
 /**
 * The `hard` argument on the delete mutations of a soft-deleting table that opted into
@@ -3867,54 +4006,79 @@ const assertSingleMatch = async (executor, table, filters) => {
 * The plural `update` and `delete` always `RETURNING *`, which is the wrong shape for
 * "archive everything older than a year": the caller pays to ship rows it does not want, and
 * on a large match that cost is the whole mutation. These return `Int!` instead — how many
-* rows the write touched, as the driver reported it, with no RETURNING clause at all.
+* rows the write touched.
 *
-* Dialect-independent: drizzle's update/delete builders take the same calls everywhere, and
-* the drivers' disagreement about how to spell the row count is handled by
-* {@link rowsAffected}.
-*/
-const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested }) => {
+* Leaving the payload off changes nothing else: the write obeys every rule of the plural
+* mutation it mirrors, through the same {@link writeResolver} scaffolding.
+*
+* - `scope` (and the soft-delete marker) is ANDed into the `where`, so only rows the plural
+*   write could reach are counted and written.
+* - On a soft-deleting table the delete is the marking `UPDATE`, not a `DELETE`, and rows that
+*   are already marked are not matched; the update skips marked rows too. `hard: true` exists
+*   exactly where the plural delete takes it.
+* - Context-derived columns are stripped from the update's `set`, as the plural update does.
+* - `onWrite` hooks run `before` and `after`, inside a transaction. The `after` hook is handed
+*   rows, so a table with one pays for a `RETURNING` — of the columns the hook names in
+*   `columns`, or of the primary key when it names none (the whole row on a table without a
+*   key) — and the count is the number of rows returned. Every other write, and every write on
+*   MySQL (no `RETURNING`; its hooks see `rows: []` as on every MySQL mutation), skips the
+*   `RETURNING` and reads the count off the driver's result via {@link rowsAffected}.
+*/
+const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested, policies, pkNames = [], returnsRows }) => {
+	const softDelete = kind === "delete" ? policies?.softDelete?.(tableName) : void 0;
+	const canHardDelete = softDelete?.hardDelete === true;
 	const queryArgs = {
 		...setArgs ? { set: { type: new GraphQLNonNull(setArgs) } } : {},
-		where: { type: requireWhere ? new GraphQLNonNull(filterArgs) : filterArgs }
+		where: { type: requireWhere ? new GraphQLNonNull(filterArgs) : filterArgs },
+		...canHardDelete ? { hard: hardDeleteArg } : {}
 	};
-	const errorCtx = {
-		table: tableName,
+	const readsRows = returnsRows && !!policies?.onWrite?.(tableName, kind)?.after;
+	const allColumns = getColumns(table);
+	const keyColumns = pkNames.length ? Object.fromEntries(pkNames.map((name) => [name, allColumns[name]])) : allColumns;
+	return writeResolver({
+		db,
+		tableName,
 		operation: kind,
-		field: fieldName
-	};
-	return {
-		name: fieldName,
-		resolver: async (_source, args, context, info) => {
-			try {
-				return await runMutation(db, context, info, txCtx, async (executor) => {
-					const { where, set } = args;
-					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 {
-						const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-						if (entry && nested.hasOps(entry.ops)) throw drizzleError("This mutation does not support nested writes — use the one that returns the rows instead.", { code: "DRIZZLE_NESTED_WRITES_UNSUPPORTED" });
-						const values = remapUpdateInput(entry ? entry.columns : set, table, tableName);
-						if (!Object.keys(values).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-						query = executor.update(table).set(values);
-					}
-					if (filters) query = query.where(filters);
-					return rowsAffected(await query);
-				});
-			} catch (e) {
-				throw withErrorContext(toGraphQLError(e), errorCtx);
+		single: false,
+		fieldName,
+		txCtx,
+		policies,
+		args: queryArgs,
+		run: async ({ executor, args, context, before, after, returning }) => {
+			const { where, set } = args;
+			const hard = canHardDelete && args.hard === true;
+			const scope = policies?.scope?.(context);
+			await before();
+			let query;
+			if (kind === "delete") query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: softDelete.writeDeleted() }) : executor.delete(table);
+			else {
+				const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+				if (entry && nested.hasOps(entry.ops)) throw drizzleError("This mutation does not support nested writes — use the one that returns the rows instead.", { code: "DRIZZLE_NESTED_WRITES_UNSUPPORTED" });
+				const values = stripContextValues(remapUpdateInput(entry ? entry.columns : set, table, tableName), policies?.contextValues?.(tableName));
+				if (!Object.keys(values).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
+				query = executor.update(table).set(values);
 			}
-		},
-		args: queryArgs
-	};
+			const filters = scopedWhere({
+				scope,
+				tableName,
+				table,
+				where,
+				relationCtx: relationFilterCtx(filterCtx, tableName),
+				required: requireWhere,
+				deleted: hard ? "INCLUDE" : void 0
+			});
+			if (filters) query = query.where(filters);
+			if (!readsRows) {
+				const result = await query;
+				await after();
+				return rowsAffected(result);
+			}
+			const named = returning({});
+			const rows = await query.returning(Object.keys(named).length ? named : keyColumns);
+			await after(rows);
+			return rows.length;
+		}
+	});
 };
 //#endregion
 //#region src/util/batch-loader/index.ts
@@ -4852,145 +5016,6 @@ const generateTableTypes = (tableName, tables, relationMap, withReturning, relat
 	};
 };
 //#endregion
-//#region src/util/builders/common/write-hooks.ts
-/**
-* Normalizes the two registration shapes: a bare function is the `after` hook — the position
-* that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
-* names them explicitly.
-*/
-const normalizeWriteHooks = (hooks, tableColumns, where) => {
-	if (!hooks) return;
-	if (typeof hooks === "function") return { after: hooks };
-	const resolved = {
-		before: hooks.before,
-		after: hooks.after
-	};
-	if (hooks.columns !== void 0) resolved.columns = resolveHookColumns(hooks.columns, !!hooks.after, tableColumns, where);
-	return resolved.before || resolved.after ? resolved : void 0;
-};
-/**
-* Resolves a hook's `columns` against the table it runs on. `where` names the registration
-* (`config.onWrite.posts`) and, for a top-level one, the table, so the error says which.
-*/
-const resolveHookColumns = (spec, hasAfter, tableColumns, where) => {
-	if (!hasAfter) throw new Error(`Drizzle-GraphQL Error: ${where}.columns only applies to an 'after' hook, and none is registered.`);
-	if (spec === "all") return { ...tableColumns };
-	if (!Array.isArray(spec)) throw new Error(`Drizzle-GraphQL Error: ${where}.columns must be an array of column names or 'all'.`);
-	const resolved = {};
-	for (const name of spec) {
-		const column = typeof name === "string" && Object.keys(tableColumns).includes(name) ? tableColumns[name] : void 0;
-		if (!column) throw new Error(`Drizzle-GraphQL Error: ${where}.columns names '${String(name)}', which is not a column of that table.`);
-		resolved[name] = column;
-	}
-	return resolved;
-};
-/**
-* Adds a hook's `columns` to a RETURNING column map, and reports which keys it added — the
-* ones the client never asked for, which have to come back off before the rows are mapped.
-* Returns the map untouched, and no keys, when the hook named none or the selection already
-* covers them.
-*/
-const withHookColumns = (hooks, columns) => {
-	const hookColumns = hooks?.columns;
-	if (!hookColumns) return {
-		returning: columns,
-		added: void 0
-	};
-	const selected = new Set(Object.keys(columns));
-	const added = Object.keys(hookColumns).filter((key) => !selected.has(key));
-	if (!added.length) return {
-		returning: columns,
-		added: void 0
-	};
-	const returning = { ...columns };
-	for (const key of added) returning[key] = hookColumns[key];
-	return {
-		returning,
-		added
-	};
-};
-/**
-* The rows with the hook-only keys taken off, as fresh objects: the hook was handed the
-* originals and may still hold them, so they are not mutated under it.
-*/
-const omitHookColumns = (rows, added) => {
-	if (!added) return rows;
-	return rows.map((row) => {
-		const copy = { ...row };
-		for (const key of added) delete copy[key];
-		return copy;
-	});
-};
-/**
-* Invokes one position of a field's hooks. Returns `undefined` rather than a resolved promise
-* when nothing is registered, so the awaiting call site costs nothing on an unhooked build.
-*/
-const runWriteHook = (hooks, position, payload) => {
-	const hook = position === "before" ? hooks?.before : hooks?.after;
-	if (!hook) return;
-	return Promise.resolve(hook({
-		...payload,
-		position,
-		rows: payload.rows ?? []
-	}));
-};
-//#endregion
-//#region src/util/builders/common/write-scaffold.ts
-/**
-* Wraps one mutation body in the scaffolding above and returns the field it becomes.
-*
-* A field carrying a hook is forced into a transaction even when it would have run straight
-* on `db`: a hook exists to write atomically with the mutation, and one that ran outside the
-* transaction could not roll anything back.
-*/
-const writeResolver = ({ db, tableName, operation, single, fieldName, args: queryArgs, txCtx, policies, run }) => {
-	const hooks = policies?.onWrite?.(tableName, operation);
-	const errorCtx = {
-		table: tableName,
-		operation,
-		field: fieldName
-	};
-	return {
-		name: fieldName,
-		resolver: async (_source, args, context, info) => {
-			try {
-				return await runMutation(db, context, info, txCtx, (executor) => {
-					const payload = {
-						table: tableName,
-						operation,
-						single,
-						args,
-						context,
-						info,
-						tx: executor
-					};
-					let added;
-					return run({
-						executor,
-						args,
-						context,
-						info,
-						before: () => runWriteHook(hooks, "before", payload),
-						after: (rows) => runWriteHook(hooks, "after", {
-							...payload,
-							rows: rows ?? []
-						}),
-						returning: (columns) => {
-							const withHook = withHookColumns(hooks, columns);
-							added = withHook.added;
-							return withHook.returning;
-						},
-						output: (rows) => omitHookColumns(rows, added)
-					});
-				}, !!hooks);
-			} catch (e) {
-				throw withErrorContext(toGraphQLError(e), errorCtx);
-			}
-		},
-		args: queryArgs
-	};
-};
-//#endregion
 //#region src/util/features.ts
 /**
 * What a table generates when the config says nothing. Everything is on except the opt-in
@@ -5202,7 +5227,6 @@ const resolveBuildConfig = (config, schema) => {
 			const missing = [!tableFeatures.insert ? "insert" : void 0, !tableFeatures.update ? "update" : void 0].filter(Boolean).join(" and ");
 			if (missing) noteConflict(`upsert is on while ${missing} is off, so the upsert mutations are a second write path past the operation you turned off`, tableName);
 		}
-		if (config?.features?.nestedWrites && (!tableFeatures.insert || !tableFeatures.update)) noteConflict("nestedWrites is on while this table's own insert or update is off, so a nested `create` or `connect` under another table's mutation can still write it", tableName);
 		if (config?.features?.updateMany !== void 0 && tableFeatures.updateMany && !tableFeatures.update) noteConflict("updateMany is on while update is off, so no batch update is generated", tableName);
 		if (config?.features?.groupBy !== void 0 && tableFeatures.groupBy && !tableFeatures.aggregates) noteConflict("groupBy is on while aggregates is off, so no grouped query is generated", tableName);
 		if (tableFeatures.countMutations && !tableFeatures.update && !tableFeatures.delete) noteConflict("countMutations is on while update and delete are both off, so no count mutation is generated", tableName);
@@ -5808,6 +5832,12 @@ const generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs,
 };
 //#endregion
 //#region src/util/builders/nested-writes.ts
+const ALL_OPS = [
+	"create",
+	"connect",
+	"disconnect",
+	"set"
+];
 /**
 * Whether a column can be left out of an INSERT — either the database fills it in or it
 * accepts NULL.
@@ -5836,7 +5866,7 @@ const throughColumn = (entry) => entry && is(entry, Column) ? entry : entry?._?.
 * joining on more than one column per side; and a junction carrying a further NOT NULL column
 * with no default, which no `connect` operand could supply a value for.
 */
-const buildThroughPlan = (relationName, relation, table, targetTableName, targetTable) => {
+const buildThroughPlan = (relationName, relation, table, targetTableName, targetTable, tableNameOf) => {
 	if (is(relation, One)) return;
 	const junction = relation.throughTable;
 	const sourceEntries = relation.through?.source;
@@ -5867,11 +5897,18 @@ const buildThroughPlan = (relationName, relation, table, targetTableName, target
 		canDetach: true,
 		through: {
 			table: junction,
+			tableName: tableNameOf(junction),
 			sourceColPropName,
 			targetColPropName,
 			sourceCol,
 			targetCol
-		}
+		},
+		targetKeyColumns: { [foreignColPropName]: foreignCol },
+		allowed: /* @__PURE__ */ new Set([
+			"connect",
+			"disconnect",
+			"set"
+		])
 	};
 };
 /**
@@ -5884,7 +5921,7 @@ const buildThroughPlan = (relationName, relation, table, targetTableName, target
 * relations whose join columns cannot be read off the drizzle relation; and relations where
 * neither join column is unique, which leaves no way to tell which side stores the key.
 */
-const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
+const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns, tableNameOf = () => void 0) => {
 	const uniqueCache = /* @__PURE__ */ new Map();
 	const singleColumnUniques = (tableName, table) => {
 		let cached = uniqueCache.get(tableName);
@@ -5913,7 +5950,7 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			const targetTable = tables[targetTableName];
 			if (!targetTable) continue;
 			if (relation.through) {
-				const throughPlan = buildThroughPlan(relationName, relation, table, targetTableName, targetTable);
+				const throughPlan = buildThroughPlan(relationName, relation, table, targetTableName, targetTable, tableNameOf);
 				if (throughPlan) tablePlans[relationName] = throughPlan;
 				continue;
 			}
@@ -5934,6 +5971,10 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			else if (foreignIsUnique) fkSide = "parent";
 			else if (localIsUnique) fkSide = "child";
 			else continue;
+			const fkColumn = fkSide === "child" ? foreignCol : localCol;
+			const targetColumns = getColumns(targetTable);
+			const targetKeyColumns = Object.fromEntries(resolvePrimaryKeys(targetTable).filter((name) => targetColumns[name]).map((name) => [name, targetColumns[name]]));
+			targetKeyColumns[foreignColPropName] = foreignCol;
 			tablePlans[relationName] = {
 				relationName,
 				targetTableName,
@@ -5944,13 +5985,87 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 				localCol,
 				isOne,
 				fkSide,
-				canDetach: !(fkSide === "child" ? foreignCol : localCol).notNull
+				canDetach: !fkColumn.notNull,
+				targetKeyColumns,
+				allowed: new Set(!fkColumn.notNull ? isOne ? [
+					"create",
+					"connect",
+					"disconnect"
+				] : ALL_OPS : ["create", "connect"])
 			};
 		}
 		if (Object.keys(tablePlans).length) plans[tableName] = tablePlans;
 	}
 	return plans;
 };
+/**
+* Which of the target's (or junction's) write features each input of a relation needs. A
+* parent-side `connect` / `disconnect` only rewrites the parent's own column, so it needs
+* nothing of the target; a child-side one moves the target's foreign key, which is an update
+* of the target. A to-one child-side `create` also detaches the row attached before it, when
+* the key is nullable.
+*/
+const requiredWrites = (plan, op) => {
+	if (plan.through) {
+		const junction = plan.through.tableName;
+		if (op === "connect") return [{
+			tableName: junction,
+			feature: "insert"
+		}];
+		if (op === "disconnect") return [{
+			tableName: junction,
+			feature: "delete"
+		}];
+		if (op === "set") return [{
+			tableName: junction,
+			feature: "delete"
+		}, {
+			tableName: junction,
+			feature: "insert"
+		}];
+		return [];
+	}
+	const target = plan.targetTableName;
+	if (op === "create") return plan.fkSide === "child" && plan.isOne && plan.canDetach ? [{
+		tableName: target,
+		feature: "insert"
+	}, {
+		tableName: target,
+		feature: "update"
+	}] : [{
+		tableName: target,
+		feature: "insert"
+	}];
+	return plan.fkSide === "child" ? [{
+		tableName: target,
+		feature: "update"
+	}] : [];
+};
+/**
+* Narrows every plan's `allowed` inputs to the ones whose writes the table they land on
+* permits: its `features.insert` / `update` / `delete`, and for a junction table that it is
+* not excluded. A plan left with nothing is dropped, so its relation field is not generated.
+*
+* Returns one line per input taken out, for the build note.
+*/
+const gateNestedWritePlans = (plans, featureOf, isExcluded) => {
+	const omitted = [];
+	for (const [tableName, tablePlans] of Object.entries(plans)) {
+		for (const [relationName, plan] of Object.entries(tablePlans)) {
+			for (const op of [...plan.allowed]) {
+				const blocked = requiredWrites(plan, op).filter(({ tableName: target, feature }) => target !== void 0 && (isExcluded(target) || !featureOf(target)[feature]));
+				if (blocked.length) {
+					plan.allowed.delete(op);
+					const reasons = blocked.map(({ tableName: target, feature }) => isExcluded(target) ? `${target} is excluded` : `${target}.${feature} is off`);
+					omitted.push(`${tableName}.${relationName}.${op} (${[...new Set(reasons)].join(", ")})`);
+				}
+			}
+			if (!plan.allowed.size) delete tablePlans[relationName];
+		}
+		if (!Object.keys(tablePlans).length) delete plans[tableName];
+	}
+	return omitted;
+};
 const NO_COLUMNS = /* @__PURE__ */ new Set();
 /**
 * Builds the nested-write input types for a schema.
@@ -6005,8 +6120,11 @@ const createNestedWriteTypes = (params) => {
 	*
 	* A many-to-many relation offers no `create`: inserting a row *and* linking it is two
 	* writes to two tables, and the link half is what the relation field is for. Its
-	* `disconnect` and `set` are offered unconditionally, since breaking a link deletes a
+	* `disconnect` and `set` do not depend on nullability, since breaking a link deletes a
 	* junction row rather than nulling a column that might be NOT NULL.
+	*
+	* Each input is also subject to `plan.allowed` — the table it writes has to have that
+	* write turned on (see {@link gateNestedWritePlans}).
 	*/
 	const wrapperType = (tableName, typeName, plan, forUpdate) => {
 		const key = `${tableName}.${plan.relationName}.${forUpdate ? "update" : "create"}`;
@@ -6015,57 +6133,52 @@ const createNestedWriteTypes = (params) => {
 		const filters = targetFilters(plan);
 		const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
 		const fields = {};
+		const offers = (op) => plan.allowed.has(op);
 		if (plan.through) {
-			if (!filters) return;
-			fields["connect"] = {
+			if (filters && offers("connect")) fields["connect"] = {
 				type: listOf(filters),
 				description: `Link every existing ${targetTypeName} row these match. Already-linked rows are left alone.`
 			};
-			if (forUpdate) {
-				fields["disconnect"] = {
-					type: listOf(filters),
-					description: `Unlink every linked ${targetTypeName} row these match, leaving the rows in place`
-				};
-				fields["set"] = {
-					type: listOf(filters),
-					description: `Replace the whole set: unlink everything linked, then link every ${targetTypeName} row these match. \`set: []\` clears the relation. Applied before \`disconnect\` and \`connect\`.`
-				};
-			}
+			if (filters && forUpdate && offers("disconnect")) fields["disconnect"] = {
+				type: listOf(filters),
+				description: `Unlink every linked ${targetTypeName} row these match, leaving the rows in place`
+			};
+			if (filters && forUpdate && offers("set")) fields["set"] = {
+				type: listOf(filters),
+				description: `Replace the whole set: unlink everything linked, then link every ${targetTypeName} row these match. \`set: []\` clears the relation. Applied before \`disconnect\` and \`connect\`.`
+			};
 		} else if (plan.isOne) {
-			fields["create"] = {
+			if (offers("create")) fields["create"] = {
 				type: payloadType(tableName, typeName, plan),
 				description: `Insert a ${targetTypeName} row and attach it`
 			};
-			if (filters) fields["connect"] = {
+			if (filters && offers("connect")) fields["connect"] = {
 				type: filters,
 				description: `Attach the existing ${targetTypeName} row this matches. Must match exactly one row.`
 			};
-			if (forUpdate && plan.canDetach) fields["disconnect"] = {
+			if (forUpdate && offers("disconnect")) fields["disconnect"] = {
 				type: GraphQLBoolean,
 				description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
 			};
 		} else {
-			fields["create"] = {
+			if (offers("create")) fields["create"] = {
 				type: listOf(payloadType(tableName, typeName, plan)),
 				description: `Insert these ${targetTypeName} rows and attach them`
 			};
-			if (filters) {
-				fields["connect"] = {
-					type: listOf(filters),
-					description: `Attach every existing ${targetTypeName} row these match`
-				};
-				if (forUpdate && plan.canDetach) {
-					fields["disconnect"] = {
-						type: listOf(filters),
-						description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
-					};
-					fields["set"] = {
-						type: listOf(filters),
-						description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
-					};
-				}
-			}
+			if (filters && offers("connect")) fields["connect"] = {
+				type: listOf(filters),
+				description: `Attach every existing ${targetTypeName} row these match`
+			};
+			if (filters && forUpdate && offers("disconnect")) fields["disconnect"] = {
+				type: listOf(filters),
+				description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
+			};
+			if (filters && forUpdate && offers("set")) fields["set"] = {
+				type: listOf(filters),
+				description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
+			};
 		}
+		if (!Object.keys(fields).length) return;
 		const type = new GraphQLInputObjectType({
 			name: cacheCtx.typeName({
 				kind: "nestedWriteInput",
@@ -6097,7 +6210,7 @@ const createNestedWriteTypes = (params) => {
 			const tablePlans = plans[tableName];
 			if (!tablePlans) return NO_COLUMNS;
 			const relaxed = /* @__PURE__ */ new Set();
-			for (const plan of Object.values(tablePlans)) if (plan.fkSide === "parent" && !isOptionalOnInsert(plan.localCol)) relaxed.add(plan.localColPropName);
+			for (const plan of Object.values(tablePlans)) if (plan.fkSide === "parent" && (plan.allowed.has("create") || plan.allowed.has("connect")) && !isOptionalOnInsert(plan.localCol)) relaxed.add(plan.localColPropName);
 			return relaxed.size ? relaxed : NO_COLUMNS;
 		}
 	};
@@ -6108,8 +6221,99 @@ const createNestedWriteTypes = (params) => {
 */
 const mergedOps = (entries) => Object.assign({}, ...entries.map((entry) => entry.ops));
 const asArray = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+const supplied = (value) => value !== void 0 && value !== null;
+/**
+* The hook calls one relation field makes. Every step is registered before the field's first
+* statement, so each `before` runs ahead of all of them and each `after` once the last has
+* returned. A table without hooks registers nothing, and its statements run exactly as they
+* did before hooks reached nested writes — no RETURNING clause is added.
+*/
+const createHookSteps = (onWrite, executor, request, parentTable, plan) => {
+	const steps = /* @__PURE__ */ new Map();
+	const keyOf = (op, operation) => `${op}:${operation}`;
+	const payload = (step) => ({
+		table: step.tableName,
+		operation: step.operation,
+		single: plan.isOne,
+		args: request?.args,
+		context: request?.context,
+		info: request?.info,
+		tx: executor,
+		nested: {
+			parentTable,
+			relation: plan.relationName,
+			op: step.op
+		}
+	});
+	return {
+		/** Registers the hook call for `op`'s `operation` statements, if that table has hooks. */
+		add: (op, operation) => {
+			const through = plan.through;
+			const tableName = through ? through.tableName : plan.targetTableName;
+			const hooks = tableName ? onWrite?.(tableName, operation) : void 0;
+			if (!tableName || !hooks || steps.has(keyOf(op, operation))) return;
+			const keyColumns = through ? {
+				[through.sourceColPropName]: through.sourceCol,
+				[through.targetColPropName]: through.targetCol
+			} : { ...plan.targetKeyColumns };
+			steps.set(keyOf(op, operation), {
+				tableName,
+				operation,
+				op,
+				hooks,
+				returning: withHookColumns(hooks, keyColumns).returning,
+				rows: []
+			});
+		},
+		get: (op, operation) => steps.get(keyOf(op, operation)),
+		/** Runs one statement, returning its rows to the step it belongs to when there is one. */
+		run: async (query, op, operation) => {
+			const step = steps.get(keyOf(op, operation));
+			if (!step) {
+				await query;
+				return;
+			}
+			step.rows.push(...await query.returning(step.returning));
+		},
+		before: async () => {
+			for (const step of steps.values()) await runWriteHook(step.hooks, "before", payload(step));
+		},
+		after: async () => {
+			for (const step of steps.values()) await runWriteHook(step.hooks, "after", {
+				...payload(step),
+				rows: step.rows
+			});
+		}
+	};
+};
+/**
+* Registers the hook calls a child-side relation field will make, in the order its
+* statements run, so the `before` hooks fire in that order too. Mirrors the branches of
+* `applyChildSide` and `applyThroughOps` exactly: a step registered for an input that runs no
+* statement would fire with no rows, and one missing would miss them.
+*/
+const registerChildSteps = (steps, plan, op) => {
+	if (plan.through) {
+		if (supplied(op["set"])) {
+			steps.add("set", "delete");
+			steps.add("set", "insert");
+		}
+		if (supplied(op["disconnect"])) steps.add("disconnect", "delete");
+		if (supplied(op["connect"])) steps.add("connect", "insert");
+		return;
+	}
+	if (op["set"] !== void 0) steps.add("set", "update");
+	if (op["disconnect"] !== void 0 && (!plan.isOne || op["disconnect"] === true)) steps.add("disconnect", "update");
+	const attachedBy = attachingOp(op);
+	if (plan.isOne && attachedBy && plan.canDetach && op["set"] === void 0) steps.add(attachedBy, "update");
+	if (op["connect"] !== void 0) steps.add("connect", "update");
+	if (op["create"] !== void 0) steps.add("create", "insert");
+};
+/** The input that attaches a row to a to-one, which detaches whatever was attached before. */
+const attachingOp = (op) => op["connect"] !== void 0 ? "connect" : op["create"] !== void 0 ? "create" : void 0;
 const createNestedWriteRuntime = (params) => {
 	const { plans, filterCtx, policies, contextValues } = params;
+	const onWrite = policies?.onWrite;
 	/**
 	* A `connect` / `disconnect` / `set` operand compiled to SQL. An operand that compiles to
 	* nothing is rejected: `connect: {}` would otherwise attach every row in the table.
@@ -6120,12 +6324,12 @@ const createNestedWriteRuntime = (params) => {
 		return withScope(scope, plan.targetTableName, plan.targetTable, condition);
 	};
 	const assertSingleOperation = (plan, op) => {
-		const supplied = [
+		const given = [
 			"create",
 			"connect",
 			"disconnect"
-		].filter((key) => op[key] !== void 0 && op[key] !== null);
-		if (supplied.length > 1) throw drizzleError(`Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time — it holds a single row.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
+		].filter((key) => supplied(op[key]));
+		if (given.length > 1) throw drizzleError(`Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${given.join(", ")} at a time — it holds a single row.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 	};
 	/** The values the junction stores for the target rows one operand selects. */
 	const selectedTargetKeys = async (executor, plan, filter, operation, scope) => {
@@ -6140,9 +6344,8 @@ const createNestedWriteRuntime = (params) => {
 	* error on some of them — the read and the write share the surrounding transaction, so no
 	* other writer can slip a duplicate in between them.
 	*/
-	const applyThroughOps = async (executor, plan, key, op, scope) => {
+	const applyThroughOps = async (executor, plan, key, op, scope, steps) => {
 		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({ [through.targetColPropName]: through.targetCol }).from(through.table).where(eq(through.sourceCol, key))).map((row) => row[through.targetColPropName]));
 			const rows = [];
@@ -6153,19 +6356,19 @@ const createNestedWriteRuntime = (params) => {
 					[through.targetColPropName]: targetKey
 				});
 			}
-			if (rows.length) await executor.insert(through.table).values(rows);
+			if (rows.length) await steps.run(executor.insert(through.table).values(rows), operation, "insert");
 		};
-		if (op["set"] !== void 0 && op["set"] !== null) {
-			await unlinkAll();
+		if (supplied(op["set"])) {
+			await steps.run(executor.delete(through.table).where(eq(through.sourceCol, key)), "set", "delete");
 			await link(asArray(op["set"]), "set");
 		}
-		if (op["disconnect"] !== void 0 && op["disconnect"] !== null) for (const filter of asArray(op["disconnect"])) {
+		if (supplied(op["disconnect"])) for (const filter of asArray(op["disconnect"])) {
 			const targetKeys = await selectedTargetKeys(executor, plan, filter, "disconnect", scope);
-			if (targetKeys.length) await executor.delete(through.table).where(and(eq(through.sourceCol, key), inArray(through.targetCol, targetKeys)));
+			if (targetKeys.length) await steps.run(executor.delete(through.table).where(and(eq(through.sourceCol, key), inArray(through.targetCol, targetKeys))), "disconnect", "delete");
 		}
-		if (op["connect"] !== void 0 && op["connect"] !== null) await link(asArray(op["connect"]), "connect");
+		if (supplied(op["connect"])) await link(asArray(op["connect"]), "connect");
 	};
-	const detachAll = async (executor, plan, key, scope) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq(plan.foreignCol, key)));
+	const detachAll = (executor, plan, key, scope, steps, op) => steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq(plan.foreignCol, key))), op, "update");
 	return {
 		enabled: (tableName) => !!plans[tableName],
 		split: (tableName, values) => {
@@ -6194,19 +6397,27 @@ const createNestedWriteRuntime = (params) => {
 			}
 			return columns;
 		},
-		applyParentSide: async (executor, tableName, ops, context) => {
+		applyParentSide: async (executor, tableName, ops, request) => {
 			const tablePlans = plans[tableName];
 			const patch = {};
 			if (!tablePlans) return patch;
+			const context = request?.context;
 			const scope = resolveScope(policies, context, filterCtx);
 			for (const [relationName, op] of Object.entries(ops)) {
 				const plan = tablePlans[relationName];
 				if (plan?.fkSide !== "parent") continue;
 				assertSingleOperation(plan, op);
 				if (op["create"] !== void 0) {
+					const steps = createHookSteps(onWrite, executor, request, tableName, plan);
+					steps.add("create", "insert");
+					await steps.before();
 					const values = applyContextValues(remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable), contextValues?.(plan.targetTableName), context);
-					const created = (await executor.insert(plan.targetTable).values(values).returning({ [plan.foreignColPropName]: plan.foreignCol }))[0];
+					const step = steps.get("create", "insert");
+					const inserted = await executor.insert(plan.targetTable).values(values).returning(step ? step.returning : { [plan.foreignColPropName]: plan.foreignCol });
+					step?.rows.push(...inserted);
+					const created = inserted[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" });
+					await steps.after();
 					patch[plan.localColPropName] = created[plan.foreignColPropName];
 				} else if (op["connect"] !== void 0) {
 					const rows = await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
@@ -6216,41 +6427,46 @@ const createNestedWriteRuntime = (params) => {
 			}
 			return patch;
 		},
-		applyChildSide: async (executor, tableName, ops, parentRows, context) => {
+		applyChildSide: async (executor, tableName, ops, parentRows, request) => {
 			const tablePlans = plans[tableName];
 			if (!tablePlans) return;
+			const context = request?.context;
 			const scope = resolveScope(policies, context, filterCtx);
 			for (const [relationName, op] of Object.entries(ops)) {
 				const plan = tablePlans[relationName];
 				if (plan?.fkSide !== "child") continue;
 				if (plan.isOne) assertSingleOperation(plan, op);
+				const steps = createHookSteps(onWrite, executor, request, tableName, plan);
+				registerChildSteps(steps, plan, op);
+				await steps.before();
 				for (const parentRow of parentRows) {
 					const key = parentRow?.[plan.localColPropName];
 					if (key === void 0 || key === null) throw drizzleError(`Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					if (plan.through) {
-						await applyThroughOps(executor, plan, key, op, scope);
+						await applyThroughOps(executor, plan, key, op, scope, steps);
 						continue;
 					}
 					if (op["set"] !== void 0) {
-						await detachAll(executor, plan, key, scope);
-						for (const filter of asArray(op["set"])) await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope));
+						await detachAll(executor, plan, key, scope, steps, "set");
+						for (const filter of asArray(op["set"])) await steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope)), "set", "update");
 					}
 					if (op["disconnect"] !== void 0) {
 						if (plan.isOne) {
-							if (op["disconnect"] === true) await detachAll(executor, plan, key, scope);
-						} else for (const filter of asArray(op["disconnect"])) await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and(eq(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope)));
+							if (op["disconnect"] === true) await detachAll(executor, plan, key, scope, steps, "disconnect");
+						} else for (const filter of asArray(op["disconnect"])) await steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and(eq(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope))), "disconnect", "update");
 					}
-					const attaches = op["connect"] !== void 0 || op["create"] !== void 0;
-					if (plan.isOne && attaches && plan.canDetach && op["set"] === void 0) await detachAll(executor, plan, key, scope);
-					if (op["connect"] !== void 0) for (const filter of asArray(op["connect"])) await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope));
+					const attachedBy = attachingOp(op);
+					if (plan.isOne && attachedBy && plan.canDetach && op["set"] === void 0) await detachAll(executor, plan, key, scope, steps, attachedBy);
+					if (op["connect"] !== void 0) for (const filter of asArray(op["connect"])) await steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope)), "connect", "update");
 					if (op["create"] !== void 0) {
 						const rows = asArray(op["create"]).map((row) => ({
 							...applyContextValues(remapFromGraphQLSingleInput({ ...row }, plan.targetTable), contextValues?.(plan.targetTableName), context),
 							[plan.foreignColPropName]: key
 						}));
-						if (rows.length) await executor.insert(plan.targetTable).values(rows);
+						if (rows.length) await steps.run(executor.insert(plan.targetTable).values(rows), "create", "insert");
 					}
 				}
+				await steps.after();
 			}
 		}
 	};
@@ -6260,21 +6476,25 @@ const createNestedWriteRuntime = (params) => {
 * inside a single transaction — a savepoint when the caller already runs on one, so a failing
 * entry rolls the whole batch back.
 *
+* That transaction is also the `tx` the target tables' `onWrite` hooks run on. Every nested
+* write opens it, so a hook on a nested target has the whole tree to roll back even when the
+* root field carries no hook of its own and was not forced into a transaction for one.
+*
 * Entries are written one at a time rather than as a single multi-row statement: a nested
 * operation attaches to the row its own entry produced, so the two have to stay correlated.
 * The batch path is untouched when no entry carries a nested operation.
 */
 const writeWithNestedOps = async (params) => {
-	const { executor, runtime, tableName, entries, remapValues, write, context } = params;
+	const { executor, runtime, tableName, entries, remapValues, write, request } = params;
 	return executor.transaction(async (tx) => {
 		const rows = [];
 		for (const entry of entries) {
-			const patch = await runtime.applyParentSide(tx, tableName, entry.ops, context);
+			const patch = await runtime.applyParentSide(tx, tableName, entry.ops, request);
 			const written = await write(tx, {
 				...remapValues(entry.columns),
 				...patch
 			});
-			await runtime.applyChildSide(tx, tableName, entry.ops, written, context);
+			await runtime.applyChildSide(tx, tableName, entry.ops, written, request);
 			rows.push(...written);
 		}
 		return rows;
@@ -6286,14 +6506,14 @@ const writeWithNestedOps = async (params) => {
 * attaches to each row that came back.
 */
 const updateWithNestedOps = async (params) => {
-	const { executor, runtime, tableName, columns, ops, remapValues, write, context } = params;
+	const { executor, runtime, tableName, columns, ops, remapValues, write, request } = params;
 	return executor.transaction(async (tx) => {
-		const patch = await runtime.applyParentSide(tx, tableName, ops, context);
+		const patch = await runtime.applyParentSide(tx, tableName, ops, request);
 		const rows = await write(tx, {
 			...remapValues(columns),
 			...patch
 		});
-		await runtime.applyChildSide(tx, tableName, ops, rows, context);
+		await runtime.applyChildSide(tx, tableName, ops, rows, request);
 		return rows;
 	});
 };
@@ -6494,7 +6714,14 @@ const createSchemaBuilder = (adapter) => {
 			uniqueKeysOf: (tableName) => uniqueKeys[tableName]
 		};
 		adapter.preflight?.(db, options);
-		const nestedPlans = features.nestedWrites ? buildNestedWritePlans(tables, namedRelations, (target) => uniqueColumnSets(target), (target) => primaryKeyPropNames(target), extractRelationJoinColumns) : void 0;
+		const nestedPlans = features.nestedWrites ? buildNestedWritePlans(tables, namedRelations, (target) => uniqueColumnSets(target), (target) => primaryKeyPropNames(target), extractRelationJoinColumns, (junction) => schemaEntries.find(([, value]) => value === junction)?.[0]) : void 0;
+		if (nestedPlans) {
+			const omitted = gateNestedWritePlans(nestedPlans, featureOf, (tableName) => excludedTables.has(tableName));
+			if (omitted.length) {
+				const listed = omitted.length > 5 ? `${omitted.slice(0, 5).join(", ")} and ${omitted.length - 5} more` : omitted.join(", ");
+				console.warn(`Drizzle-GraphQL Warning: config.features — nestedWrites leaves out the nested inputs whose table has that write turned off: ${listed}.`);
+			}
+		}
 		const nestedTypes = nestedPlans ? createNestedWriteTypes({
 			plans: nestedPlans,
 			cacheCtx,
@@ -6992,7 +7219,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			fieldName: updateCountFieldName,
 			requireWhere: tableFeatures.requireWhere,
 			filterCtx,
-			txCtx: mutationTxCtx
+			txCtx: mutationTxCtx,
+			policies,
+			returnsRows: false
 		}) : void 0;
 		const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 			db,
@@ -7003,7 +7232,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			fieldName: deleteCountFieldName,
 			requireWhere: tableFeatures.requireWhere,
 			filterCtx,
-			txCtx: mutationTxCtx
+			txCtx: mutationTxCtx,
+			policies,
+			returnsRows: false
 		}) : void 0;
 		const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 		const withMeta = (generated, meta) => ({
@@ -7073,12 +7304,25 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 				{
 					generated: updateCountGenerated,
 					type: new GraphQLNonNull(GraphQLInt),
+					meta: {
+						operation: "update",
+						single: false,
+						targetArg: "where",
+						count: true
+					},
 					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."
+					meta: {
+						operation: "delete",
+						single: false,
+						targetArg: "where",
+						count: true,
+						...hardDeleteMeta
+					},
+					description: "How many rows the delete removed — or, on a soft-deleting table, marked deleted. The rows themselves are not read back, which is the point of this mutation."
 				}
 			],
 			onConflictInput,
@@ -7150,7 +7394,11 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					entries: nestedEntries,
 					remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
 					write: (tx, values) => runInsert(tx, [values]),
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				}) : await runInsert(executor, input);
 				await after(written);
 				const result = output(written);
@@ -7239,7 +7487,11 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					entries: nestedEntries,
 					remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
 					write: (tx, values) => runUpsert(tx, [values]),
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				}) : await runUpsert(executor, input);
 				await after(written);
 				const result = output(written);
@@ -7312,7 +7564,11 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					ops: nestedOps,
 					remapValues: (values) => values,
 					write: runUpdate,
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				}) : await runUpdate(executor, input);
 				await after(written);
 				const result = output(written);
@@ -7579,7 +7835,10 @@ const createSchemaDataGenerator = (adapter) => {
 				requireWhere: tableFeatures.requireWhere,
 				filterCtx,
 				txCtx: mutationTxCtx,
-				nested: nestedRuntime
+				nested: nestedRuntime,
+				policies,
+				pkNames: primaryKeyPropNames(schema[tableName]),
+				returnsRows: true
 			}) : void 0;
 			const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 				db,
@@ -7590,7 +7849,10 @@ const createSchemaDataGenerator = (adapter) => {
 				fieldName: deleteCountFieldName,
 				requireWhere: tableFeatures.requireWhere,
 				filterCtx,
-				txCtx: mutationTxCtx
+				txCtx: mutationTxCtx,
+				policies,
+				pkNames: primaryKeyPropNames(schema[tableName]),
+				returnsRows: true
 			}) : void 0;
 			const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 			return {
@@ -7700,12 +7962,25 @@ const createSchemaDataGenerator = (adapter) => {
 					{
 						generated: updateCountGenerated,
 						type: new GraphQLNonNull(GraphQLInt),
+						meta: {
+							operation: "update",
+							single: false,
+							targetArg: "where",
+							count: true
+						},
 						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."
+						meta: {
+							operation: "delete",
+							single: false,
+							targetArg: "where",
+							count: true,
+							...hardDeleteMeta
+						},
+						description: "How many rows the delete removed — or, on a soft-deleting table, marked deleted. The rows themselves are not read back, which is the point of this mutation."
 					}
 				],
 				onConflictInput,
@@ -7723,18 +7998,18 @@ const createSchemaDataGenerator = (adapter) => {
 * the shared multi-mutation transaction opened by `runMutation` — this opens a savepoint, so
 * the batch stays atomic without breaking the outer transaction.
 */
-const runUpdateManyBatch = ({ executor, entries, table, returning, nested, tableName, context }) => executor.transaction(async (tx) => {
+const runUpdateManyBatch = ({ executor, entries, table, returning, nested, tableName, request }) => executor.transaction(async (tx) => {
 	const results = [];
 	for (const entry of entries) {
 		const values = entry.ops ? {
 			...entry.set,
-			...await nested.applyParentSide(tx, tableName, entry.ops, context)
+			...await nested.applyParentSide(tx, tableName, entry.ops, request)
 		} : entry.set;
 		const writes = Object.keys(values).length > 0;
 		let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
 		if (entry.filters) query = query.where(entry.filters);
 		const rows = await (writes ? query.returning(returning) : query);
-		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, request);
 		results.push(rows);
 	}
 	return results;
@@ -7807,7 +8082,11 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					anyNested,
 					nested,
 					tableName,
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				});
 				const written = perEntry.flat();
 				await after(written);
@@ -7856,7 +8135,7 @@ const sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(ta
 * would run after the COMMIT. The driver kind is probed from the first statement's result
 * rather than declared, so the same resolver serves both driver families.
 */
-const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNested, nested, tableName, context }) => {
+const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNested, nested, tableName, request }) => {
 	const runEntry = (tx, entry) => {
 		let query = tx.update(table).set(entry.set);
 		if (entry.filters) query = query.where(entry.filters);
@@ -7865,13 +8144,13 @@ const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNest
 	const runNestedEntry = async (tx, entry) => {
 		const values = entry.ops ? {
 			...entry.set,
-			...await nested.applyParentSide(tx, tableName, entry.ops, context)
+			...await nested.applyParentSide(tx, tableName, entry.ops, request)
 		} : entry.set;
 		const writes = Object.keys(values).length > 0;
 		let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
 		if (entry.filters) query = query.where(entry.filters);
 		const rows = await (writes ? query.returning(returning) : query);
-		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, request);
 		return rows;
 	};
 	return executor.transaction((tx) => {