@vantreeseba/drizzle-graphql 15.1.3 → 15.1.5

package/dist/index.js

@@ -1778,6 +1778,11 @@ const warnUnresolvedJoin = (relEntry, tableName, relationName, omitted) => {
 * Returns the JS property name of the local column on the parent table and the
 * Column object for the foreign column on the target table, or undefined if the
 * relation internals are not accessible.
+*
+* Only the relation's *first* column pair is reported. A relation joined on several columns
+* (`from: [a, b], to: [x, y]`) is not described fully by it, so anything that reads rows by
+* this pair alone mixes up parents that share the first column. Read paths use
+* {@link extractRelationJoinColumnPairs}, which returns every pair.
 */
 const extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
 	const rel = relEntry.relation ?? relEntry;
@@ -1796,6 +1801,48 @@ const extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
 	};
 };
 /**
+* Every column pair the relation joins on, in declaration order — one for an ordinary relation,
+* several for one declared `from: [a, b], to: [x, y]`. A row of the target belongs to a parent
+* only when *all* pairs match, so a read path has to correlate on every one of them.
+*
+* `undefined` when the relation's columns cannot be matched to the two tables, or when its two
+* sides list a different number of columns.
+*/
+const extractRelationJoinColumnPairs = (relEntry, parentTable, targetTable) => {
+	const rel = relEntry.relation ?? relEntry;
+	const sourceCols = relationColumns(rel, "source");
+	const targetCols = relationColumns(rel, "target");
+	if (!sourceCols?.length || sourceCols.length !== targetCols?.length) return;
+	const parentEntries = Object.entries(getColumns(parentTable));
+	const targetEntries = Object.entries(getColumns(targetTable));
+	const pairs = [];
+	for (let i = 0; i < sourceCols.length; i++) {
+		const localCol = sourceCols[i];
+		const foreignCol = targetCols[i];
+		const localColPropName = parentEntries.find(([, c]) => c === localCol)?.[0];
+		const foreignColPropName = targetEntries.find(([, c]) => c === foreignCol)?.[0];
+		if (!localColPropName || !foreignColPropName) return;
+		pairs.push({
+			localColPropName,
+			localCol,
+			foreignColPropName,
+			foreignCol
+		});
+	}
+	return pairs;
+};
+/**
+* A string identifying one combination of join-column values, for grouping a batch's rows by
+* parent. Values are compared by their string form, as a single-column key always has been.
+*/
+const joinKeyOf = (values) => values.length === 1 ? String(values[0]) : JSON.stringify(values.map((value) => String(value)));
+/**
+* The rows whose `cols` hold one of `keys`: `col IN (…)` for a single join column, and an `OR`
+* of per-parent equalities for several — `(a = 1 AND b = 1) OR (a = 1 AND b = 2)` — which
+* every dialect accepts, unlike a row-value `IN` list.
+*/
+const parentKeyCondition = (cols, keys) => cols.length === 1 ? inArray(cols[0], keys.map((key) => key[0])) : or(...keys.map((key) => and(...cols.map((col, i) => eq(col, key[i])))));
+/**
 * The junction table and its two columns for a `.through()` (many-to-many) relation:
 * `sourceCol` holds the parent's key, `targetCol` the target's. `undefined` for a relation
 * with no junction; `null` for one whose junction cannot be used here — more than one column
@@ -1826,16 +1873,18 @@ const extractJunctionColumns = (relEntry) => {
 *
 * A reversed filter (inherited from the relation on the other side) is written against the
 * parent table, so it is applied as "the row's parent key belongs to a parent that passes it".
-* `parentKeyCol` is the parent's join column and `groupCol` the column in the query that holds
-* the parent key for each row — the target's foreign key, or the junction's source column.
+* `parentKeyCols` are the parent's join columns and `groupCols` the columns in the query that
+* hold the parent key for each row — the target's foreign key, or the junction's source
+* column — in the same order. A key of several columns is compared as a row value.
 */
-const relationOwnCondition = (relEntry, parentTable, targetTable, parentKeyCol, groupCol) => {
+const relationOwnCondition = (relEntry, parentTable, targetTable, parentKeyCols, groupCols) => {
 	const rel = relEntry.relation ?? relEntry;
 	const ownWhere = relationOwnWhere(rel);
 	if (!ownWhere) return;
 	if (!isRelationFilterReversed(rel)) return relationsFilterToSQL(targetTable, ownWhere);
 	const parentFilter = relationsFilterToSQL(parentTable, ownWhere);
-	return sql`${groupCol} in (select ${parentKeyCol} from ${parentTable} where ${parentFilter})`;
+	if (groupCols.length === 1) return sql`${groupCols[0]} in (select ${parentKeyCols[0]} from ${parentTable} where ${parentFilter})`;
+	return sql`(${sql.join([...groupCols], sql`, `)}) in (select ${sql.join([...parentKeyCols], sql`, `)} from ${parentTable} where ${parentFilter})`;
 };
 /**
 * Whether a to-one relation can back a relation orderBy hop. `.through()` (junction)
@@ -3821,8 +3870,7 @@ const relationJoinColumns = (tree, table, selectionCtx) => {
 		const relEntry = fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX) ? relations[fieldData.name.slice(0, -9)] : relations[fieldData.name];
 		const targetTable = relEntry ? selectionCtx.tables[relEntry.targetTableName] : void 0;
 		if (!relEntry || !targetTable) continue;
-		const joinCols = extractRelationJoinColumns(relEntry, table, targetTable);
-		if (joinCols) needed.push(joinCols.localColPropName);
+		for (const pair of extractRelationJoinColumnPairs(relEntry, table, targetTable) ?? []) needed.push(pair.localColPropName);
 	}
 	return needed;
 };
@@ -4843,13 +4891,12 @@ const identifyRows = (field, args) => {
 * Window functions require PostgreSQL, MySQL >= 8.0, or SQLite >= 3.25.
 * Returns raw rows (NOT remapped); the caller groups + remaps them.
 */
-const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs, junction) => {
+const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, partitionCols, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs, junction) => {
 	const cols = columns ?? getColumns(targetTable);
 	const orderExprs = [...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx, whereArgs) : [], ...primaryKeyOrderExprs(targetTable, pkNames)];
 	const orderClause = orderExprs.length ? sql` order by ${sql.join(orderExprs, sql`, `)}` : sql``;
 	const RN = "__drizzle_graphql_rn";
-	const partitionCol = junction ? junction.sourceCol : foreignCol;
-	const rowNumber = sql`row_number() over (partition by ${partitionCol}${orderClause})`.as(RN);
+	const rowNumber = sql`row_number() over (partition by ${sql.join([...partitionCols], sql`, `)}${orderClause})`.as(RN);
 	const sub = withJunction(db.select({
 		...cols,
 		[RN]: rowNumber
@@ -4888,13 +4935,14 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	const targetTableName = relEntry.targetTableName;
 	const targetTable = tables[targetTableName];
 	if (!parentTable || !targetTable) return;
-	const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
-	if (!joinCols) return;
-	const { localColPropName, foreignCol, foreignColPropName } = joinCols;
+	const joinPairs = extractRelationJoinColumnPairs(relEntry, parentTable, targetTable);
+	if (!joinPairs) return;
+	const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+	const foreignCol = joinPairs[0].foreignCol;
 	const junction = extractJunctionColumns(relEntry);
-	const groupCol = junction ? junction.sourceCol : foreignCol;
-	const groupKey = junction ? PARENT_KEY : foreignColPropName;
-	const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, getColumns(parentTable)[localColPropName], groupCol);
+	const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
+	const groupKeys = junction ? [PARENT_KEY] : joinPairs.map((pair) => pair.foreignColPropName);
+	const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, joinPairs.map((pair) => pair.localCol), groupCols);
 	const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, isOne && relEntry.relation?.optional === false);
 	const limitPolicy = isOne ? void 0 : limits?.(targetTableName);
 	const targetPkNames = relEntry.targetPkNames ?? [];
@@ -4923,7 +4971,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			allRelations: filterCtx?.relationMap
 		});
 		const targetColumns = getColumns(targetTable);
-		columns[foreignColPropName] = foreignCol;
+		for (const pair of joinPairs) columns[pair.foreignColPropName] = pair.foreignCol;
 		for (const [columnName] of cursorEntries ?? []) {
 			const column = targetColumns[columnName];
 			if (column) columns[columnName] = column;
@@ -4935,8 +4983,8 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
-		const localValue = parent[localColPropName];
-		if (localValue == null) return isOne ? null : [];
+		const localValues = localColPropNames.map((name) => parent[name]);
+		if (localValues.some((value) => value == null)) return isOne ? null : [];
 		const { where: whereArg, limit: requestedLimit, offset, after, deleted } = args ?? {};
 		const { orderByArg, limit, distinct, cursorEntries, cursorValues, columns, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
 			const orderByArg = isOne ? args?.orderBy : withDefaultOrderBy(args ?? {}, targetTableName, policies?.defaultOrderBy).orderBy;
@@ -4977,11 +5025,11 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			};
 		});
 		if (junction === null) throw drizzleError(`Relation '${tableName}.${relationName}' goes through a junction with a composite key, which can only be loaded together with its parent. Leave it to eager loading (eagerLoadRelations).`, { code: "DRIZZLE_UNSUPPORTED_RELATION" });
-		return getOrCreateLoader(context, loaderKey, async (parentIds) => {
+		return getOrCreateLoader(context, loaderKey, async (parentKeys) => {
 			const executor = resolveExecutor(db, context);
-			const uniqueIds = [...new Set(parentIds)];
+			const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
 			const scope = resolveScope(policies, context, filterCtx);
-			let whereCondition = withScope(scope, targetTableName, targetTable, and(inArray(groupCol, uniqueIds), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0, cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0), deleted ?? defaultDeleted);
+			let whereCondition = withScope(scope, targetTableName, targetTable, and(parentKeyCondition(groupCols, uniqueKeys), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0, cursorValues ? buildCursorCondition(targetTable, cursorEntries, cursorValues, nullOrdering) : void 0), deleted ?? defaultDeleted);
 			if (distinct) {
 				const keys = await selectDistinctKeys({
 					db: executor,
@@ -4991,22 +5039,22 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 					pkNames: targetPkNames,
 					where: whereCondition,
 					orderBy: orderByArg,
-					partitionBy: [groupCol],
+					partitionBy: groupCols,
 					junction: junction ? {
 						table: junction.table,
 						on: eq(junction.targetCol, foreignCol),
-						parentKey: groupCol
+						parentKey: junction.sourceCol
 					} : void 0
 				});
-				if (!keys.length) return parentIds.map(() => isOne ? null : []);
-				whereCondition = and(whereCondition, junction ? or(...keys.map((key) => and(eq(groupCol, key[DISTINCT_PARENT]), primaryKeyRestriction(targetTable, targetPkNames, [key])))) : primaryKeyRestriction(targetTable, targetPkNames, keys));
+				if (!keys.length) return parentKeys.map(() => isOne ? null : []);
+				whereCondition = and(whereCondition, junction ? or(...keys.map((key) => and(eq(junction.sourceCol, key[DISTINCT_PARENT]), primaryKeyRestriction(targetTable, targetPkNames, [key])))) : primaryKeyRestriction(targetTable, targetPkNames, keys));
 			}
 			const selection = junction ? {
 				...columns ?? getColumns(targetTable),
-				[PARENT_KEY]: groupCol
+				[PARENT_KEY]: junction.sourceCol
 			} : columns;
 			let rows;
-			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, selection, relationFilterCtx(filterCtx, targetTableName, scope), whereArg, junction);
+			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, groupCols, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, selection, relationFilterCtx(filterCtx, targetTableName, scope), whereArg, junction);
 			else {
 				let q = withJunction((selection ? executor.select(selection) : executor.select()).from(targetTable), junction, foreignCol).where(whereCondition);
 				const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName, scope), whereArg) : [];
@@ -5015,20 +5063,20 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			}
 			if (cursorEntries) attachRowCursors(rows, cursorEntries);
 			const keyOf = (row) => {
-				const key = String(row[groupKey]);
+				const key = joinKeyOf(groupKeys.map((name) => row[name]));
 				if (junction) delete row[PARENT_KEY];
 				return key;
 			};
 			if (isOne) {
 				const byKey = new Map(rows.map((row) => [keyOf(row), row]));
 				remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
-				return parentIds.map((id) => byKey.get(String(id)) ?? null);
+				return parentKeys.map((key) => byKey.get(joinKeyOf(key)) ?? null);
 			}
-			const grouped = new Map(uniqueIds.map((id) => [String(id), []]));
+			const grouped = new Map(uniqueKeys.map((key) => [joinKeyOf(key), []]));
 			for (const row of rows) grouped.get(keyOf(row))?.push(row);
 			remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
-			return parentIds.map((id) => grouped.get(String(id)) ?? []);
-		}).load(localValue);
+			return parentKeys.map((key) => grouped.get(joinKeyOf(key)) ?? []);
+		}).load(localValues);
 	};
 	return async (parent, args, context, info) => {
 		try {
@@ -6104,8 +6152,8 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 		const targetTableName = relEntry.targetTableName;
 		const targetTable = tables[targetTableName];
 		if (!parentTable || !targetTable) return;
-		const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
-		if (!joinCols) {
+		const joinPairs = extractRelationJoinColumnPairs(relEntry, parentTable, targetTable);
+		if (!joinPairs) {
 			const key = `${tableName}.${relationName}`;
 			if (!warned.has(key)) {
 				warned.add(key);
@@ -6113,11 +6161,13 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 			}
 			return;
 		}
-		const { localColPropName, foreignCol } = joinCols;
+		const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+		const foreignCol = joinPairs[0].foreignCol;
 		const junction = extractJunctionColumns(relEntry);
 		if (junction === null) return;
-		const groupCol = junction ? junction.sourceCol : foreignCol;
-		const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, getColumns(parentTable)[localColPropName], groupCol);
+		const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
+		const groupAliases = groupCols.map((_, i) => `${GROUP_KEY}${i}`);
+		const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, joinPairs.map((pair) => pair.localCol), groupCols);
 		const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, false);
 		const targetTypeName = resolveTypeName(targetTableName, typeNameMapper);
 		const type = generateAggregateTypes(targetTable, targetTableName, targetTypeName, cacheCtx);
@@ -6141,24 +6191,25 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 					};
 				});
 				if (!Object.keys(request.selection).length) return {};
-				const localValue = parent[localColPropName];
-				if (localValue == null) return assembleAggregateRow({}, request, target);
+				const localValues = localColPropNames.map((name) => parent[name]);
+				if (localValues.some((value) => value == null)) return assembleAggregateRow({}, request, target);
 				const whereArg = args?.where;
 				const deleted = args?.deleted;
-				const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
+				const loader = getOrCreateLoader(context, loaderKey, async (parentKeys) => {
 					const executor = resolveExecutor(db, context);
-					const uniqueIds = [...new Set(parentIds)];
+					const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
 					const scope = resolveScope(policies, context, filterCtx);
-					const whereCondition = withScope(scope, targetTableName, targetTable, and(inArray(groupCol, uniqueIds), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0), deleted ?? defaultDeleted);
+					const whereCondition = withScope(scope, targetTableName, targetTable, and(parentKeyCondition(groupCols, uniqueKeys), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0), deleted ?? defaultDeleted);
+					const groupSelection = Object.fromEntries(groupAliases.map((alias, i) => [alias, groupCols[i]]));
 					const selected = executor.select({
-						[GROUP_KEY]: groupCol,
+						...groupSelection,
 						...request.selection
 					}).from(targetTable);
-					const rows = await (junction ? selected.innerJoin(junction.table, eq(junction.targetCol, foreignCol)) : selected).where(whereCondition).groupBy(groupCol);
-					const byKey = new Map(rows.map((row) => [row[GROUP_KEY], row]));
-					return parentIds.map((id) => byKey.get(id) ?? {});
+					const rows = await (junction ? selected.innerJoin(junction.table, eq(junction.targetCol, foreignCol)) : selected).where(whereCondition).groupBy(...groupCols);
+					const byKey = new Map(rows.map((row) => [joinKeyOf(groupAliases.map((alias) => row[alias])), row]));
+					return parentKeys.map((key) => byKey.get(joinKeyOf(key)) ?? {});
 				});
-				return assembleAggregateRow(await loader.load(localValue), request, target);
+				return assembleAggregateRow(await loader.load(localValues), request, target);
 			} catch (e) {
 				throw withErrorContext(toGraphQLError(e), errorCtx);
 			}
@@ -6465,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;
@@ -6485,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;
@@ -6526,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",
@@ -6540,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();
@@ -6573,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);
@@ -6599,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,
@@ -6613,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;
@@ -6692,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.
@@ -6722,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",
@@ -6846,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;
 /**
@@ -6937,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;
@@ -6947,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 = [
@@ -6970,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"])) {
@@ -6994,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) => {
@@ -7021,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 = {};
@@ -7047,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) => {
@@ -7068,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) {
@@ -7081,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");
 					}
 				}
@@ -7097,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
@@ -7115,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;
@@ -7133,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
@@ -7348,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,
@@ -8661,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;
 });
@@ -8802,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 () => {