@vantreeseba/drizzle-graphql 15.1.4 → 15.1.6

package/dist/index.js

@@ -1235,6 +1235,39 @@ const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 	}
 	return value;
 };
+/**
+* Where a remapped row keeps the values its columns held before remapping, by property name —
+* only for the columns remapping changed. The output form is not always reversible: a
+* microsecond timestamp read in `'string'` mode leaves as an ISO string the `DateTime` input
+* side would cut to milliseconds. A relation field correlating on the row's join columns reads
+* them from here (see `parentJoinValues`). Non-enumerable, so the row's own keys, JSON form and
+* equality are unchanged.
+*/
+const RAW_COLUMN_VALUES = Symbol("drizzle-graphql.rawColumnValues");
+/**
+* The value column `key` held in `row` before remapping: `{ found: true, value }` when remapping
+* changed it, `{ found: false }` when it did not (or the row was never remapped), in which case
+* `row[key]` is still the column's own value.
+*/
+const rawColumnValue = (row, key) => {
+	const raw = row[RAW_COLUMN_VALUES];
+	return raw && key in raw ? {
+		found: true,
+		value: raw[key]
+	} : { found: false };
+};
+const keepRawColumnValue = (row, key, value) => {
+	let raw = row[RAW_COLUMN_VALUES];
+	if (!raw) {
+		raw = Object.create(null);
+		Object.defineProperty(row, RAW_COLUMN_VALUES, {
+			value: raw,
+			enumerable: false,
+			configurable: true
+		});
+	}
+	if (!(key in raw)) raw[key] = value;
+};
 const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
 	const columns = getColumns(table);
 	for (const [key, value] of Object.entries(queryOutput)) {
@@ -1252,7 +1285,9 @@ const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap)
 			delete queryOutput[key];
 			continue;
 		}
-		queryOutput[key] = remapToGraphQLCore(key, value, tableName, column, relationMap);
+		const remapped = remapToGraphQLCore(key, value, tableName, column, relationMap);
+		if (column && remapped !== value) keepRawColumnValue(queryOutput, key, value);
+		queryOutput[key] = remapped;
 	}
 	return queryOutput;
 };
@@ -1831,17 +1866,104 @@ const extractRelationJoinColumnPairs = (relEntry, parentTable, targetTable) => {
 	}
 	return pairs;
 };
+/** A decimal written as text, in a form `canonicalDecimal` can normalise. */
+const DECIMAL_TEXT = /^([+-]?)(\d*)(?:\.(\d*))?$/;
+/**
+* Decimal text without the zeros that do not change its value: `1.500` and `01.5` are both
+* `1.5`, as SQL compares them. Anything else (an exponent, `NaN`) is returned unchanged.
+*/
+const canonicalDecimal = (value) => {
+	const match = DECIMAL_TEXT.exec(value);
+	if (!match || !match[2] && !match[3]) return value;
+	const whole = match[2].replace(/^0+(?=\d)/, "") || "0";
+	const fraction = (match[3] ?? "").replace(/0+$/, "");
+	const digits = fraction ? `${whole}.${fraction}` : whole;
+	return match[1] === "-" && digits !== "0" ? `-${digits}` : digits;
+};
+/** An ISO instant without trailing zeros in its fraction: `…:00.100Z` and `…:00.1Z` agree. */
+const trimIsoFraction = (iso) => iso.replace(/(\.\d*?)0+Z$/, "$1Z").replace(/\.Z$/, "Z");
+/**
+* One join value in a form both sides of a relation produce for the same SQL value. The parent's
+* key and a related row's can arrive in different JS forms — a `Date` and the text of the same
+* instant, `1.50` and `1.500` from decimals of different scale — and `String()` would tell them
+* apart (it even drops a `Date`'s milliseconds).
+*/
+const joinValueKey = (value, column) => {
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) return String(value);
+		if (column && isDateOnlyColumn(column)) return dateToCalendarDate(value) ?? value.toISOString();
+		return trimIsoFraction(value.toISOString());
+	}
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("hex");
+	if (typeof value === "string" && column) {
+		if (isMySqlDateTimeStringColumn(column)) return trimIsoFraction(mySqlDateTimeTextToIso(value));
+		if (isPgTimestampStringColumn(column)) return trimIsoFraction(pgTimestampTextToIso(value));
+		if ((column.dataType ?? "") === "string numeric") return canonicalDecimal(value);
+	}
+	return String(value);
+};
 /**
 * 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.
+* parent. `columns` are the columns the values were read from, in the same order: the parent's
+* join columns for a parent key, the target's (or the junction's) for a related row. Values the
+* database compares equal give the same key — see {@link joinValueKey}.
+*/
+const joinKeyOf = (values, columns) => values.length === 1 ? joinValueKey(values[0], columns?.[0]) : JSON.stringify(values.map((value, i) => joinValueKey(value, columns?.[i])));
+/**
+* The parent row's values for the relation's join columns, as the database holds them. The row
+* a relation field resolves under has been remapped to its GraphQL form — a `Date` is an ISO
+* string by then, a `bigint` a decimal string — which can neither be bound back through every
+* column's encoder (SQLite's integer timestamp calls `getTime()` on it) nor be compared with the
+* related rows' decoded values. The values from before remapping are used when the row kept
+* them; otherwise the output form is mapped back the way an input value would be.
+*/
+const parentJoinValues = (parent, pairs) => pairs.map(({ localColPropName, localCol }) => {
+	const raw = rawColumnValue(parent, localColPropName);
+	if (raw.found) return raw.value;
+	const value = parent[localColPropName];
+	if (value == null) return value;
+	try {
+		return remapFromGraphQLCore(value, localCol, localColPropName);
+	} catch {
+		return value;
+	}
+});
+/**
+* At most this many bound parameters for the parent keys of one batched relation query. SQLite
+* accepts 32,766 per statement, Postgres and MySQL 65,535; the rest is left to the request's own
+* filters. A batch with more parents runs as several queries.
+*/
+const MAX_PARENT_KEY_PARAMS = 1e4;
+/**
+* The parent keys of one batch split into the groups each query reads, so that no query binds
+* more than {@link MAX_PARENT_KEY_PARAMS} key values. Every parent lands in exactly one group, so
+* a per-parent result — its rows, its window, its count — is the same whichever query made it.
+*/
+const parentKeyChunks = (keys, width) => {
+	const size = Math.max(1, Math.floor(MAX_PARENT_KEY_PARAMS / Math.max(1, width)));
+	const chunks = [];
+	for (let i = 0; i < keys.length; i += size) chunks.push(keys.slice(i, i + size));
+	return chunks;
+};
+/**
+* `or` over `conditions` as a balanced tree. A flat `a OR b OR c …` is parsed left-deep, and
+* SQLite refuses an expression more than 1,000 levels deep; balanced, a batch of thousands of
+* parents stays a few levels deep.
 */
-const joinKeyOf = (values) => values.length === 1 ? String(values[0]) : JSON.stringify(values.map((value) => String(value)));
+const balancedOr = (conditions) => {
+	if (conditions.length <= 2) return or(...conditions);
+	const middle = Math.ceil(conditions.length / 2);
+	return or(balancedOr(conditions.slice(0, middle)), balancedOr(conditions.slice(middle)));
+};
 /**
 * 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.
+* every dialect accepts, unlike a row-value `IN` list. The `OR` is nested as a balanced tree.
+* Callers split a large batch with {@link parentKeyChunks} first, which keeps either form within
+* the dialects' parameter limits.
 */
-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])))));
+const parentKeyCondition = (cols, keys) => cols.length === 1 ? inArray(cols[0], keys.map((key) => key[0])) : balancedOr(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
@@ -4937,7 +5059,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	if (!parentTable || !targetTable) return;
 	const joinPairs = extractRelationJoinColumnPairs(relEntry, parentTable, targetTable);
 	if (!joinPairs) return;
-	const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+	const localCols = joinPairs.map((pair) => pair.localCol);
 	const foreignCol = joinPairs[0].foreignCol;
 	const junction = extractJunctionColumns(relEntry);
 	const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
@@ -4983,7 +5105,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
-		const localValues = localColPropNames.map((name) => parent[name]);
+		const localValues = parentJoinValues(parent, joinPairs);
 		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}`, () => {
@@ -5027,55 +5149,60 @@ 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 (parentKeys) => {
 			const executor = resolveExecutor(db, context);
-			const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
+			const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key, localCols), key])).values()];
 			const scope = resolveScope(policies, context, filterCtx);
-			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,
-					table: targetTable,
-					tableName: targetTableName,
-					distinct,
-					pkNames: targetPkNames,
-					where: whereCondition,
-					orderBy: orderByArg,
-					partitionBy: groupCols,
-					junction: junction ? {
-						table: junction.table,
-						on: eq(junction.targetCol, foreignCol),
-						parentKey: junction.sourceCol
-					} : void 0
-				});
-				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]: junction.sourceCol
-			} : columns;
-			let rows;
-			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) : [];
-				if (orderExprs.length) q = q.orderBy(...orderExprs);
-				rows = await q;
-			}
-			if (cursorEntries) attachRowCursors(rows, cursorEntries);
-			const keyOf = (row) => {
-				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]));
+			const loadChunk = async (chunkKeys) => {
+				let whereCondition = withScope(scope, targetTableName, targetTable, and(parentKeyCondition(groupCols, chunkKeys), 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,
+						table: targetTable,
+						tableName: targetTableName,
+						distinct,
+						pkNames: targetPkNames,
+						where: whereCondition,
+						orderBy: orderByArg,
+						partitionBy: groupCols,
+						junction: junction ? {
+							table: junction.table,
+							on: eq(junction.targetCol, foreignCol),
+							parentKey: junction.sourceCol
+						} : void 0
+					});
+					if (!keys.length) return /* @__PURE__ */ new Map();
+					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]: junction.sourceCol
+				} : columns;
+				let rows;
+				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) : [];
+					if (orderExprs.length) q = q.orderBy(...orderExprs);
+					rows = await q;
+				}
+				if (cursorEntries) attachRowCursors(rows, cursorEntries);
+				const keyOf = (row) => {
+					const key = joinKeyOf(groupKeys.map((name) => row[name]), groupCols);
+					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 byKey;
+				}
+				const grouped = new Map(chunkKeys.map((key) => [joinKeyOf(key, localCols), []]));
+				for (const row of rows) grouped.get(keyOf(row))?.push(row);
 				remapToGraphQLArrayOutput(rows, targetTableName, targetTable);
-				return parentKeys.map((key) => byKey.get(joinKeyOf(key)) ?? null);
-			}
-			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 parentKeys.map((key) => grouped.get(joinKeyOf(key)) ?? []);
+				return grouped;
+			};
+			const results = /* @__PURE__ */ new Map();
+			for (const chunk of parentKeyChunks(uniqueKeys, groupCols.length)) for (const [key, value] of await loadChunk(chunk)) results.set(key, value);
+			return parentKeys.map((key) => results.get(joinKeyOf(key, localCols)) ?? (isOne ? null : []));
 		}).load(localValues);
 	};
 	return async (parent, args, context, info) => {
@@ -6161,7 +6288,7 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 			}
 			return;
 		}
-		const localColPropNames = joinPairs.map((pair) => pair.localColPropName);
+		const localCols = joinPairs.map((pair) => pair.localCol);
 		const foreignCol = joinPairs[0].foreignCol;
 		const junction = extractJunctionColumns(relEntry);
 		if (junction === null) return;
@@ -6191,23 +6318,26 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 					};
 				});
 				if (!Object.keys(request.selection).length) return {};
-				const localValues = localColPropNames.map((name) => parent[name]);
+				const localValues = parentJoinValues(parent, joinPairs);
 				if (localValues.some((value) => value == null)) return assembleAggregateRow({}, request, target);
 				const whereArg = args?.where;
 				const deleted = args?.deleted;
 				const loader = getOrCreateLoader(context, loaderKey, async (parentKeys) => {
 					const executor = resolveExecutor(db, context);
-					const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key), key])).values()];
+					const uniqueKeys = [...new Map(parentKeys.map((key) => [joinKeyOf(key, localCols), key])).values()];
 					const scope = resolveScope(policies, context, filterCtx);
-					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({
-						...groupSelection,
-						...request.selection
-					}).from(targetTable);
-					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)) ?? {});
+					const byKey = /* @__PURE__ */ new Map();
+					for (const chunk of parentKeyChunks(uniqueKeys, groupCols.length)) {
+						const whereCondition = withScope(scope, targetTableName, targetTable, and(parentKeyCondition(groupCols, chunk), ownCondition, whereArg ? extractFilters(targetTable, targetTableName, whereArg, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0), deleted ?? defaultDeleted);
+						const selected = executor.select({
+							...groupSelection,
+							...request.selection
+						}).from(targetTable);
+						const rows = await (junction ? selected.innerJoin(junction.table, eq(junction.targetCol, foreignCol)) : selected).where(whereCondition).groupBy(...groupCols);
+						for (const row of rows) byKey.set(joinKeyOf(groupAliases.map((alias) => row[alias]), groupCols), row);
+					}
+					return parentKeys.map((key) => byKey.get(joinKeyOf(key, localCols)) ?? {});
 				});
 				return assembleAggregateRow(await loader.load(localValues), request, target);
 			} catch (e) {
@@ -6516,6 +6646,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 +6680,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 +6721,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 +6736,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 +6770,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 +6797,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 +6818,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 +6895,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 +6954,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 +7079,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 +7172,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 +7184,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 +7207,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 +7233,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 +7260,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 +7302,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 +7324,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 +7338,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 +7358,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 +7409,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 +7432,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 +7649,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,
@@ -8170,7 +8424,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 						serverOwned: Object.keys(contextColumns ?? {}),
 						buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName, scope))
 					});
-					const runBatch = async (executor, { values: rows, plan }) => {
+					const batchQuery = (executor, { values: rows, plan }) => {
 						let query = executor.insert(table).values(rows).returning(returning);
 						const setWhere = withScope(scope, tableName, table, plan.setWhere);
 						query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? {
@@ -8182,12 +8436,22 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 							set: plan.set,
 							setWhere
 						});
-						return await query;
+						return query;
 					};
-					if (batches.length === 1) return runBatch(target, batches[0]);
-					return target.transaction(async (tx) => {
-						const rows = [];
-						for (const batch of batches) rows.push(...await runBatch(tx, batch));
+					if (batches.length === 1) return await batchQuery(target, batches[0]);
+					return target.transaction((tx) => {
+						const execute = (batch) => {
+							const query = batchQuery(tx, batch);
+							return typeof query.all === "function" ? query.all() : query;
+						};
+						const first = execute(batches[0]);
+						if (typeof first?.then === "function") return (async () => {
+							const rows = [...await first];
+							for (const batch of batches.slice(1)) rows.push(...await execute(batch));
+							return rows;
+						})();
+						const rows = [...first];
+						for (const batch of batches.slice(1)) rows.push(...execute(batch));
 						return rows;
 					});
 				};
@@ -8712,16 +8976,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 +9125,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 () => {