@vantreeseba/drizzle-graphql 13.1.1 → 15.0.0

package/dist/index.js

@@ -1,9 +1,9 @@
 import { Column, One, SQL, Table, aliasedTable, and, arrayContains, arrayOverlaps, asc, avg, count, countDistinct, desc, eq, extractExtendedColumnType, getColumns, getTableAsAliasSQL, gt, gte, ilike, inArray, is, isNotNull, isNull, like, lt, lte, max, min, ne, not, notIlike, notInArray, notLike, or, relationsFilterToSQL, sql, sum } from "drizzle-orm";
-import { MySqlAsyncDatabase, MySqlInt, MySqlSerial, MySqlTable, getTableConfig } from "drizzle-orm/mysql-core";
+import { MySqlAsyncDatabase, MySqlDate, MySqlDateString, MySqlDateTime, MySqlDateTimeString, MySqlInt, MySqlSerial, MySqlTable, MySqlTimestamp, MySqlTimestampString, getTableConfig } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase, PgDate, PgDateString, PgInteger, PgSerial, PgTable, PgTimestamp, PgTimestampString, PgUUID, getTableConfig as getTableConfig$1 } from "drizzle-orm/pg-core";
-import { SQLiteAsyncDatabase, SQLiteInteger, SQLiteTable, getTableConfig as getTableConfig$2 } from "drizzle-orm/sqlite-core";
+import { SQLiteAsyncDatabase, SQLiteInteger, SQLiteTable, SQLiteTimestamp, getTableConfig as getTableConfig$2 } from "drizzle-orm/sqlite-core";
 import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, Kind, getArgumentValues } from "graphql";
-import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
+import { GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
 import pluralize from "pluralize";
 //#region src/util/builders/common/errors.ts
 /**
@@ -160,6 +160,76 @@ const GraphQLDecimalString = new GraphQLScalarType({
 		return parseNumeric(ast.value);
 	}
 });
+const fullDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+const daysInMonth = (year, month) => {
+	if (month === 2) return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28;
+	return [
+		4,
+		6,
+		9,
+		11
+	].includes(month) ? 30 : 31;
+};
+/** Whether `value` is a `YYYY-MM-DD` string naming a day that exists on the calendar. */
+const isCalendarDate = (value) => {
+	const match = fullDatePattern.exec(value);
+	if (!match) return false;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth(year, month);
+};
+/**
+* A JS `Date` as the calendar day it stands for. Read in UTC, because that is how drivers
+* build one from a `date` column: `new Date('2026-09-15')` is UTC midnight, so the local
+* getters would name the previous day anywhere west of Greenwich.
+*/
+const dateToCalendarDate = (value) => {
+	if (Number.isNaN(value.getTime())) return;
+	const year = value.getUTCFullYear();
+	if (year < 0 || year > 9999) return;
+	const month = String(value.getUTCMonth() + 1).padStart(2, "0");
+	const day = String(value.getUTCDate()).padStart(2, "0");
+	return `${String(year).padStart(4, "0")}-${month}-${day}`;
+};
+const calendarDate = (code, acceptDate) => (value) => {
+	if (typeof value === "string") {
+		if (!isCalendarDate(value)) throw drizzleError(`Date cannot represent "${value}": expected a calendar date as YYYY-MM-DD`, { code });
+		return value;
+	}
+	if (acceptDate && value instanceof Date) {
+		const formatted = dateToCalendarDate(value);
+		if (formatted === void 0) throw drizzleError("Date cannot represent an invalid or out-of-range Date", { code });
+		return formatted;
+	}
+	throw drizzleError(`Date cannot represent value: ${JSON.stringify(value)}: expected a YYYY-MM-DD string`, { code });
+};
+const parseCalendarDate = calendarDate(INVALID_INPUT, false);
+/**
+* A calendar day — `date` columns, whichever `mode` drizzle reads them in. Always transported
+* as an RFC 3339 `full-date` string (`YYYY-MM-DD`), in both directions: it has no time and no
+* offset, so there is nothing for a client's timezone to shift. `graphql-scalars`' own
+* `GraphQLDate` is deliberately not used: its `parseValue` returns a JS `Date`, so the same
+* scalar would be a string on the way out and an instant on the way in.
+*
+* Input accepts only a `YYYY-MM-DD` string naming a real day (`2026-02-30` and datetime
+* strings are rejected) and hands it on unchanged. Output also accepts a JS `Date`, read as
+* the UTC day it encodes.
+*/
+const GraphQLDate = new GraphQLScalarType({
+	name: "Date",
+	description: "A calendar date with no time or offset, transported as an RFC 3339 full-date string (YYYY-MM-DD).",
+	specifiedByURL: "https://datatracker.ietf.org/doc/html/rfc3339#section-5.6",
+	serialize: calendarDate(UNREPRESENTABLE, true),
+	parseValue: parseCalendarDate,
+	parseLiteral: (ast) => {
+		if (ast.kind !== Kind.STRING) throw drizzleError(`Date cannot represent a ${ast.kind}`, {
+			code: INVALID_INPUT,
+			nodes: ast
+		});
+		return parseCalendarDate(ast.value);
+	}
+});
 //#endregion
 //#region src/util/case-ops/index.ts
 const uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
@@ -193,6 +263,17 @@ const singularizeMapper = (tableName) => ({
 //#endregion
 //#region src/util/type-converter/index.ts
 const allowedNameChars = /^[a-zA-Z0-9_]+$/;
+/** drizzle's `number` constraints whose values always fit a GraphQL `Int` (32-bit signed). */
+const smallIntegerConstraints = /* @__PURE__ */ new Set([
+	"int8",
+	"uint8",
+	"int16",
+	"uint16",
+	"int24",
+	"uint24",
+	"int32",
+	"year"
+]);
 /** A GraphQL `Name` that is also allowed as an enum value — the spec reserves the three literals. */
 const validEnumValueName = (name) => /^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) && name !== "true" && name !== "false" && name !== "null";
 /**
@@ -333,6 +414,52 @@ const geoXyInputType = new GraphQLInputObjectType({
 		y: { type: GraphQLFloat }
 	}
 });
+/**
+* Whether the column holds a calendar day with no time component — a SQL `date`, in either of
+* the modes drizzle reads one in (`'date'` → a JS `Date`, `'string'` → `YYYY-MM-DD`). Every
+* position a column's type appears in — output, create/update input, filter operands,
+* aggregates and group keys — gives such a column the `Date` scalar, whichever mode it uses:
+* the mode is how the server holds the value, not what the value is. SQLite has no date-only
+* column type (its integer timestamps are instants — see {@link isDateTimeColumn}), so only
+* Postgres and MySQL appear here.
+*/
+const isDateOnlyColumn = (column) => is(column, PgDate) || is(column, PgDateString) || is(column, MySqlDate) || is(column, MySqlDateString);
+/**
+* Whether the column is a MySQL `timestamp` / `datetime` read in drizzle's `'string'` mode. The
+* driver hands such a column back as MySQL's own `YYYY-MM-DD HH:MM:SS[.fraction]` text, with no
+* offset, and expects that form on write, so the data mappers translate between it and the ISO
+* 8601 instant the `DateTime` scalar carries. The text is read as UTC, the way drizzle's own
+* `'date'`-mode codecs for these columns read it.
+*/
+const isMySqlDateTimeStringColumn = (column) => is(column, MySqlTimestampString) || is(column, MySqlDateTimeString);
+/**
+* Whether the column is a Postgres `timestamp` read in drizzle's `'string'` mode. The driver hands
+* such a column back as Postgres's own text — `YYYY-MM-DD HH:MM:SS[.fraction]`, followed by an
+* offset (`+00`, `-06`, `+05:30`) for `timestamptz` — so the data mappers translate between it
+* and the ISO 8601 instant the `DateTime` scalar carries. Text without an offset (`timestamp`
+* without time zone) is read as UTC, the way drizzle's own `'date'`-mode codec reads it.
+*/
+const isPgTimestampStringColumn = (column) => is(column, PgTimestampString);
+/**
+* Whether the column is a SQLite `integer({ mode: 'timestamp' | 'timestamp_ms' })`. Both modes
+* are one drizzle class, told apart by `mode`: the stored integer counts seconds or milliseconds
+* since the Unix epoch. drizzle converts a JS `Date` to that integer on write (`'timestamp'`
+* floors to the whole second) and back on read, but a value read through a path that skips the
+* column's decoder arrives as the bare integer, which {@link sqliteTimestampToDate} reads.
+*/
+const isSQLiteTimestampColumn = (column) => is(column, SQLiteTimestamp);
+/**
+* A SQLite timestamp column's stored integer as the instant it names, using the column's own
+* unit (seconds for `'timestamp'`, milliseconds for `'timestamp_ms'`).
+*/
+const sqliteTimestampToDate = (column, value) => new Date(column.mode === "timestamp" ? value * 1e3 : value);
+/**
+* Whether the column holds an instant — a Postgres `timestamp`, a MySQL `timestamp` /
+* `datetime`, in either drizzle mode, or a SQLite integer timestamp in either unit. Every position
+* such a column appears in gives it the `DateTime` scalar and the `DateTimeFilter`, whichever
+* mode it uses, for the same reason as {@link isDateOnlyColumn}.
+*/
+const isDateTimeColumn = (column) => is(column, PgTimestamp) || isPgTimestampStringColumn(column) || is(column, MySqlTimestamp) || is(column, MySqlDateTime) || isMySqlDateTimeStringColumn(column) || isSQLiteTimestampColumn(column);
 const columnToGraphQLCore = (column, columnName, tableName, isInput) => {
 	const dimensions = column.dimensions;
 	if (dimensions !== void 0 && dimensions > 0) {
@@ -359,7 +486,11 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 			typeLabel: "Boolean"
 		};
 		case "object":
-			if (column instanceof PgTimestamp || column instanceof PgDate) return {
+			if (isDateOnlyColumn(column)) return {
+				type: GraphQLDate,
+				typeLabel: "Date"
+			};
+			if (isDateTimeColumn(column)) return {
 				type: GraphQLDateTime,
 				typeLabel: "DateTime"
 			};
@@ -379,7 +510,7 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 				type: GraphQLDecimalString,
 				typeLabel: "Decimal"
 			};
-			if (column instanceof PgTimestamp || column instanceof PgTimestampString) return {
+			if (isDateTimeColumn(column)) return {
 				type: GraphQLDateTime,
 				typeLabel: "DateTime"
 			};
@@ -387,10 +518,7 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 				type: GraphQLUUID,
 				typeLabel: "UUID"
 			};
-			if (column instanceof PgDateString) return isInput ? {
-				type: GraphQLString,
-				typeLabel: "Date"
-			} : {
+			if (isDateOnlyColumn(column)) return {
 				type: GraphQLDate,
 				typeLabel: "Date"
 			};
@@ -402,7 +530,7 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 			type: GraphQLBigIntString,
 			typeLabel: "BigInt"
 		};
-		case "number": return is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? {
+		case "number": return constraint !== void 0 && smallIntegerConstraints.has(constraint) || is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? {
 			type: GraphQLInt,
 			typeLabel: "Integer"
 		} : {
@@ -578,7 +706,8 @@ const isJsonColumn = (column) => (column.dataType ?? "").includes("json") && col
 * - "Decimal"     → numeric/decimal columns (Decimal-scalar-typed operators, no string pattern operators)
 * - the enum GraphQL type name → enum columns (still unique per enum; equality and
 *                       membership only, like Boolean)
-* - "DateTime"    → timestamp and date columns (ordering kept, no string pattern operators)
+* - "Date"        → date columns, either mode (ordering kept, no string pattern operators)
+* - "DateTime"    → timestamp columns (ordering kept, no string pattern operators)
 * - "Int"         → integer/serial columns (no string pattern operators)
 * - "Float"       → real/double columns (no string pattern operators)
 * - "String"      → all other text/varchar columns
@@ -617,8 +746,11 @@ const resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
 		name: "Decimal",
 		kind: "scalar"
 	};
-	const ct = column.columnType ?? "";
-	if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") return {
+	if (columnGraphQLType.type === GraphQLDate) return {
+		name: "Date",
+		kind: "scalar"
+	};
+	if (isDateTimeColumn(column)) return {
 		name: "DateTime",
 		kind: "scalar"
 	};
@@ -1013,6 +1145,58 @@ const generateColumnFilterValues = (column, tableName, columnName, cacheCtx) =>
 };
 //#endregion
 //#region src/util/data-mappers/index.ts
+/**
+* MySQL's own text form for a `timestamp` / `datetime`: `YYYY-MM-DD HH:MM:SS`, an optional
+* fraction, and no offset. mysql2 returns it for a `'string'`-mode column, and it is what such a
+* column expects on write.
+*/
+const MYSQL_DATETIME_TEXT = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+/**
+* MySQL datetime text, read as UTC, as the ISO 8601 instant the `DateTime` scalar carries.
+* UTC because that is how drizzle's own `'date'`-mode codecs read the same text, so a column's
+* two modes agree on the instant. Anything else (a zero date, a value already carrying an
+* offset) is returned unchanged for the scalar to accept or reject.
+*/
+const mySqlDateTimeTextToIso = (value) => {
+	const match = MYSQL_DATETIME_TEXT.exec(value);
+	return match ? `${match[1]}T${match[2]}Z` : value;
+};
+/**
+* A JS `Date` as offset-less `YYYY-MM-DD HH:MM:SS.mmm` text in UTC: what a MySQL `'string'`-mode
+* column and a Postgres `timestamp` (without time zone) `'string'`-mode column are written with.
+*/
+const dateToUtcWallText = (value) => value.toISOString().slice(0, -1).replace("T", " ");
+/**
+* Postgres's text form for a `timestamp` / `timestamptz` (the `ISO` `DateStyle`, the default):
+* `YYYY-MM-DD HH:MM:SS`, an optional fraction, and — for `timestamptz` only — the session zone's
+* offset as `±HH`, `±HH:MM` or, for historical local mean time, `±HH:MM:SS`.
+*/
+const PG_TIMESTAMP_TEXT = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(\.\d+)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?$/;
+/**
+* Postgres timestamp text as the RFC 3339 UTC instant (`…Z`) the `DateTime` scalar accepts.
+*
+* - With an offset (`timestamptz`), the instant is shifted to UTC. The offset can carry seconds,
+*   which RFC 3339 cannot express, so it is applied here rather than rewritten.
+* - Without one (`timestamp`), the wall time is read as UTC: that is what drizzle's `'date'`-mode
+*   codec does (`new Date(text + '+0000')`) and what the input side writes, so a column's two
+*   modes agree on the instant.
+* - The fraction is kept digit for digit. The scalar itself carries milliseconds, so microseconds
+*   are truncated on the wire, never rounded into the next second.
+*
+* Anything else (`infinity`, a `BC` date, a five-digit year) is returned unchanged for the scalar
+* to reject.
+*/
+const pgTimestampTextToIso = (value) => {
+	const match = PG_TIMESTAMP_TEXT.exec(value);
+	if (!match) return value;
+	const [, date, time, fraction = "", sign, hours, minutes = "0", seconds = "0"] = match;
+	if (!sign) return `${date}T${time}${fraction}Z`;
+	const wallMs = Date.parse(`${date}T${time}Z`);
+	if (Number.isNaN(wallMs)) return value;
+	const offsetSeconds = (sign === "-" ? -1 : 1) * (Number(hours) * 3600 + Number(minutes) * 60 + Number(seconds));
+	const utc = (/* @__PURE__ */ new Date(wallMs - offsetSeconds * 1e3)).toISOString();
+	return utc.length === 24 ? `${utc.slice(0, 19)}${fraction}Z` : value;
+};
 const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 	if (Array.isArray(value)) {
 		const relations = relationMap?.[tableName];
@@ -1031,7 +1215,14 @@ const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 	if (!column) return value;
 	if (getColumnScalarOverride(column, false)) return value;
 	if (isJsonColumn(column)) return value;
+	if (value instanceof Date && isDateOnlyColumn(column)) return dateToCalendarDate(value) ?? value;
+	if (typeof value === "number" && isSQLiteTimestampColumn(column)) {
+		const instant = sqliteTimestampToDate(column, value);
+		return Number.isNaN(instant.getTime()) ? value : instant.toISOString();
+	}
 	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "string" && isMySqlDateTimeStringColumn(column)) return mySqlDateTimeTextToIso(value);
+	if (typeof value === "string" && isPgTimestampStringColumn(column)) return pgTimestampTextToIso(value);
 	if (value instanceof Buffer) return Array.from(value);
 	if (typeof value === "bigint") return value.toString();
 	if (Array.isArray(value)) {
@@ -1077,16 +1268,20 @@ const remapFromGraphQLCore = (value, column, columnName) => {
 	}
 	const dataType = column.dataType ?? "";
 	const columnType = column.columnType ?? "";
-	if (columnType === "SQLiteTimestamp" || columnType === "SQLiteTimestampMs" || columnType === "MySqlTimestamp" || columnType === "MySqlDateTime" || columnType === "PgTimestamp" || columnType === "PgTimestampString") {
-		const formatted = new Date(value);
+	if (isDateTimeColumn(column)) {
+		const isMySql = columnType.startsWith("MySql");
+		const isPgString = isPgTimestampStringColumn(column);
+		const toIso = isMySql ? mySqlDateTimeTextToIso : isPgString ? pgTimestampTextToIso : void 0;
+		const formatted = new Date(toIso && typeof value === "string" ? toIso(value) : value);
 		if (Number.isNaN(formatted.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-		return formatted;
+		if (isPgString) return column.withTimezone ? formatted.toISOString() : dateToUtcWallText(formatted);
+		return isMySqlDateTimeStringColumn(column) ? dateToUtcWallText(formatted) : formatted;
 	}
-	if ((columnType === "MySqlDate" || columnType === "PgDate") && typeof value === "string") {
-		const dateOnly = value.includes("T") ? value.split("T")[0] : value;
-		const check = new Date(dateOnly);
-		if (Number.isNaN(check.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-		return dateOnly;
+	if (isDateOnlyColumn(column)) {
+		if (Array.isArray(value)) return value.map((element) => remapFromGraphQLCore(element, column, columnName));
+		const day = value instanceof Date ? dateToCalendarDate(value) : value;
+		if (typeof day !== "string" || !isCalendarDate(day)) throw drizzleError(`Field '${columnName}' is not a valid date! Expected a calendar date as YYYY-MM-DD.`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		return day;
 	}
 	if (dataType.includes("bigint")) try {
 		return BigInt(value);
@@ -1442,7 +1637,8 @@ const extractFiltersColumn = (column, columnName, operators) => {
 	}
 	if (NOT) {
 		const extracted = extractFiltersColumn(column, columnName, NOT);
-		if (extracted) variants.push(not(extracted));
+		const negated = extracted ? not(extracted) : void 0;
+		if (negated) variants.push(negated);
 	}
 	if (OR?.length) {
 		const orVariants = [];
@@ -1455,6 +1651,150 @@ const extractFiltersColumn = (column, columnName, operators) => {
 	return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
 //#endregion
+//#region src/util/builders/common/relations.ts
+/**
+* Flatten drizzle-orm v1 TablesRelationalConfig into the canonical
+* Record<tableName, Record<relName, TableNamedRelations>> shape used
+* throughout common.ts.  Both pg.ts and sqlite.ts call this before
+* passing the relation map to any shared function.
+*/
+const buildNamedRelations = (relations, tableEntries) => {
+	const namedRelations = {};
+	for (const [relTableName, relConfig] of Object.entries(relations)) {
+		if (!relConfig?.relations) continue;
+		const namedConfig = {};
+		for (const [innerRelName, innerRelValue] of Object.entries(relConfig.relations)) {
+			const targetTable = innerRelValue.targetTable ?? innerRelValue.referencedTable;
+			const directTargetName = innerRelValue.targetTableName;
+			let targetTableName;
+			if (directTargetName) targetTableName = tableEntries.find(([key]) => key === directTargetName)?.[0];
+			else if (targetTable) targetTableName = tableEntries.find(([, tableValue]) => tableValue === targetTable)?.[0];
+			if (!targetTableName) continue;
+			namedConfig[innerRelName] = {
+				relation: innerRelValue,
+				targetTableName
+			};
+		}
+		if (Object.keys(namedConfig).length > 0) namedRelations[relTableName] = namedConfig;
+	}
+	return namedRelations;
+};
+/**
+* Records each relation's target-table primary-key property names on the relation entry,
+* so the pagination paths (the window-function batch loader and the eager `with:` orderBy
+* default) can fall back to a deterministic PK order without re-deriving it per request.
+*
+* Composite primary keys are only visible through the dialect's getTableConfig, so the
+* dialect builder passes a `resolvePkNames` that threads the composite column names in.
+* Mutates the relation entries in place (they are shared with the pruned eager map and
+* the resolver factory, so attaching once covers every consumer).
+*/
+const attachTargetPrimaryKeys = (namedRelations, tables, resolvePkNames) => {
+	const cache = /* @__PURE__ */ new Map();
+	for (const rels of Object.values(namedRelations)) for (const relEntry of Object.values(rels)) {
+		const { targetTableName } = relEntry;
+		let pk = cache.get(targetTableName);
+		if (!pk) {
+			const targetTable = tables[targetTableName];
+			pk = targetTable ? resolvePkNames(targetTable) : [];
+			cache.set(targetTableName, pk);
+		}
+		relEntry.targetPkNames = pk;
+	}
+};
+/**
+* The table column behind one entry of a relation's `sourceColumns`, `targetColumns` or
+* `through` lists.
+*
+* drizzle-orm rc.4 stores the table's own Column objects in `sourceColumns` / `targetColumns`
+* and a `RelationsBuilderColumn` descriptor (`{ _: { column, key, tableName } }`) in `through`.
+* The rc.5 snapshots store the descriptor in all of them. Both shapes are accepted here, told
+* apart structurally rather than by importing a class one of those versions does not export.
+* Anything else yields `undefined`, which callers treat as "join columns not readable".
+*/
+const unwrapRelationColumn = (entry) => {
+	if (is(entry, Column)) return entry;
+	const inner = entry?._?.column;
+	return is(inner, Column) ? inner : void 0;
+};
+/**
+* A relation's `sourceColumns` or `targetColumns` as table columns, via
+* {@link unwrapRelationColumn}. `undefined` when the list is missing, empty, or has an entry
+* that is not a column in either known shape.
+*/
+const relationColumns = (relation, side) => {
+	const entries = relation?.[side === "source" ? "sourceColumns" : "targetColumns"];
+	if (!entries?.length) return;
+	const columns = [];
+	for (const entry of entries) {
+		const column = unwrapRelationColumn(entry);
+		if (!column) return;
+		columns.push(column);
+	}
+	return columns;
+};
+/**
+* drizzle-orm's "no filter" sentinel. rc.5 snapshots export it as `EmptyFilter` and use it as
+* the default `relation.where`; rc.4 has no such export and leaves `where` undefined. It is a
+* registered symbol, so it can be compared against without importing anything.
+*/
+const EMPTY_FILTER = Symbol.for("drizzle:EmptyFilter");
+/**
+* The relation's own declared `where` filter, or `undefined` when it has none. rc.4 leaves
+* `where` undefined in that case; rc.5 snapshots set it to the `EmptyFilter` sentinel, which is
+* truthy and must not be read as a filter.
+*/
+const relationOwnWhere = (relation) => {
+	const where = relation?.where;
+	return where == null || where === EMPTY_FILTER ? void 0 : where;
+};
+/**
+* Whether the relation's `where` was inherited from its reverse relation, and so is written
+* against the parent table rather than the target. rc.4 calls this flag `isReversed`; rc.5
+* snapshots renamed it to `isFilterReversed`. Both are set in the same place with the same
+* meaning (true only for a relation declared without `from`/`to` and without its own `where`).
+*/
+const isRelationFilterReversed = (relation) => !!(relation?.isFilterReversed ?? relation?.isReversed);
+/**
+* Warns, at build time, that a field was left out because the relation's join columns could
+* not be matched to its tables. Omitting it silently is how a drizzle-orm change in the shape
+* of relation columns (issue #179) went unnoticed. A relation that declares no join columns
+* is not reported: there is nothing that failed to match.
+*/
+const warnUnresolvedJoin = (relEntry, tableName, relationName, omitted) => {
+	const rel = relEntry.relation ?? relEntry;
+	if (!rel?.sourceColumns?.length || !rel?.targetColumns?.length) return;
+	console.warn(`Drizzle-GraphQL Warning: relation '${tableName}.${relationName}' declares join columns that could not be matched to columns of '${tableName}' and '${relEntry.targetTableName}', so ${omitted} is not generated. The installed drizzle-orm probably stores relation columns in a shape this version of drizzle-graphql does not recognize.`);
+};
+/**
+* Extracts the join column info from a drizzle-orm v1 Relation object.
+* 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.
+*/
+const extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
+	const rel = relEntry.relation ?? relEntry;
+	const sourceCol = relationColumns(rel, "source")?.[0];
+	const targetCol = relationColumns(rel, "target")?.[0];
+	if (!sourceCol || !targetCol) return;
+	const parentCols = getColumns(parentTable);
+	const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
+	const targetCols = getColumns(targetTable);
+	const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
+	if (!localColPropName || !foreignColPropName) return;
+	return {
+		localColPropName,
+		foreignCol: targetCol,
+		foreignColPropName
+	};
+};
+/**
+* Whether a to-one relation can back a relation orderBy hop. `.through()` (junction)
+* relations are excluded — the ordering subquery only joins the direct target, never the
+* junction table. (Relation *filters* do support `.through()` — this guard is orderBy-only.)
+*/
+const isFilterableRelation = (relation) => !relation.through;
+//#endregion
 //#region src/util/builders/common/exclusions.ts
 /**
 * Columns this build keeps out of the generated schema, keyed by the table object.
@@ -1630,8 +1970,8 @@ const relationFilterCtx = (base, tableKey) => {
 * the parent is an aliased proxy (as it is inside a relational `with:` where callback).
 */
 const buildRelationJoinCondition = (parentTable, relation, aliasedTarget, relationName) => {
-	const sourceColumns = relation.sourceColumns;
-	const targetColumns = relation.targetColumns;
+	const sourceColumns = relationColumns(relation, "source");
+	const targetColumns = relationColumns(relation, "target");
 	if (!sourceColumns?.length || sourceColumns.length !== targetColumns?.length) throw drizzleError(`WHERE ${relationName}: Relation cannot be used as a filter`, { code: "DRIZZLE_INVALID_FILTER" });
 	const parentColumns = Object.values(getColumns(parentTable));
 	const targetColumnsByName = Object.values(getColumns(aliasedTarget));
@@ -1655,7 +1995,7 @@ const resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
 	const key = junctionRef?._?.key;
 	const byKey = key ? throughColumns[key] : void 0;
 	if (byKey) return byKey;
-	const columnName = junctionRef?._?.column?.name;
+	const columnName = unwrapRelationColumn(junctionRef)?.name;
 	const byName = columnName ? Object.values(throughColumns).find((c) => c.name === columnName) : void 0;
 	if (!byName) throw drizzleError(`WHERE ${relationName}: Relation cannot be used as a filter`, { code: "DRIZZLE_INVALID_FILTER" });
 	return byName;
@@ -1669,8 +2009,8 @@ const resolveJunctionColumn = (aliasedThrough, junctionRef, relationName) => {
 * `through` metadata.
 */
 const buildThroughJoinConditions = (parentTable, relation, aliasedThrough, aliasedTarget, relationName) => {
-	const sourceColumns = relation.sourceColumns;
-	const targetColumns = relation.targetColumns;
+	const sourceColumns = relationColumns(relation, "source");
+	const targetColumns = relationColumns(relation, "target");
 	const through = relation.through;
 	if (!sourceColumns?.length || !targetColumns?.length || through?.source.length !== sourceColumns.length || through.target.length !== targetColumns.length) throw drizzleError(`WHERE ${relationName}: Relation cannot be used as a filter`, { code: "DRIZZLE_INVALID_FILTER" });
 	const parentColumns = Object.values(getColumns(parentTable));
@@ -1722,7 +2062,8 @@ const buildRelationExists = (parentTable, relationName, relEntry, innerFilters,
 		fromClause = getTableAsAliasSQL(aliasedTarget);
 		joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
 	}
-	const relationWhere = relation.where ? relationsFilterToSQL(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+	const ownWhere = relationOwnWhere(relation);
+	const relationWhere = ownWhere ? relationsFilterToSQL(isRelationFilterReversed(relation) ? parentTable : aliasedTarget, ownWhere) : void 0;
 	const inner = innerFilters ? extractFilters(aliasedTarget, targetTableName, innerFilters, {
 		...ctx,
 		tableKey: targetTableName,
@@ -1776,7 +2117,8 @@ const extractFilters = (table, tableName, filters, relationCtx) => {
 	}
 	if (NOT) {
 		const extracted = extractFilters(table, tableName, NOT, relationCtx);
-		if (extracted) variants.push(not(extracted));
+		const negated = extracted ? not(extracted) : void 0;
+		if (negated) variants.push(negated);
 	}
 	if (OR?.length) {
 		const orVariants = [];
@@ -2173,88 +2515,6 @@ const excludedColumnRef = (columnName) => sql`excluded.${sql.identifier(columnNa
 /** `values(<column>)` — MySQL's equivalent inside ON DUPLICATE KEY UPDATE. */
 const mysqlValuesColumnRef = (columnName) => sql`values(${sql.identifier(columnName)})`;
 //#endregion
-//#region src/util/builders/common/relations.ts
-/**
-* Flatten drizzle-orm v1 TablesRelationalConfig into the canonical
-* Record<tableName, Record<relName, TableNamedRelations>> shape used
-* throughout common.ts.  Both pg.ts and sqlite.ts call this before
-* passing the relation map to any shared function.
-*/
-const buildNamedRelations = (relations, tableEntries) => {
-	const namedRelations = {};
-	for (const [relTableName, relConfig] of Object.entries(relations)) {
-		if (!relConfig?.relations) continue;
-		const namedConfig = {};
-		for (const [innerRelName, innerRelValue] of Object.entries(relConfig.relations)) {
-			const targetTable = innerRelValue.targetTable ?? innerRelValue.referencedTable;
-			const directTargetName = innerRelValue.targetTableName;
-			let targetTableName;
-			if (directTargetName) targetTableName = tableEntries.find(([key]) => key === directTargetName)?.[0];
-			else if (targetTable) targetTableName = tableEntries.find(([, tableValue]) => tableValue === targetTable)?.[0];
-			if (!targetTableName) continue;
-			namedConfig[innerRelName] = {
-				relation: innerRelValue,
-				targetTableName
-			};
-		}
-		if (Object.keys(namedConfig).length > 0) namedRelations[relTableName] = namedConfig;
-	}
-	return namedRelations;
-};
-/**
-* Records each relation's target-table primary-key property names on the relation entry,
-* so the pagination paths (the window-function batch loader and the eager `with:` orderBy
-* default) can fall back to a deterministic PK order without re-deriving it per request.
-*
-* Composite primary keys are only visible through the dialect's getTableConfig, so the
-* dialect builder passes a `resolvePkNames` that threads the composite column names in.
-* Mutates the relation entries in place (they are shared with the pruned eager map and
-* the resolver factory, so attaching once covers every consumer).
-*/
-const attachTargetPrimaryKeys = (namedRelations, tables, resolvePkNames) => {
-	const cache = /* @__PURE__ */ new Map();
-	for (const rels of Object.values(namedRelations)) for (const relEntry of Object.values(rels)) {
-		const { targetTableName } = relEntry;
-		let pk = cache.get(targetTableName);
-		if (!pk) {
-			const targetTable = tables[targetTableName];
-			pk = targetTable ? resolvePkNames(targetTable) : [];
-			cache.set(targetTableName, pk);
-		}
-		relEntry.targetPkNames = pk;
-	}
-};
-/**
-* Extracts the join column info from a drizzle-orm v1 Relation object.
-* 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.
-*/
-const extractRelationJoinColumns = (relEntry, parentTable, targetTable) => {
-	const rel = relEntry.relation ?? relEntry;
-	const sourceColumns = rel.sourceColumns;
-	const targetColumns = rel.targetColumns;
-	if (!sourceColumns?.length || !targetColumns?.length) return;
-	const sourceCol = sourceColumns[0];
-	const targetCol = targetColumns[0];
-	const parentCols = getColumns(parentTable);
-	const localColPropName = Object.entries(parentCols).find(([, c]) => c === sourceCol)?.[0];
-	const targetCols = getColumns(targetTable);
-	const foreignColPropName = Object.entries(targetCols).find(([, c]) => c === targetCol)?.[0];
-	if (!localColPropName || !foreignColPropName) return;
-	return {
-		localColPropName,
-		foreignCol: targetCol,
-		foreignColPropName
-	};
-};
-/**
-* Whether a to-one relation can back a relation orderBy hop. `.through()` (junction)
-* relations are excluded — the ordering subquery only joins the direct target, never the
-* junction table. (Relation *filters* do support `.through()` — this guard is orderBy-only.)
-*/
-const isFilterableRelation = (relation) => !relation.through;
-//#endregion
 //#region src/util/builders/common/order-by.ts
 /**
 * Column name / direction / nulls triples from an `orderBy` argument, highest priority
@@ -2300,7 +2560,8 @@ const extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chai
 	ctx.aliases ??= { n: 0 };
 	const aliasedTarget = aliasedTable(targetTable, `dgql_ord_${ctx.aliases.n++}`);
 	const joinCondition = buildRelationJoinCondition(parentTable, relation, aliasedTarget, relationName);
-	const relationWhere = relation.where ? relationsFilterToSQL(relation.isReversed ? parentTable : aliasedTarget, relation.where) : void 0;
+	const ownWhere = relationOwnWhere(relation);
+	const relationWhere = ownWhere ? relationsFilterToSQL(isRelationFilterReversed(relation) ? parentTable : aliasedTarget, ownWhere) : void 0;
 	return {
 		fromParts: [...chain?.fromParts ?? [], getTableAsAliasSQL(aliasedTarget)],
 		conditions: [
@@ -2317,15 +2578,17 @@ const extendRelationOrderChain = (parentTable, relationName, relEntry, ctx, chai
 *
 * A ladder rather than a dialect array function (`array_position` on Postgres, `FIELD()` on
 * MySQL, neither on SQLite) because it is the one form all three share, and because every
-* list value stays a bound parameter. The branch indices are library-generated integers, so
-* they are written into the SQL text — a bound parameter there would leave Postgres unable
-* to infer the CASE result type. Values outside the list sort after every listed one.
+* list value stays a bound parameter — encoded by the column, as `eq` would, so a value whose
+* driver form differs from its JS one (a SQLite integer timestamp's `Date`) is bound as stored.
+* The branch indices are library-generated integers, so they are written into the SQL text — a
+* bound parameter there would leave Postgres unable to infer the CASE result type. Values
+* outside the list sort after every listed one.
 */
 const filterOrderExpression = (column, columnName, whereArgs) => {
 	const values = whereArgs?.[columnName]?.inArray;
 	if (!Array.isArray(values)) throw drizzleError(`ORDER BY ${columnName}: 'matchFilterOrder' needs an 'inArray' filter on the same column in this query's 'where'`, { code: "DRIZZLE_INVALID_ORDER_BY" });
 	if (!values.length) return sql`0`;
-	const branches = values.map((value, index) => sql`when ${column} = ${remapFromGraphQLCore(value, column, columnName)} then ${sql.raw(String(index))}`);
+	const branches = values.map((value, index) => sql`when ${column} = ${sql.param(remapFromGraphQLCore(value, column, columnName), column)} then ${sql.raw(String(index))}`);
 	return sql`case ${sql.join(branches, sql` `)} else ${sql.raw(String(values.length))} end`;
 };
 /**
@@ -3291,6 +3554,26 @@ const remapUpdateInput = (values, table, tableName) => {
 	} : remapped;
 };
 //#endregion
+//#region src/util/builders/common/rqb-config.ts
+/**
+* A copy of a relational query config with every key whose value is `undefined` left out.
+*
+* drizzle-orm rc.5 snapshots test `"where" in params` rather than its value, and throw
+* `Unexpected 'undefined' in filter value` for `{ where: undefined }`; rc.4 read the value and
+* treated both the same. The library builds its configs with conditional keys
+* (`where: cond ? … : undefined`), so every config goes through here before it reaches drizzle.
+* Only `where` is checked that way today, but leaving out every undefined key costs nothing
+* and keeps the next key that gets the same treatment from breaking queries.
+*
+* Shallow on purpose: nested `with:` entries are built (and passed through here) one level at
+* a time, and the values of the other keys are drizzle's own (column maps, callbacks, RAW).
+*/
+const omitUndefinedKeys = (config) => {
+	const out = {};
+	for (const [key, value] of Object.entries(config)) if (value !== void 0) out[key] = value;
+	return out;
+};
+//#endregion
 //#region src/util/builders/common/selected-columns.ts
 const rqbCrashTypes = [
 	"SQLiteBigInt",
@@ -3419,7 +3702,7 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		thisRecord.offset = offset;
 		thisRecord.limit = limit;
 		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, field, relTypeName, options);
-		args[relName] = thisRecord;
+		args[relName] = omitUndefinedKeys(thisRecord);
 	}
 	return args;
 };
@@ -3496,12 +3779,12 @@ const runRelationalSelect = async (opts) => {
 		}) : void 0
 	};
 	if (single) {
-		const result = await queryBase.findFirst(params);
+		const result = await queryBase.findFirst(omitUndefinedKeys(params));
 		return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
 	}
 	if (cursorEntries && cursorSelected) for (const [column] of cursorEntries) params.columns[column] = true;
 	params.limit = distinctKeys ? void 0 : opts.limit;
-	const result = await queryBase.findMany(params);
+	const result = await queryBase.findMany(omitUndefinedKeys(params));
 	if (cursorEntries && cursorSelected) attachRowCursors(result, cursorEntries);
 	return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
 };
@@ -5227,7 +5510,6 @@ const resolveBuildConfig = (config, schema) => {
 			const missing = [!tableFeatures.insert ? "insert" : void 0, !tableFeatures.update ? "update" : void 0].filter(Boolean).join(" and ");
 			if (missing) noteConflict(`upsert is on while ${missing} is off, so the upsert mutations are a second write path past the operation you turned off`, tableName);
 		}
-		if (config?.features?.nestedWrites && (!tableFeatures.insert || !tableFeatures.update)) noteConflict("nestedWrites is on while this table's own insert or update is off, so a nested `create` or `connect` under another table's mutation can still write it", tableName);
 		if (config?.features?.updateMany !== void 0 && tableFeatures.updateMany && !tableFeatures.update) noteConflict("updateMany is on while update is off, so no batch update is generated", tableName);
 		if (config?.features?.groupBy !== void 0 && tableFeatures.groupBy && !tableFeatures.aggregates) noteConflict("groupBy is on while aggregates is off, so no grouped query is generated", tableName);
 		if (tableFeatures.countMutations && !tableFeatures.update && !tableFeatures.delete) noteConflict("countMutations is on while update and delete are both off, so no count mutation is generated", tableName);
@@ -5540,13 +5822,21 @@ const GROUP_KEY = "__dgql_group_key";
 * for every other aggregate.
 */
 const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, filterCtx, policies) => {
+	const warned = /* @__PURE__ */ new Set();
 	return ({ tableName, relationName, relEntry }) => {
 		const parentTable = tables[tableName];
 		const targetTableName = relEntry.targetTableName;
 		const targetTable = tables[targetTableName];
 		if (!parentTable || !targetTable) return;
 		const joinCols = extractRelationJoinColumns(relEntry, parentTable, targetTable);
-		if (!joinCols) return;
+		if (!joinCols) {
+			const key = `${tableName}.${relationName}`;
+			if (!warned.has(key)) {
+				warned.add(key);
+				warnUnresolvedJoin(relEntry, tableName, relationName, `its '${relationName}Aggregate' field`);
+			}
+			return;
+		}
 		const { localColPropName, foreignCol } = joinCols;
 		const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, false);
 		const targetTypeName = resolveTypeName(targetTableName, typeNameMapper);
@@ -5833,6 +6123,12 @@ const generateGroupBy = (db, tableName, table, typeName, fieldName, filterArgs,
 };
 //#endregion
 //#region src/util/builders/nested-writes.ts
+const ALL_OPS = [
+	"create",
+	"connect",
+	"disconnect",
+	"set"
+];
 /**
 * Whether a column can be left out of an INSERT — either the database fills it in or it
 * accepts NULL.
@@ -5844,12 +6140,6 @@ const propNameOf = (table, column) => {
 	for (const [propName, candidate] of Object.entries(getColumns(table))) if (candidate === column) return propName;
 };
 /**
-* The junction column one entry of a relation's `through` config points at. Drizzle wraps it
-* in a descriptor while the relation is being defined; the raw column is accepted too, so a
-* change of shape there degrades to skipping the relation rather than mis-planning it.
-*/
-const throughColumn = (entry) => entry && is(entry, Column) ? entry : entry?._?.column;
-/**
 * A `.through()` relation's plan: the junction table plus the two columns it joins on.
 *
 * Nothing about the parent or the target row changes when a many-to-many link is made or
@@ -5860,21 +6150,27 @@ const throughColumn = (entry) => entry && is(entry, Column) ? entry : entry?._?.
 * row" guarantee lives in the junction's constraints rather than in the relation; a relation
 * joining on more than one column per side; and a junction carrying a further NOT NULL column
 * with no default, which no `connect` operand could supply a value for.
+*
+* `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) => {
+const buildThroughPlan = (relationName, relation, table, targetTableName, targetTable, tableNameOf, onUnresolved) => {
 	if (is(relation, One)) return;
 	const junction = relation.throughTable;
 	const sourceEntries = relation.through?.source;
 	const targetEntries = relation.through?.target;
 	if (!junction || sourceEntries?.length !== 1 || targetEntries?.length !== 1) return;
 	if (relation.sourceColumns?.length !== 1 || relation.targetColumns?.length !== 1) return;
-	const localCol = relation.sourceColumns[0];
-	const foreignCol = relation.targetColumns[0];
+	const localCol = unwrapRelationColumn(relation.sourceColumns[0]);
+	const foreignCol = unwrapRelationColumn(relation.targetColumns[0]);
 	const localColPropName = propNameOf(table, localCol);
 	const foreignColPropName = propNameOf(targetTable, foreignCol);
-	const sourceColPropName = propNameOf(junction, throughColumn(sourceEntries[0]));
-	const targetColPropName = propNameOf(junction, throughColumn(targetEntries[0]));
-	if (!localColPropName || !foreignColPropName || !sourceColPropName || !targetColPropName) return;
+	const sourceColPropName = propNameOf(junction, unwrapRelationColumn(sourceEntries[0]));
+	const targetColPropName = propNameOf(junction, unwrapRelationColumn(targetEntries[0]));
+	if (!localCol || !foreignCol || !localColPropName || !foreignColPropName || !sourceColPropName || !targetColPropName) {
+		onUnresolved();
+		return;
+	}
 	const junctionColumns = getColumns(junction);
 	const sourceCol = junctionColumns[sourceColPropName];
 	const targetCol = junctionColumns[targetColPropName];
@@ -5892,11 +6188,18 @@ const buildThroughPlan = (relationName, relation, table, targetTableName, target
 		canDetach: true,
 		through: {
 			table: junction,
+			tableName: tableNameOf(junction),
 			sourceColPropName,
 			targetColPropName,
 			sourceCol,
 			targetCol
-		}
+		},
+		targetKeyColumns: { [foreignColPropName]: foreignCol },
+		allowed: /* @__PURE__ */ new Set([
+			"connect",
+			"disconnect",
+			"set"
+		])
 	};
 };
 /**
@@ -5909,7 +6212,7 @@ const buildThroughPlan = (relationName, relation, table, targetTableName, target
 * relations whose join columns cannot be read off the drizzle relation; and relations where
 * neither join column is unique, which leaves no way to tell which side stores the key.
 */
-const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
+const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns, tableNameOf = () => void 0) => {
 	const uniqueCache = /* @__PURE__ */ new Map();
 	const singleColumnUniques = (tableName, table) => {
 		let cached = uniqueCache.get(tableName);
@@ -5937,13 +6240,17 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			const targetTableName = relEntry.targetTableName;
 			const targetTable = tables[targetTableName];
 			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);
+				const throughPlan = buildThroughPlan(relationName, relation, table, targetTableName, targetTable, tableNameOf, () => warnUnresolvedJoin(relEntry, tableName, relationName, omitted));
 				if (throughPlan) tablePlans[relationName] = throughPlan;
 				continue;
 			}
 			const joinColumns = extractJoinColumns(relEntry, table, targetTable);
-			if (!joinColumns) continue;
+			if (!joinColumns) {
+				warnUnresolvedJoin(relEntry, tableName, relationName, omitted);
+				continue;
+			}
 			const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
 			const localCol = getColumns(table)[localColPropName];
 			if (!localCol) continue;
@@ -5959,6 +6266,10 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			else if (foreignIsUnique) fkSide = "parent";
 			else if (localIsUnique) fkSide = "child";
 			else continue;
+			const fkColumn = fkSide === "child" ? foreignCol : localCol;
+			const targetColumns = getColumns(targetTable);
+			const targetKeyColumns = Object.fromEntries(resolvePrimaryKeys(targetTable).filter((name) => targetColumns[name]).map((name) => [name, targetColumns[name]]));
+			targetKeyColumns[foreignColPropName] = foreignCol;
 			tablePlans[relationName] = {
 				relationName,
 				targetTableName,
@@ -5969,13 +6280,87 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 				localCol,
 				isOne,
 				fkSide,
-				canDetach: !(fkSide === "child" ? foreignCol : localCol).notNull
+				canDetach: !fkColumn.notNull,
+				targetKeyColumns,
+				allowed: new Set(!fkColumn.notNull ? isOne ? [
+					"create",
+					"connect",
+					"disconnect"
+				] : ALL_OPS : ["create", "connect"])
 			};
 		}
 		if (Object.keys(tablePlans).length) plans[tableName] = tablePlans;
 	}
 	return plans;
 };
+/**
+* Which of the target's (or junction's) write features each input of a relation needs. A
+* parent-side `connect` / `disconnect` only rewrites the parent's own column, so it needs
+* nothing of the target; a child-side one moves the target's foreign key, which is an update
+* of the target. A to-one child-side `create` also detaches the row attached before it, when
+* the key is nullable.
+*/
+const requiredWrites = (plan, op) => {
+	if (plan.through) {
+		const junction = plan.through.tableName;
+		if (op === "connect") return [{
+			tableName: junction,
+			feature: "insert"
+		}];
+		if (op === "disconnect") return [{
+			tableName: junction,
+			feature: "delete"
+		}];
+		if (op === "set") return [{
+			tableName: junction,
+			feature: "delete"
+		}, {
+			tableName: junction,
+			feature: "insert"
+		}];
+		return [];
+	}
+	const target = plan.targetTableName;
+	if (op === "create") return plan.fkSide === "child" && plan.isOne && plan.canDetach ? [{
+		tableName: target,
+		feature: "insert"
+	}, {
+		tableName: target,
+		feature: "update"
+	}] : [{
+		tableName: target,
+		feature: "insert"
+	}];
+	return plan.fkSide === "child" ? [{
+		tableName: target,
+		feature: "update"
+	}] : [];
+};
+/**
+* Narrows every plan's `allowed` inputs to the ones whose writes the table they land on
+* permits: its `features.insert` / `update` / `delete`, and for a junction table that it is
+* not excluded. A plan left with nothing is dropped, so its relation field is not generated.
+*
+* Returns one line per input taken out, for the build note.
+*/
+const gateNestedWritePlans = (plans, featureOf, isExcluded) => {
+	const omitted = [];
+	for (const [tableName, tablePlans] of Object.entries(plans)) {
+		for (const [relationName, plan] of Object.entries(tablePlans)) {
+			for (const op of [...plan.allowed]) {
+				const blocked = requiredWrites(plan, op).filter(({ tableName: target, feature }) => target !== void 0 && (isExcluded(target) || !featureOf(target)[feature]));
+				if (blocked.length) {
+					plan.allowed.delete(op);
+					const reasons = blocked.map(({ tableName: target, feature }) => isExcluded(target) ? `${target} is excluded` : `${target}.${feature} is off`);
+					omitted.push(`${tableName}.${relationName}.${op} (${[...new Set(reasons)].join(", ")})`);
+				}
+			}
+			if (!plan.allowed.size) delete tablePlans[relationName];
+		}
+		if (!Object.keys(tablePlans).length) delete plans[tableName];
+	}
+	return omitted;
+};
 const NO_COLUMNS = /* @__PURE__ */ new Set();
 /**
 * Builds the nested-write input types for a schema.
@@ -6030,8 +6415,11 @@ const createNestedWriteTypes = (params) => {
 	*
 	* A many-to-many relation offers no `create`: inserting a row *and* linking it is two
 	* writes to two tables, and the link half is what the relation field is for. Its
-	* `disconnect` and `set` are offered unconditionally, since breaking a link deletes a
+	* `disconnect` and `set` do not depend on nullability, since breaking a link deletes a
 	* junction row rather than nulling a column that might be NOT NULL.
+	*
+	* Each input is also subject to `plan.allowed` — the table it writes has to have that
+	* write turned on (see {@link gateNestedWritePlans}).
 	*/
 	const wrapperType = (tableName, typeName, plan, forUpdate) => {
 		const key = `${tableName}.${plan.relationName}.${forUpdate ? "update" : "create"}`;
@@ -6040,57 +6428,52 @@ const createNestedWriteTypes = (params) => {
 		const filters = targetFilters(plan);
 		const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
 		const fields = {};
+		const offers = (op) => plan.allowed.has(op);
 		if (plan.through) {
-			if (!filters) return;
-			fields["connect"] = {
+			if (filters && offers("connect")) fields["connect"] = {
 				type: listOf(filters),
 				description: `Link every existing ${targetTypeName} row these match. Already-linked rows are left alone.`
 			};
-			if (forUpdate) {
-				fields["disconnect"] = {
-					type: listOf(filters),
-					description: `Unlink every linked ${targetTypeName} row these match, leaving the rows in place`
-				};
-				fields["set"] = {
-					type: listOf(filters),
-					description: `Replace the whole set: unlink everything linked, then link every ${targetTypeName} row these match. \`set: []\` clears the relation. Applied before \`disconnect\` and \`connect\`.`
-				};
-			}
+			if (filters && forUpdate && offers("disconnect")) fields["disconnect"] = {
+				type: listOf(filters),
+				description: `Unlink every linked ${targetTypeName} row these match, leaving the rows in place`
+			};
+			if (filters && forUpdate && offers("set")) fields["set"] = {
+				type: listOf(filters),
+				description: `Replace the whole set: unlink everything linked, then link every ${targetTypeName} row these match. \`set: []\` clears the relation. Applied before \`disconnect\` and \`connect\`.`
+			};
 		} else if (plan.isOne) {
-			fields["create"] = {
+			if (offers("create")) fields["create"] = {
 				type: payloadType(tableName, typeName, plan),
 				description: `Insert a ${targetTypeName} row and attach it`
 			};
-			if (filters) fields["connect"] = {
+			if (filters && offers("connect")) fields["connect"] = {
 				type: filters,
 				description: `Attach the existing ${targetTypeName} row this matches. Must match exactly one row.`
 			};
-			if (forUpdate && plan.canDetach) fields["disconnect"] = {
+			if (forUpdate && offers("disconnect")) fields["disconnect"] = {
 				type: GraphQLBoolean,
 				description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
 			};
 		} else {
-			fields["create"] = {
+			if (offers("create")) fields["create"] = {
 				type: listOf(payloadType(tableName, typeName, plan)),
 				description: `Insert these ${targetTypeName} rows and attach them`
 			};
-			if (filters) {
-				fields["connect"] = {
-					type: listOf(filters),
-					description: `Attach every existing ${targetTypeName} row these match`
-				};
-				if (forUpdate && plan.canDetach) {
-					fields["disconnect"] = {
-						type: listOf(filters),
-						description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
-					};
-					fields["set"] = {
-						type: listOf(filters),
-						description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
-					};
-				}
-			}
+			if (filters && offers("connect")) fields["connect"] = {
+				type: listOf(filters),
+				description: `Attach every existing ${targetTypeName} row these match`
+			};
+			if (filters && forUpdate && offers("disconnect")) fields["disconnect"] = {
+				type: listOf(filters),
+				description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
+			};
+			if (filters && forUpdate && offers("set")) fields["set"] = {
+				type: listOf(filters),
+				description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
+			};
 		}
+		if (!Object.keys(fields).length) return;
 		const type = new GraphQLInputObjectType({
 			name: cacheCtx.typeName({
 				kind: "nestedWriteInput",
@@ -6122,7 +6505,7 @@ const createNestedWriteTypes = (params) => {
 			const tablePlans = plans[tableName];
 			if (!tablePlans) return NO_COLUMNS;
 			const relaxed = /* @__PURE__ */ new Set();
-			for (const plan of Object.values(tablePlans)) if (plan.fkSide === "parent" && !isOptionalOnInsert(plan.localCol)) relaxed.add(plan.localColPropName);
+			for (const plan of Object.values(tablePlans)) if (plan.fkSide === "parent" && (plan.allowed.has("create") || plan.allowed.has("connect")) && !isOptionalOnInsert(plan.localCol)) relaxed.add(plan.localColPropName);
 			return relaxed.size ? relaxed : NO_COLUMNS;
 		}
 	};
@@ -6133,8 +6516,99 @@ const createNestedWriteTypes = (params) => {
 */
 const mergedOps = (entries) => Object.assign({}, ...entries.map((entry) => entry.ops));
 const asArray = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+const supplied = (value) => value !== void 0 && value !== null;
+/**
+* The hook calls one relation field makes. Every step is registered before the field's first
+* statement, so each `before` runs ahead of all of them and each `after` once the last has
+* returned. A table without hooks registers nothing, and its statements run exactly as they
+* did before hooks reached nested writes — no RETURNING clause is added.
+*/
+const createHookSteps = (onWrite, executor, request, parentTable, plan) => {
+	const steps = /* @__PURE__ */ new Map();
+	const keyOf = (op, operation) => `${op}:${operation}`;
+	const payload = (step) => ({
+		table: step.tableName,
+		operation: step.operation,
+		single: plan.isOne,
+		args: request?.args,
+		context: request?.context,
+		info: request?.info,
+		tx: executor,
+		nested: {
+			parentTable,
+			relation: plan.relationName,
+			op: step.op
+		}
+	});
+	return {
+		/** Registers the hook call for `op`'s `operation` statements, if that table has hooks. */
+		add: (op, operation) => {
+			const through = plan.through;
+			const tableName = through ? through.tableName : plan.targetTableName;
+			const hooks = tableName ? onWrite?.(tableName, operation) : void 0;
+			if (!tableName || !hooks || steps.has(keyOf(op, operation))) return;
+			const keyColumns = through ? {
+				[through.sourceColPropName]: through.sourceCol,
+				[through.targetColPropName]: through.targetCol
+			} : { ...plan.targetKeyColumns };
+			steps.set(keyOf(op, operation), {
+				tableName,
+				operation,
+				op,
+				hooks,
+				returning: withHookColumns(hooks, keyColumns).returning,
+				rows: []
+			});
+		},
+		get: (op, operation) => steps.get(keyOf(op, operation)),
+		/** Runs one statement, returning its rows to the step it belongs to when there is one. */
+		run: async (query, op, operation) => {
+			const step = steps.get(keyOf(op, operation));
+			if (!step) {
+				await query;
+				return;
+			}
+			step.rows.push(...await query.returning(step.returning));
+		},
+		before: async () => {
+			for (const step of steps.values()) await runWriteHook(step.hooks, "before", payload(step));
+		},
+		after: async () => {
+			for (const step of steps.values()) await runWriteHook(step.hooks, "after", {
+				...payload(step),
+				rows: step.rows
+			});
+		}
+	};
+};
+/**
+* Registers the hook calls a child-side relation field will make, in the order its
+* statements run, so the `before` hooks fire in that order too. Mirrors the branches of
+* `applyChildSide` and `applyThroughOps` exactly: a step registered for an input that runs no
+* statement would fire with no rows, and one missing would miss them.
+*/
+const registerChildSteps = (steps, plan, op) => {
+	if (plan.through) {
+		if (supplied(op["set"])) {
+			steps.add("set", "delete");
+			steps.add("set", "insert");
+		}
+		if (supplied(op["disconnect"])) steps.add("disconnect", "delete");
+		if (supplied(op["connect"])) steps.add("connect", "insert");
+		return;
+	}
+	if (op["set"] !== void 0) steps.add("set", "update");
+	if (op["disconnect"] !== void 0 && (!plan.isOne || op["disconnect"] === true)) steps.add("disconnect", "update");
+	const attachedBy = attachingOp(op);
+	if (plan.isOne && attachedBy && plan.canDetach && op["set"] === void 0) steps.add(attachedBy, "update");
+	if (op["connect"] !== void 0) steps.add("connect", "update");
+	if (op["create"] !== void 0) steps.add("create", "insert");
+};
+/** The input that attaches a row to a to-one, which detaches whatever was attached before. */
+const attachingOp = (op) => op["connect"] !== void 0 ? "connect" : op["create"] !== void 0 ? "create" : void 0;
 const createNestedWriteRuntime = (params) => {
 	const { plans, filterCtx, policies, contextValues } = params;
+	const onWrite = policies?.onWrite;
 	/**
 	* A `connect` / `disconnect` / `set` operand compiled to SQL. An operand that compiles to
 	* nothing is rejected: `connect: {}` would otherwise attach every row in the table.
@@ -6145,12 +6619,12 @@ const createNestedWriteRuntime = (params) => {
 		return withScope(scope, plan.targetTableName, plan.targetTable, condition);
 	};
 	const assertSingleOperation = (plan, op) => {
-		const supplied = [
+		const given = [
 			"create",
 			"connect",
 			"disconnect"
-		].filter((key) => op[key] !== void 0 && op[key] !== null);
-		if (supplied.length > 1) throw drizzleError(`Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time — it holds a single row.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
+		].filter((key) => supplied(op[key]));
+		if (given.length > 1) throw drizzleError(`Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${given.join(", ")} at a time — it holds a single row.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 	};
 	/** The values the junction stores for the target rows one operand selects. */
 	const selectedTargetKeys = async (executor, plan, filter, operation, scope) => {
@@ -6165,9 +6639,8 @@ const createNestedWriteRuntime = (params) => {
 	* error on some of them — the read and the write share the surrounding transaction, so no
 	* other writer can slip a duplicate in between them.
 	*/
-	const applyThroughOps = async (executor, plan, key, op, scope) => {
+	const applyThroughOps = async (executor, plan, key, op, scope, steps) => {
 		const through = plan.through;
-		const unlinkAll = () => executor.delete(through.table).where(eq(through.sourceCol, key));
 		const link = async (operands, operation) => {
 			const existing = new Set((await executor.select({ [through.targetColPropName]: through.targetCol }).from(through.table).where(eq(through.sourceCol, key))).map((row) => row[through.targetColPropName]));
 			const rows = [];
@@ -6178,19 +6651,19 @@ const createNestedWriteRuntime = (params) => {
 					[through.targetColPropName]: targetKey
 				});
 			}
-			if (rows.length) await executor.insert(through.table).values(rows);
+			if (rows.length) await steps.run(executor.insert(through.table).values(rows), operation, "insert");
 		};
-		if (op["set"] !== void 0 && op["set"] !== null) {
-			await unlinkAll();
+		if (supplied(op["set"])) {
+			await steps.run(executor.delete(through.table).where(eq(through.sourceCol, key)), "set", "delete");
 			await link(asArray(op["set"]), "set");
 		}
-		if (op["disconnect"] !== void 0 && op["disconnect"] !== null) for (const filter of asArray(op["disconnect"])) {
+		if (supplied(op["disconnect"])) for (const filter of asArray(op["disconnect"])) {
 			const targetKeys = await selectedTargetKeys(executor, plan, filter, "disconnect", scope);
-			if (targetKeys.length) await executor.delete(through.table).where(and(eq(through.sourceCol, key), inArray(through.targetCol, targetKeys)));
+			if (targetKeys.length) await steps.run(executor.delete(through.table).where(and(eq(through.sourceCol, key), inArray(through.targetCol, targetKeys))), "disconnect", "delete");
 		}
-		if (op["connect"] !== void 0 && op["connect"] !== null) await link(asArray(op["connect"]), "connect");
+		if (supplied(op["connect"])) await link(asArray(op["connect"]), "connect");
 	};
-	const detachAll = async (executor, plan, key, scope) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq(plan.foreignCol, key)));
+	const detachAll = (executor, plan, key, scope, steps, op) => steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(withScope(scope, plan.targetTableName, plan.targetTable, eq(plan.foreignCol, key))), op, "update");
 	return {
 		enabled: (tableName) => !!plans[tableName],
 		split: (tableName, values) => {
@@ -6219,19 +6692,27 @@ const createNestedWriteRuntime = (params) => {
 			}
 			return columns;
 		},
-		applyParentSide: async (executor, tableName, ops, context) => {
+		applyParentSide: async (executor, tableName, ops, request) => {
 			const tablePlans = plans[tableName];
 			const patch = {};
 			if (!tablePlans) return patch;
+			const context = request?.context;
 			const scope = resolveScope(policies, context, filterCtx);
 			for (const [relationName, op] of Object.entries(ops)) {
 				const plan = tablePlans[relationName];
 				if (plan?.fkSide !== "parent") continue;
 				assertSingleOperation(plan, op);
 				if (op["create"] !== void 0) {
+					const steps = createHookSteps(onWrite, executor, request, tableName, plan);
+					steps.add("create", "insert");
+					await steps.before();
 					const values = applyContextValues(remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable), contextValues?.(plan.targetTableName), context);
-					const created = (await executor.insert(plan.targetTable).values(values).returning({ [plan.foreignColPropName]: plan.foreignCol }))[0];
+					const step = steps.get("create", "insert");
+					const inserted = await executor.insert(plan.targetTable).values(values).returning(step ? step.returning : { [plan.foreignColPropName]: plan.foreignCol });
+					step?.rows.push(...inserted);
+					const created = inserted[0];
 					if (!created) throw drizzleError(`Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
+					await steps.after();
 					patch[plan.localColPropName] = created[plan.foreignColPropName];
 				} else if (op["connect"] !== void 0) {
 					const rows = await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
@@ -6241,41 +6722,46 @@ const createNestedWriteRuntime = (params) => {
 			}
 			return patch;
 		},
-		applyChildSide: async (executor, tableName, ops, parentRows, context) => {
+		applyChildSide: async (executor, tableName, ops, parentRows, request) => {
 			const tablePlans = plans[tableName];
 			if (!tablePlans) return;
+			const context = request?.context;
 			const scope = resolveScope(policies, context, filterCtx);
 			for (const [relationName, op] of Object.entries(ops)) {
 				const plan = tablePlans[relationName];
 				if (plan?.fkSide !== "child") continue;
 				if (plan.isOne) assertSingleOperation(plan, op);
+				const steps = createHookSteps(onWrite, executor, request, tableName, plan);
+				registerChildSteps(steps, plan, op);
+				await steps.before();
 				for (const parentRow of parentRows) {
 					const key = parentRow?.[plan.localColPropName];
 					if (key === void 0 || key === null) throw drizzleError(`Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					if (plan.through) {
-						await applyThroughOps(executor, plan, key, op, scope);
+						await applyThroughOps(executor, plan, key, op, scope, steps);
 						continue;
 					}
 					if (op["set"] !== void 0) {
-						await detachAll(executor, plan, key, scope);
-						for (const filter of asArray(op["set"])) await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope));
+						await detachAll(executor, plan, key, scope, steps, "set");
+						for (const filter of asArray(op["set"])) await steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set", scope)), "set", "update");
 					}
 					if (op["disconnect"] !== void 0) {
 						if (plan.isOne) {
-							if (op["disconnect"] === true) await detachAll(executor, plan, key, scope);
-						} else for (const filter of asArray(op["disconnect"])) await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and(eq(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope)));
+							if (op["disconnect"] === true) await detachAll(executor, plan, key, scope, steps, "disconnect");
+						} else for (const filter of asArray(op["disconnect"])) await steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where(and(eq(plan.foreignCol, key), conditionOf(plan, filter, "disconnect", scope))), "disconnect", "update");
 					}
-					const attaches = op["connect"] !== void 0 || op["create"] !== void 0;
-					if (plan.isOne && attaches && plan.canDetach && op["set"] === void 0) await detachAll(executor, plan, key, scope);
-					if (op["connect"] !== void 0) for (const filter of asArray(op["connect"])) await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope));
+					const attachedBy = attachingOp(op);
+					if (plan.isOne && attachedBy && plan.canDetach && op["set"] === void 0) await detachAll(executor, plan, key, scope, steps, attachedBy);
+					if (op["connect"] !== void 0) for (const filter of asArray(op["connect"])) await steps.run(executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect", scope)), "connect", "update");
 					if (op["create"] !== void 0) {
 						const rows = asArray(op["create"]).map((row) => ({
 							...applyContextValues(remapFromGraphQLSingleInput({ ...row }, plan.targetTable), contextValues?.(plan.targetTableName), context),
 							[plan.foreignColPropName]: key
 						}));
-						if (rows.length) await executor.insert(plan.targetTable).values(rows);
+						if (rows.length) await steps.run(executor.insert(plan.targetTable).values(rows), "create", "insert");
 					}
 				}
+				await steps.after();
 			}
 		}
 	};
@@ -6285,21 +6771,25 @@ const createNestedWriteRuntime = (params) => {
 * inside a single transaction — a savepoint when the caller already runs on one, so a failing
 * entry rolls the whole batch back.
 *
+* That transaction is also the `tx` the target tables' `onWrite` hooks run on. Every nested
+* write opens it, so a hook on a nested target has the whole tree to roll back even when the
+* root field carries no hook of its own and was not forced into a transaction for one.
+*
 * Entries are written one at a time rather than as a single multi-row statement: a nested
 * operation attaches to the row its own entry produced, so the two have to stay correlated.
 * The batch path is untouched when no entry carries a nested operation.
 */
 const writeWithNestedOps = async (params) => {
-	const { executor, runtime, tableName, entries, remapValues, write, context } = params;
+	const { executor, runtime, tableName, entries, remapValues, write, request } = params;
 	return executor.transaction(async (tx) => {
 		const rows = [];
 		for (const entry of entries) {
-			const patch = await runtime.applyParentSide(tx, tableName, entry.ops, context);
+			const patch = await runtime.applyParentSide(tx, tableName, entry.ops, request);
 			const written = await write(tx, {
 				...remapValues(entry.columns),
 				...patch
 			});
-			await runtime.applyChildSide(tx, tableName, entry.ops, written, context);
+			await runtime.applyChildSide(tx, tableName, entry.ops, written, request);
 			rows.push(...written);
 		}
 		return rows;
@@ -6311,14 +6801,14 @@ const writeWithNestedOps = async (params) => {
 * attaches to each row that came back.
 */
 const updateWithNestedOps = async (params) => {
-	const { executor, runtime, tableName, columns, ops, remapValues, write, context } = params;
+	const { executor, runtime, tableName, columns, ops, remapValues, write, request } = params;
 	return executor.transaction(async (tx) => {
-		const patch = await runtime.applyParentSide(tx, tableName, ops, context);
+		const patch = await runtime.applyParentSide(tx, tableName, ops, request);
 		const rows = await write(tx, {
 			...remapValues(columns),
 			...patch
 		});
-		await runtime.applyChildSide(tx, tableName, ops, rows, context);
+		await runtime.applyChildSide(tx, tableName, ops, rows, request);
 		return rows;
 	});
 };
@@ -6519,7 +7009,14 @@ const createSchemaBuilder = (adapter) => {
 			uniqueKeysOf: (tableName) => uniqueKeys[tableName]
 		};
 		adapter.preflight?.(db, options);
-		const nestedPlans = features.nestedWrites ? buildNestedWritePlans(tables, namedRelations, (target) => uniqueColumnSets(target), (target) => primaryKeyPropNames(target), extractRelationJoinColumns) : void 0;
+		const nestedPlans = features.nestedWrites ? buildNestedWritePlans(tables, namedRelations, (target) => uniqueColumnSets(target), (target) => primaryKeyPropNames(target), extractRelationJoinColumns, (junction) => schemaEntries.find(([, value]) => value === junction)?.[0]) : void 0;
+		if (nestedPlans) {
+			const omitted = gateNestedWritePlans(nestedPlans, featureOf, (tableName) => excludedTables.has(tableName));
+			if (omitted.length) {
+				const listed = omitted.length > 5 ? `${omitted.slice(0, 5).join(", ")} and ${omitted.length - 5} more` : omitted.join(", ");
+				console.warn(`Drizzle-GraphQL Warning: config.features — nestedWrites leaves out the nested inputs whose table has that write turned off: ${listed}.`);
+			}
+		}
 		const nestedTypes = nestedPlans ? createNestedWriteTypes({
 			plans: nestedPlans,
 			cacheCtx,
@@ -7192,7 +7689,11 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					entries: nestedEntries,
 					remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
 					write: (tx, values) => runInsert(tx, [values]),
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				}) : await runInsert(executor, input);
 				await after(written);
 				const result = output(written);
@@ -7281,7 +7782,11 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					entries: nestedEntries,
 					remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
 					write: (tx, values) => runUpsert(tx, [values]),
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				}) : await runUpsert(executor, input);
 				await after(written);
 				const result = output(written);
@@ -7354,7 +7859,11 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					ops: nestedOps,
 					remapValues: (values) => values,
 					write: runUpdate,
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				}) : await runUpdate(executor, input);
 				await after(written);
 				const result = output(written);
@@ -7784,18 +8293,18 @@ const createSchemaDataGenerator = (adapter) => {
 * the shared multi-mutation transaction opened by `runMutation` — this opens a savepoint, so
 * the batch stays atomic without breaking the outer transaction.
 */
-const runUpdateManyBatch = ({ executor, entries, table, returning, nested, tableName, context }) => executor.transaction(async (tx) => {
+const runUpdateManyBatch = ({ executor, entries, table, returning, nested, tableName, request }) => executor.transaction(async (tx) => {
 	const results = [];
 	for (const entry of entries) {
 		const values = entry.ops ? {
 			...entry.set,
-			...await nested.applyParentSide(tx, tableName, entry.ops, context)
+			...await nested.applyParentSide(tx, tableName, entry.ops, request)
 		} : entry.set;
 		const writes = Object.keys(values).length > 0;
 		let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
 		if (entry.filters) query = query.where(entry.filters);
 		const rows = await (writes ? query.returning(returning) : query);
-		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, request);
 		results.push(rows);
 	}
 	return results;
@@ -7868,7 +8377,11 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					anyNested,
 					nested,
 					tableName,
-					context
+					request: {
+						context,
+						args,
+						info
+					}
 				});
 				const written = perEntry.flat();
 				await after(written);
@@ -7917,7 +8430,7 @@ const sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(ta
 * would run after the COMMIT. The driver kind is probed from the first statement's result
 * rather than declared, so the same resolver serves both driver families.
 */
-const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNested, nested, tableName, context }) => {
+const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNested, nested, tableName, request }) => {
 	const runEntry = (tx, entry) => {
 		let query = tx.update(table).set(entry.set);
 		if (entry.filters) query = query.where(entry.filters);
@@ -7926,13 +8439,13 @@ const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNest
 	const runNestedEntry = async (tx, entry) => {
 		const values = entry.ops ? {
 			...entry.set,
-			...await nested.applyParentSide(tx, tableName, entry.ops, context)
+			...await nested.applyParentSide(tx, tableName, entry.ops, request)
 		} : entry.set;
 		const writes = Object.keys(values).length > 0;
 		let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
 		if (entry.filters) query = query.where(entry.filters);
 		const rows = await (writes ? query.returning(returning) : query);
-		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, context);
+		if (entry.ops) await nested.applyChildSide(tx, tableName, entry.ops, rows, request);
 		return rows;
 	};
 	return executor.transaction((tx) => {