@vantreeseba/drizzle-graphql 13.1.1 → 14.0.0

package/dist/index.js

@@ -5227,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);
@@ -5833,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.
@@ -5861,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;
@@ -5892,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"
+		])
 	};
 };
 /**
@@ -5909,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);
@@ -5938,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;
 			}
@@ -5959,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,
@@ -5969,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.
@@ -6030,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"}`;
@@ -6040,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",
@@ -6122,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;
 		}
 	};
@@ -6133,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.
@@ -6145,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) => {
@@ -6165,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 = [];
@@ -6178,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) => {
@@ -6219,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));
@@ -6241,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();
 			}
 		}
 	};
@@ -6285,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;
@@ -6311,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;
 	});
 };
@@ -6519,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,
@@ -7192,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);
@@ -7281,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);
@@ -7354,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);
@@ -7784,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;
@@ -7868,7 +8082,11 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					anyNested,
 					nested,
 					tableName,
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				});
 				const written = perEntry.flat();
 				await after(written);
@@ -7917,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);
@@ -7926,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) => {