@vantreeseba/drizzle-graphql 15.1.4 → 15.1.5

package/dist/index.d.cts

@@ -1548,8 +1548,15 @@ type SchemaFeatures = {
    *   relation left with no input loses its field.
    * - **`onWrite`** — the hooks of the table a nested statement writes fire on the same `tx`,
    *   with `payload.nested` set. See {@link BuildSchemaConfig.onWrite}.
-   * - **`scope`** and **`contextValues`** — `connect` / `disconnect` / `set` reach only
-   *   in-scope rows, and a nested `create` is stamped like any insert.
+   * - **`scope`**, **`softDelete`** and **`contextValues`** — `connect` / `disconnect` / `set`
+   *   reach only in-scope, unmarked rows (a many-to-many `set` keeps the links it cannot
+   *   reach), and a nested `create` is stamped like any insert. A relation whose foreign key
+   *   is a `contextValues` column is not offered at all.
+   *
+   * A relation's own `where` limits the rows its writes reach the same way, and takes its
+   * `create` away. A relation joining on more than one column per side is not offered. A
+   * to-one `connect` must match exactly one row. When the parent write produces no row, a
+   * parent-side `create` made for it is rolled back.
    *
    * PostgreSQL and SQLite only. MySQL cannot return the rows it just wrote, which is how a
    * nested write learns the parent's key, so `buildSchema` rejects the flag there. On SQLite
@@ -2136,6 +2143,8 @@ type BuildSchemaConfig = {
    * - Every insert stamps it, including the rows created by a nested `create`.
    * - Updates never write it: an update cannot hand a row to another owner. That includes
    *   the conflict branch of an upsert, whose `onConflict.update` does not offer it.
+   * - With `nestedWrites`, a relation whose foreign key is such a column gets no nested-write
+   *   field, since every nested operation on it would write the column.
    * - Keyed by the Drizzle schema key, then by the column's property name (not its database
    *   name), the same keying {@link BuildSchemaConfig.exclude} uses.
    */

package/dist/index.d.ts

@@ -1548,8 +1548,15 @@ type SchemaFeatures = {
    *   relation left with no input loses its field.
    * - **`onWrite`** — the hooks of the table a nested statement writes fire on the same `tx`,
    *   with `payload.nested` set. See {@link BuildSchemaConfig.onWrite}.
-   * - **`scope`** and **`contextValues`** — `connect` / `disconnect` / `set` reach only
-   *   in-scope rows, and a nested `create` is stamped like any insert.
+   * - **`scope`**, **`softDelete`** and **`contextValues`** — `connect` / `disconnect` / `set`
+   *   reach only in-scope, unmarked rows (a many-to-many `set` keeps the links it cannot
+   *   reach), and a nested `create` is stamped like any insert. A relation whose foreign key
+   *   is a `contextValues` column is not offered at all.
+   *
+   * A relation's own `where` limits the rows its writes reach the same way, and takes its
+   * `create` away. A relation joining on more than one column per side is not offered. A
+   * to-one `connect` must match exactly one row. When the parent write produces no row, a
+   * parent-side `create` made for it is rolled back.
    *
    * PostgreSQL and SQLite only. MySQL cannot return the rows it just wrote, which is how a
    * nested write learns the parent's key, so `buildSchema` rejects the flag there. On SQLite
@@ -2136,6 +2143,8 @@ type BuildSchemaConfig = {
    * - Every insert stamps it, including the rows created by a nested `create`.
    * - Updates never write it: an update cannot hand a row to another owner. That includes
    *   the conflict branch of an upsert, whose `onConflict.update` does not offer it.
+   * - With `nestedWrites`, a relation whose foreign key is such a column gets no nested-write
+   *   field, since every nested operation on it would write the column.
    * - Keyed by the Drizzle schema key, then by the column's property name (not its database
    *   name), the same keying {@link BuildSchemaConfig.exclude} uses.
    */

package/dist/index.js

@@ -6516,6 +6516,20 @@ const ALL_OPS = [
 * accepts NULL.
 */
 const isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault || !!column.defaultFn;
+/**
+* The plan fields that carry a relation's own `where` (see {@link relationOwnCondition}).
+*
+* A `where` on the target narrows every row selection the write makes, and takes `create`
+* away: the row it inserts is attached whether or not it satisfies the `where`, so the
+* relation could come back without it. A `where` inherited from the reverse relation filters
+* the parent instead, and becomes a per-parent check.
+*/
+const ownWherePlan = (relEntry, parentTable, targetTable, localCol) => {
+	const condition = () => relationOwnCondition(relEntry, parentTable, targetTable, [localCol], [localCol]);
+	if (!condition()) return {};
+	if (!isRelationFilterReversed(relEntry.relation ?? relEntry)) return { ownCondition: () => condition() };
+	return { parentShows: async (executor, key) => (await executor.select({ key: localCol }).from(parentTable).where(and(eq(localCol, key), condition())).limit(1)).length > 0 };
+};
 /** The property name a column is stored under on its table, matched by identity. */
 const propNameOf = (table, column) => {
 	if (!column) return;
@@ -6536,7 +6550,7 @@ const propNameOf = (table, column) => {
 * `onUnresolved` is called when the relation's columns are of a supported shape but cannot be
 * matched to the three tables — a drizzle-orm mismatch rather than an unsupported relation.
 */
-const buildThroughPlan = (relationName, relation, table, targetTableName, targetTable, tableNameOf, onUnresolved) => {
+const buildThroughPlan = (relationName, relEntry, relation, table, targetTableName, targetTable, tableNameOf, onUnresolved) => {
 	if (is(relation, One)) return;
 	const junction = relation.throughTable;
 	const sourceEntries = relation.through?.source;
@@ -6577,6 +6591,7 @@ const buildThroughPlan = (relationName, relation, table, targetTableName, target
 			targetCol
 		},
 		targetKeyColumns: { [foreignColPropName]: foreignCol },
+		...ownWherePlan(relEntry, table, targetTable, localCol),
 		allowed: /* @__PURE__ */ new Set([
 			"connect",
 			"disconnect",
@@ -6591,8 +6606,9 @@ const buildThroughPlan = (relationName, relation, table, targetTableName, target
 * rather than a foreign-key one — see {@link buildThroughPlan}.
 *
 * Skipped, and so absent from the generated inputs rather than failing at runtime:
-* 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.
+* relations whose join columns cannot be read off the drizzle relation; relations joining on
+* more than one column per side; 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, tableNameOf = () => void 0) => {
 	const uniqueCache = /* @__PURE__ */ new Map();
@@ -6624,10 +6640,11 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			if (!targetTable) continue;
 			const omitted = `the '${relationName}' field of its nested-write create and update inputs`;
 			if (relation.through) {
-				const throughPlan = buildThroughPlan(relationName, relation, table, targetTableName, targetTable, tableNameOf, () => warnUnresolvedJoin(relEntry, tableName, relationName, omitted));
+				const throughPlan = buildThroughPlan(relationName, relEntry, relation, table, targetTableName, targetTable, tableNameOf, () => warnUnresolvedJoin(relEntry, tableName, relationName, omitted));
 				if (throughPlan) tablePlans[relationName] = throughPlan;
 				continue;
 			}
+			if ((relationColumns(relation, "source")?.length ?? 0) > 1 || (relationColumns(relation, "target")?.length ?? 0) > 1) continue;
 			const joinColumns = extractJoinColumns(relEntry, table, targetTable);
 			if (!joinColumns) {
 				warnUnresolvedJoin(relEntry, tableName, relationName, omitted);
@@ -6650,8 +6667,15 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			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]]));
+			const targetPrimaryKey = resolvePrimaryKeys(targetTable).filter((name) => targetColumns[name]);
+			const targetKeyColumns = Object.fromEntries(targetPrimaryKey.map((name) => [name, targetColumns[name]]));
 			targetKeyColumns[foreignColPropName] = foreignCol;
+			const ownWhere = ownWherePlan(relEntry, table, targetTable, localCol);
+			const ops = !fkColumn.notNull ? isOne ? [
+				"create",
+				"connect",
+				"disconnect"
+			] : ALL_OPS : ["create", "connect"];
 			tablePlans[relationName] = {
 				relationName,
 				targetTableName,
@@ -6664,11 +6688,9 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 				fkSide,
 				canDetach: !fkColumn.notNull,
 				targetKeyColumns,
-				allowed: new Set(!fkColumn.notNull ? isOne ? [
-					"create",
-					"connect",
-					"disconnect"
-				] : ALL_OPS : ["create", "connect"])
+				targetPrimaryKey,
+				...ownWhere,
+				allowed: new Set(ownWhere.ownCondition ? ops.filter((op) => op !== "create") : ops)
 			};
 		}
 		if (Object.keys(tablePlans).length) plans[tableName] = tablePlans;
@@ -6743,6 +6765,35 @@ const gateNestedWritePlans = (plans, featureOf, isExcluded) => {
 	}
 	return omitted;
 };
+/**
+* Takes out every relation whose foreign key is a `contextValues` column of the table storing
+* it — the parent's own column for a parent-side relation, the target's for a child-side one,
+* either junction column for a many-to-many.
+*
+* Every operation on such a relation writes that column: `connect`, `disconnect` and `set`
+* by definition, and a child-side `create` too, since it fills the key in from the parent row
+* rather than from context. That column is the server's to set — an insert stamps it and an
+* update never touches it — so writing it from a nested input would let a client pick, or
+* change, the owner the server assigns. Whole relations are dropped, not single inputs: no
+* operation on them is left that does not write the key.
+*
+* Returns one line per relation taken out, for the build note.
+*/
+const dropContextValueRelations = (plans, contextValuesOf) => {
+	const omitted = [];
+	if (!contextValuesOf) return omitted;
+	for (const [tableName, tablePlans] of Object.entries(plans)) {
+		for (const [relationName, plan] of Object.entries(tablePlans)) {
+			const stamped = (plan.through ? [[plan.through.tableName, plan.through.sourceColPropName], [plan.through.tableName, plan.through.targetColPropName]] : plan.fkSide === "parent" ? [[tableName, plan.localColPropName]] : [[plan.targetTableName, plan.foreignColPropName]]).find(([owner, column]) => owner !== void 0 && contextValuesOf(owner)?.[column]);
+			if (stamped) {
+				delete tablePlans[relationName];
+				omitted.push(`${tableName}.${relationName} (${stamped[0]}.${stamped[1]} is a contextValues column)`);
+			}
+		}
+		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.
@@ -6773,7 +6824,8 @@ const createNestedWriteTypes = (params) => {
 		if (cached) return cached;
 		const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
 		const contextColumns = cacheCtx.contextValuesOf?.(plan.targetTableName);
-		const fields = Object.fromEntries(Object.entries(visibleColumns(plan.targetTable)).filter(([columnName]) => columnName !== omitted && !contextColumns?.[columnName]).map(([columnName, column]) => [columnName, drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)]));
+		const markerColumn = cacheCtx.softDeleteOf?.(plan.targetTableName)?.columnName;
+		const fields = Object.fromEntries(Object.entries(visibleColumns(plan.targetTable)).filter(([columnName]) => columnName !== omitted && !contextColumns?.[columnName] && columnName !== markerColumn).map(([columnName, column]) => [columnName, drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)]));
 		const type = new GraphQLInputObjectType({
 			name: cacheCtx.typeName({
 				kind: "nestedWriteInput",
@@ -6897,6 +6949,8 @@ const createNestedWriteTypes = (params) => {
 * join columns the whole batch's RETURNING clause needs, without inspecting each row's write.
 */
 const mergedOps = (entries) => Object.assign({}, ...entries.map((entry) => entry.ops));
+/** A to-one `connect` whose filter did not match exactly one row. */
+const connectMatchError = (relationName, matched) => drizzleError(`Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${matched} rows — it attaches a single row, so its filter must match exactly one.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 const asArray = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
 const supplied = (value) => value !== void 0 && value !== null;
 /**
@@ -6988,6 +7042,8 @@ const registerChildSteps = (steps, plan, op) => {
 };
 /** 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;
+/** The child-side relation in `ops` whose target is the parent's own table, if there is one. */
+const selfTargetingPlan = (tablePlans, tableName, ops) => Object.keys(ops).map((relationName) => tablePlans?.[relationName]).find((plan) => plan?.fkSide === "child" && !plan.through && plan.targetTableName === tableName);
 const createNestedWriteRuntime = (params) => {
 	const { plans, filterCtx, policies, contextValues } = params;
 	const onWrite = policies?.onWrite;
@@ -6998,7 +7054,7 @@ const createNestedWriteRuntime = (params) => {
 	const conditionOf = (plan, filter, operation, scope) => {
 		const condition = extractFilters(plan.targetTable, plan.targetTableName, filter, relationFilterCtx(filterCtx, plan.targetTableName, scope));
 		if (!condition) throw drizzleError(`Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows — it was given one that matches everything.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
-		return withScope(scope, plan.targetTableName, plan.targetTable, condition);
+		return withScope(scope, plan.targetTableName, plan.targetTable, and(condition, plan.ownCondition?.()));
 	};
 	const assertSingleOperation = (plan, op) => {
 		const given = [
@@ -7021,22 +7077,24 @@ 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, steps) => {
+	const applyThroughOps = async (executor, plan, key, op, scope, steps, context) => {
 		const through = plan.through;
 		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 = [];
 			for (const filter of operands) for (const targetKey of await selectedTargetKeys(executor, plan, filter, operation, scope)) if (!existing.has(targetKey)) {
 				existing.add(targetKey);
-				rows.push({
+				rows.push(applyContextValues({
 					[through.sourceColPropName]: key,
 					[through.targetColPropName]: targetKey
-				});
+				}, through.tableName ? contextValues?.(through.tableName) : void 0, context));
 			}
 			if (rows.length) await steps.run(executor.insert(through.table).values(rows), operation, "insert");
 		};
 		if (supplied(op["set"])) {
-			await steps.run(executor.delete(through.table).where(eq(through.sourceCol, key)), "set", "delete");
+			const reachable = withScope(scope, plan.targetTableName, plan.targetTable, plan.ownCondition?.());
+			const unlink = reachable ? and(eq(through.sourceCol, key), inArray(through.targetCol, executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(reachable))) : eq(through.sourceCol, key);
+			await steps.run(executor.delete(through.table).where(unlink), "set", "delete");
 			await link(asArray(op["set"]), "set");
 		}
 		if (supplied(op["disconnect"])) for (const filter of asArray(op["disconnect"])) {
@@ -7045,7 +7103,7 @@ const createNestedWriteRuntime = (params) => {
 		}
 		if (supplied(op["connect"])) await link(asArray(op["connect"]), "connect");
 	};
-	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");
+	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, and(eq(plan.foreignCol, key), plan.ownCondition?.()))), op, "update");
 	return {
 		enabled: (tableName) => !!plans[tableName],
 		split: (tableName, values) => {
@@ -7072,8 +7130,24 @@ const createNestedWriteRuntime = (params) => {
 				const plan = tablePlans[relationName];
 				if (plan?.fkSide === "child" && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) columns[plan.localColPropName] = allColumns[plan.localColPropName];
 			}
+			for (const name of selfTargetingPlan(tablePlans, tableName, ops)?.targetPrimaryKey ?? []) if (!(name in columns) && allColumns[name]) columns[name] = allColumns[name];
 			return columns;
 		},
+		createsParentSide: (tableName, ops) => Object.entries(ops).some(([relationName, op]) => plans[tableName]?.[relationName]?.fkSide === "parent" && supplied(op?.["create"])),
+		refreshed: async (executor, tableName, ops, rows) => {
+			const plan = selfTargetingPlan(plans[tableName], tableName, ops);
+			const pk = plan?.targetPrimaryKey ?? [];
+			if (!plan || !pk.length || !rows.length || !pk.every((name) => name in rows[0])) return rows;
+			const columns = getColumns(plan.targetTable);
+			const selection = Object.fromEntries(Object.keys(rows[0]).filter((name) => columns[name]).map((name) => [name, columns[name]]));
+			const keyOf = (row) => pk.map((name) => String(row[name])).join("\0");
+			const match = pk.length === 1 ? inArray(columns[pk[0]], rows.map((row) => row[pk[0]])) : or(...rows.map((row) => and(...pk.map((name) => eq(columns[name], row[name])))));
+			const fresh = new Map((await executor.select(selection).from(plan.targetTable).where(match)).map((row) => [keyOf(row), row]));
+			return rows.map((row) => ({
+				...row,
+				...fresh.get(keyOf(row))
+			}));
+		},
 		applyParentSide: async (executor, tableName, ops, request) => {
 			const tablePlans = plans[tableName];
 			const patch = {};
@@ -7098,10 +7172,11 @@ const createNestedWriteRuntime = (params) => {
 					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));
-					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" });
+					if (rows.length !== 1) throw connectMatchError(relationName, rows.length);
 					patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
 				} else if (op["disconnect"] === true) patch[plan.localColPropName] = null;
 			}
+			for (const columnName of Object.keys(contextValues?.(tableName) ?? {})) delete patch[columnName];
 			return patch;
 		},
 		applyChildSide: async (executor, tableName, ops, parentRows, request) => {
@@ -7119,8 +7194,9 @@ const createNestedWriteRuntime = (params) => {
 				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.parentShows && !await plan.parentShows(executor, key)) throw drizzleError(`Drizzle-GraphQL Error: cannot write through '${relationName}': its \`where\` hides the relation on this ${tableName} row.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					if (plan.through) {
-						await applyThroughOps(executor, plan, key, op, scope, steps);
+						await applyThroughOps(executor, plan, key, op, scope, steps, context);
 						continue;
 					}
 					if (op["set"] !== void 0) {
@@ -7132,14 +7208,18 @@ const createNestedWriteRuntime = (params) => {
 							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");
 					}
+					if (plan.isOne && op["connect"] !== void 0) {
+						const matched = await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
+						if (matched.length !== 1) throw connectMatchError(relationName, matched.length);
+					}
 					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),
+						const rows = asArray(op["create"]).map((row) => applyContextValues({
+							...remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
 							[plan.foreignColPropName]: key
-						}));
+						}, contextValues?.(plan.targetTableName), context));
 						if (rows.length) await steps.run(executor.insert(plan.targetTable).values(rows), "create", "insert");
 					}
 				}
@@ -7148,6 +7228,39 @@ const createNestedWriteRuntime = (params) => {
 		}
 	};
 };
+/** Thrown inside an entry's savepoint to undo a parent-side `create` whose parent was never written. */
+var NoParentRow = class extends Error {};
+/**
+* One parent write with its nested operations around it: the parent-side operations, whose
+* values `write` receives as a patch, then the write, then the child-side operations — and
+* the rows it returns read back when a child-side statement may have changed them.
+*
+* A parent write can come back empty: an update whose `where` matched nothing, an insert or
+* upsert that a conflict turned into a no-op. Anything a parent-side `create` inserted would
+* then be left with nothing pointing at it, so such an entry runs in a savepoint of its own
+* that is rolled back when the write produced no row, and the entry returns no rows — as it
+* would have without the nested operation. The rest of the batch is unaffected.
+*
+* `executor` must already be a transaction.
+*/
+const writeNestedEntry = async (params) => {
+	const { executor, runtime, tableName, ops, write, request } = params;
+	const guarded = runtime.createsParentSide(tableName, ops);
+	const run = async (tx) => {
+		const patch = await runtime.applyParentSide(tx, tableName, ops, request);
+		const rows = await write(tx, patch);
+		if (guarded && !rows.length) throw new NoParentRow();
+		await runtime.applyChildSide(tx, tableName, ops, rows, request);
+		return runtime.refreshed(tx, tableName, ops, rows);
+	};
+	if (!guarded) return run(executor);
+	try {
+		return await executor.transaction(run);
+	} catch (error) {
+		if (error instanceof NoParentRow) return [];
+		throw error;
+	}
+};
 /**
 * Runs one parent write per input entry, with that entry's nested operations around it, all
 * inside a single transaction — a savepoint when the caller already runs on one, so a failing
@@ -7166,12 +7279,17 @@ const writeWithNestedOps = async (params) => {
 	return executor.transaction(async (tx) => {
 		const rows = [];
 		for (const entry of entries) {
-			const patch = await runtime.applyParentSide(tx, tableName, entry.ops, request);
-			const written = await write(tx, {
-				...remapValues(entry.columns),
-				...patch
+			const written = await writeNestedEntry({
+				executor: tx,
+				runtime,
+				tableName,
+				ops: entry.ops,
+				write: (target, patch) => write(target, {
+					...remapValues(entry.columns),
+					...patch
+				}),
+				request
 			});
-			await runtime.applyChildSide(tx, tableName, entry.ops, written, request);
 			rows.push(...written);
 		}
 		return rows;
@@ -7184,15 +7302,17 @@ const writeWithNestedOps = async (params) => {
 */
 const updateWithNestedOps = async (params) => {
 	const { executor, runtime, tableName, columns, ops, remapValues, write, request } = params;
-	return executor.transaction(async (tx) => {
-		const patch = await runtime.applyParentSide(tx, tableName, ops, request);
-		const rows = await write(tx, {
+	return executor.transaction((tx) => writeNestedEntry({
+		executor: tx,
+		runtime,
+		tableName,
+		ops,
+		write: (target, patch) => write(target, {
 			...remapValues(columns),
 			...patch
-		});
-		await runtime.applyChildSide(tx, tableName, ops, rows, request);
-		return rows;
-	});
+		}),
+		request
+	}));
 };
 //#endregion
 //#region src/util/builders/errors.ts
@@ -7399,6 +7519,10 @@ const createSchemaBuilder = (adapter) => {
 				console.warn(`Drizzle-GraphQL Warning: config.features — nestedWrites leaves out the nested inputs whose table has that write turned off: ${listed}.`);
 			}
 		}
+		if (nestedPlans) {
+			const omitted = dropContextValueRelations(nestedPlans, contextValuesOf);
+			if (omitted.length) console.warn(`Drizzle-GraphQL Warning: config.contextValues — nestedWrites leaves out the relations whose foreign key the server stamps from context: ${omitted.join(", ")}.`);
+		}
 		const nestedTypes = nestedPlans ? createNestedWriteTypes({
 			plans: nestedPlans,
 			cacheCtx,
@@ -8712,16 +8836,24 @@ const createSchemaDataGenerator = (adapter) => {
 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, 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, request);
-		results.push(rows);
+		const write = async (target, patch) => {
+			const values = {
+				...entry.set,
+				...patch
+			};
+			const writes = Object.keys(values).length > 0;
+			let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
+			if (entry.filters) query = query.where(entry.filters);
+			return await (writes ? query.returning(returning) : query);
+		};
+		results.push(entry.ops ? await writeNestedEntry({
+			executor: tx,
+			runtime: nested,
+			tableName,
+			ops: entry.ops,
+			write,
+			request
+		}) : await write(tx, {}));
 	}
 	return results;
 });
@@ -8853,16 +8985,24 @@ const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNest
 		return query.returning(returning).all();
 	};
 	const runNestedEntry = async (tx, entry) => {
-		const values = entry.ops ? {
-			...entry.set,
-			...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, request);
-		return rows;
+		const write = async (target, patch) => {
+			const values = {
+				...entry.set,
+				...patch
+			};
+			const writes = Object.keys(values).length > 0;
+			let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
+			if (entry.filters) query = query.where(entry.filters);
+			return await (writes ? query.returning(returning) : query);
+		};
+		return entry.ops ? writeNestedEntry({
+			executor: tx,
+			runtime: nested,
+			tableName,
+			ops: entry.ops,
+			write,
+			request
+		}) : write(tx, {});
 	};
 	return executor.transaction((tx) => {
 		if (anyNested) return (async () => {