@vantreeseba/drizzle-graphql 15.1.5 → 16.0.0

package/dist/index.js

@@ -1,7 +1,7 @@
-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, MySqlDate, MySqlDateString, MySqlDateTime, MySqlDateTimeString, MySqlInt, MySqlSerial, MySqlTable, MySqlTimestamp, MySqlTimestampString, getTableConfig } from "drizzle-orm/mysql-core";
+import { Column, One, SQL, Subquery, 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, MySqlDate, MySqlDateString, MySqlDateTime, MySqlDateTimeString, MySqlEnumColumn, MySqlEnumObjectColumn, 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, SQLiteTimestamp, getTableConfig as getTableConfig$2 } from "drizzle-orm/sqlite-core";
+import { SQLiteAsyncDatabase, 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, getNamedType } from "graphql";
 import { GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
 import pluralize from "pluralize";
@@ -262,7 +262,6 @@ 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",
@@ -288,8 +287,15 @@ const declaredEnum = (column) => {
 		schema: typeof declared.schema === "string" ? declared.schema : void 0
 	} : void 0;
 };
-/** `user_status` / `user-status` / `user status` → `UserStatus`; an already-PascalCase name is left alone. */
-const pascalize = (input) => input.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => capitalize(part)).join("");
+/**
+* `user_status` / `user-status` / `user status` → `UserStatus`; an already-PascalCase name is left
+* alone. A GraphQL name cannot start with a digit, so a name that would (`2fa_mode`) is prefixed
+* with an underscore: `_2faMode`.
+*/
+const pascalize = (input) => {
+	const pascal = input.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => capitalize(part)).join("");
+	return /^[0-9]/.test(pascal) ? `_${pascal}` : pascal;
+};
 /**
 * Identity of the values a GraphQL enum was built from, so a name claimed twice can be told
 * apart from the same enum reached twice.
@@ -364,7 +370,7 @@ const generateEnumCached = (column, columnName, tableName) => {
 			index,
 			typeName: name
 		});
-		if (mapped === void 0) return allowedNameChars.test(value) ? value : `Option${index}`;
+		if (mapped === void 0) return validEnumValueName(value) ? value : `Option${index}`;
 		if (!validEnumValueName(mapped)) throw new Error(`Drizzle-GraphQL Error: config.enumValueNameMapper named value '${value}' of enum '${name}' (on '${tableName}.${columnName}') '${mapped}', which is not a valid GraphQL enum value name. A name must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ and not be true, false or null.`);
 		return mapped;
 	});
@@ -460,6 +466,27 @@ const sqliteTimestampToDate = (column, value) => new Date(column.mode === "times
 * 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);
+/**
+* Whether the column holds raw bytes: Postgres `bytea` and SQLite `blob({ mode: 'buffer' })`,
+* both `object buffer` in drizzle v1. Their values are `[Int!]` lists of the bytes.
+*/
+const isBufferColumn = (column) => (column.dataType ?? "").endsWith(" buffer");
+/**
+* Whether the column is a float tuple or vector: drizzle v1 gives every such column an
+* `array …` data type — `point` / `line` in tuple mode (`array point`, `array line`), PostGIS
+* `geometry` in tuple mode, pgvector `vector` and `halfvec`. Each value is one list of numbers,
+* typed `[Float!]`, not a database array of elements.
+*/
+const isFloatTupleColumn = (column) => (column.dataType ?? "").startsWith("array ");
+/** The fixed length of a float tuple column's values, or `undefined` for a vector. */
+const floatTupleLength = (column) => {
+	switch (column.dataType) {
+		case "array point":
+		case "array geometry": return 2;
+		case "array line": return 3;
+		default: return;
+	}
+};
 const columnToGraphQLCore = (column, columnName, tableName, isInput) => {
 	const dimensions = column.dimensions;
 	if (dimensions !== void 0 && dimensions > 0) {
@@ -497,7 +524,7 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 			return column.columnType === "PgGeometryObject" ? {
 				type: isInput ? geoXyInputType : geoXyType,
 				typeLabel: "Geometry points XY"
-			} : column.columnType === "PgBytea" ? {
+			} : isBufferColumn(column) ? {
 				type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
 				typeLabel: "Buffer"
 			} : {
@@ -530,7 +557,7 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 			type: GraphQLBigIntString,
 			typeLabel: "BigInt"
 		};
-		case "number": return constraint !== void 0 && smallIntegerConstraints.has(constraint) || 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) ? {
 			type: GraphQLInt,
 			typeLabel: "Integer"
 		} : {
@@ -538,18 +565,10 @@ const columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
 			typeLabel: "Float"
 		};
 		case "array": {
-			if (column.columnType === "PgVector") return {
-				type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
-				typeLabel: "Array<Float>"
-			};
-			if (column.columnType === "PgGeometry") return {
-				type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
-				typeLabel: "Tuple<[Float, Float]>"
-			};
-			const innerType = columnToGraphQLCore(column.baseColumn, columnName, tableName, isInput);
+			const length = floatTupleLength(column);
 			return {
-				type: new GraphQLList(new GraphQLNonNull(innerType.type)),
-				typeLabel: `Array<${innerType.typeLabel}>`
+				type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+				typeLabel: length === void 0 ? "Array<Float>" : `Tuple<[${Array(length).fill("Float").join(", ")}]>`
 			};
 		}
 		default: throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
@@ -691,6 +710,18 @@ const columnDialect = (column) => {
 */
 const isJsonColumn = (column) => (column.dataType ?? "").includes("json") && column.columnType !== "PgGeometryObject";
 /**
+* SQLite `blob({ mode: 'bigint' })`: the bigint is stored as the bytes of its decimal text, and
+* SQLite compares blobs byte by byte, so `9` sorts above `10`. Equality still holds, so it can be
+* grouped and made distinct on, but not ordered or given a min/max.
+*/
+const isSqliteBlobBigIntColumn = (column) => column.columnType === "SQLiteBigInt";
+/**
+* Whether `orderBy` (and so cursor pagination) offers a column. JSON has no meaningful order:
+* PostgreSQL `json` cannot be ordered at all, and MySQL's JSON ordering disagrees with any
+* keyset comparison a cursor could make. A SQLite blob bigint orders as text.
+*/
+const isOrderableColumn = (column) => !isJsonColumn(column) && !isSqliteBlobBigIntColumn(column);
+/**
 * Maps a Drizzle column to the generic filter type to use.
 *
 * Selection is keyed on the column's data type, never its name: a text column named
@@ -1197,6 +1228,36 @@ const pgTimestampTextToIso = (value) => {
 	const utc = (/* @__PURE__ */ new Date(wallMs - offsetSeconds * 1e3)).toISOString();
 	return utc.length === 24 ? `${utc.slice(0, 19)}${fraction}Z` : value;
 };
+/** Marks a decoder installed by {@link installSqliteBlobJsonDecoders}, so a rebuild never wraps it twice. */
+const BLOB_JSON_DECODER = Symbol.for("drizzle-graphql.sqliteBlobJsonDecoder");
+/**
+* Gives SQLite's blob columns a decoder for the relational query builder's JSON path, so a NULL
+* there reads back as null.
+*
+* Inside a nested relation drizzle selects a blob as `hex(column)` (JSON cannot hold a blob), and
+* `hex(NULL)` is `''`. drizzle then decodes that `''` with the column's ordinary decoder: a
+* `blob({ mode: 'bigint' })` reads it as `0n` — indistinguishable from a stored 0 — and a
+* `blob({ mode: 'json' })` throws on it. drizzle consults a column's `mapFromJsonValue`, when it
+* has one, instead of `mapFromDriverValue` for exactly this path, so one is installed here that
+* reads `''` as NULL and hands everything else to the column's own decoder.
+*
+* `''` is never a stored bigint or JSON blob, so for those it can only be NULL. For a buffer
+* blob it is also how an empty blob arrives, so it is read as NULL only when the column is
+* nullable — a `notNull` column cannot hold the NULL, so there it is the empty blob.
+*/
+const installSqliteBlobJsonDecoders = (tables) => {
+	for (const table of Object.values(tables)) for (const column of Object.values(getColumns(table))) {
+		const columnType = column.columnType ?? "";
+		const isBuffer = columnType === "SQLiteBlobBuffer";
+		if (columnType !== "SQLiteBigInt" && columnType !== "SQLiteBlobJson" && !isBuffer) continue;
+		const existing = column.mapFromJsonValue;
+		if (existing && !existing[BLOB_JSON_DECODER]) continue;
+		const emptyIsNull = !isBuffer || !column.notNull;
+		const decoder = (value) => value === "" && emptyIsNull ? null : column.mapFromDriverValue(value);
+		decoder[BLOB_JSON_DECODER] = true;
+		column.mapFromJsonValue = decoder;
+	}
+};
 const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 	if (Array.isArray(value)) {
 		const relations = relationMap?.[tableName];
@@ -1223,18 +1284,51 @@ const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
 	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 (value instanceof Uint8Array) return Array.from(value);
 	if (typeof value === "bigint") return value.toString();
 	if (Array.isArray(value)) {
-		if (column.columnType === "PgGeometry" || column.columnType === "PgVector") return value;
+		if (isFloatTupleColumn(column)) return value;
 		return value.map((arrVal) => remapToGraphQLCore(key, arrVal, tableName, column, relationMap));
 	}
 	if (typeof value === "object" && value !== null) {
-		if (column.columnType === "PgGeometryObject") return value;
+		if ((column.dataType ?? "").startsWith("object")) return value;
 		return JSON.stringify(value);
 	}
 	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)) {
@@ -1248,11 +1342,9 @@ const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap)
 			continue;
 		}
 		const column = columns[key];
-		if (value === 0n && column && column.columnType === "SQLiteBigInt" && !column.notNull) {
-			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;
 };
@@ -1269,6 +1361,7 @@ const remapFromGraphQLCore = (value, column, columnName) => {
 	const dataType = column.dataType ?? "";
 	const columnType = column.columnType ?? "";
 	if (isDateTimeColumn(column)) {
+		if (Array.isArray(value)) return value.map((element) => remapFromGraphQLCore(element, column, columnName));
 		const isMySql = columnType.startsWith("MySql");
 		const isPgString = isPgTimestampStringColumn(column);
 		const toIso = isMySql ? mySqlDateTimeTextToIso : isPgString ? pgTimestampTextToIso : void 0;
@@ -1283,41 +1376,29 @@ const remapFromGraphQLCore = (value, column, columnName) => {
 		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);
-	} catch {
-		throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-	}
-	if (dataType.includes("json") && column.columnType !== "PgGeometryObject") return value;
-	switch (dataType) {
-		case "date": {
-			const formatted = new Date(value);
-			if (Number.isNaN(formatted.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			return formatted;
-		}
-		case "buffer":
-			if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			return Buffer.from(value);
-		case "json":
-			if (column.columnType === "PgGeometryObject") return value;
-			try {
-				return JSON.parse(value);
-			} catch (e) {
-				throw drizzleError(`Invalid JSON in field '${columnName}':\n${e instanceof Error ? e.message : "Unknown error"}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			}
-		case "array":
-			if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			if (column.columnType === "PgGeometry" && value.length !== 2) throw drizzleError(`Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			return value;
-		case "bigint": try {
+	if (dataType.includes("bigint")) {
+		if (Array.isArray(value)) return value.map((element) => remapFromGraphQLCore(element, column, columnName));
+		try {
 			return BigInt(value);
-		} catch (_error) {
+		} catch {
 			throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
 		}
-		default:
-			if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === null) return Object.assign({}, value);
-			return value;
 	}
+	if (isJsonColumn(column)) return value;
+	if (isBufferColumn(column)) {
+		if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		if (column.dimensions > 0 && value.every((element) => element === null || Array.isArray(element))) return value.map((element) => remapFromGraphQLCore(element, column, columnName));
+		if (!value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) throw drizzleError(`Field '${columnName}' is not a list of bytes! Expected integers from 0 to 255.`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		return Buffer.from(value);
+	}
+	if (isFloatTupleColumn(column)) {
+		if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		const length = floatTupleLength(column);
+		if (length !== void 0 && value.length !== length) throw drizzleError(`Invalid float tuple in field '${columnName}': expected array with length of ${length}, received ${value.length}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		return value;
+	}
+	if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === null) return Object.assign({}, value);
+	return value;
 };
 const remapFromGraphQLSingleInput = (queryInput, table, operation = "insert") => {
 	const columns = getColumns(table);
@@ -1359,36 +1440,60 @@ const escapeLikeValue = (value) => value.replace(/[\\%_]/g, (char) => `\\${char}
 const safeLikeOps = {
 	startsWith: {
 		buildPattern: (value) => `${escapeLikeValue(value)}%`,
+		buildGlob: (value) => `${escapeGlobValue(value)}*`,
 		insensitive: false
 	},
 	endsWith: {
 		buildPattern: (value) => `%${escapeLikeValue(value)}`,
+		buildGlob: (value) => `*${escapeGlobValue(value)}`,
 		insensitive: false
 	},
 	contains: {
 		buildPattern: (value) => `%${escapeLikeValue(value)}%`,
+		buildGlob: (value) => `*${escapeGlobValue(value)}*`,
 		insensitive: false
 	},
 	iStartsWith: {
 		buildPattern: (value) => `${escapeLikeValue(value)}%`,
+		buildGlob: (value) => `${escapeGlobValue(value)}*`,
 		insensitive: true
 	},
 	iEndsWith: {
 		buildPattern: (value) => `%${escapeLikeValue(value)}`,
+		buildGlob: (value) => `*${escapeGlobValue(value)}`,
 		insensitive: true
 	},
 	iContains: {
 		buildPattern: (value) => `%${escapeLikeValue(value)}%`,
+		buildGlob: (value) => `*${escapeGlobValue(value)}*`,
 		insensitive: true
 	}
 };
 /**
-* `LIKE <pattern> ESCAPE '\'` for a safe string operator. Case-insensitive variants use
-* Postgres's native `ILIKE`; MySQL and SQLite have no `ILIKE`, so they compare `lower()`
-* on both sides instead (mirroring how the raw `ilike` operator is Postgres-only).
+* Escapes SQLite's `GLOB` wildcards (`*`, `?`, `[`) in a literal search term by wrapping each in
+* a one-character class, so the term only ever matches literally inside a GLOB pattern. GLOB
+* has no escape character; `]` outside a class and everything else is already literal.
 */
-const safeLikeCondition = (column, pattern, insensitive) => {
-	if (!insensitive) return sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
+const escapeGlobValue = (value) => value.replace(/[*?[]/g, (char) => `[${char}]`);
+/**
+* A caller-written LIKE pattern as the GLOB pattern matching the same strings, for SQLite's
+* case-sensitive `like` / `notLike`: `%` → `*`, `_` → `?`, and GLOB's own wildcards escaped.
+* The raw operators bind no `ESCAPE` clause, so `\` is an ordinary character in both.
+*/
+const likePatternToGlob = (pattern) => pattern.replace(/[%_*?[]/g, (char) => char === "%" ? "*" : char === "_" ? "?" : `[${char}]`);
+/**
+* The safe string operator's predicate. Case-insensitive variants use Postgres's native
+* `ILIKE`; MySQL and SQLite have no `ILIKE`, so they compare `lower()` on both sides instead
+* (mirroring how the raw `ilike` operator is Postgres-only).
+*
+* The case-sensitive variants are `LIKE <pattern> ESCAPE '\'`, except on SQLite, whose `LIKE`
+* folds ASCII case — `contains: "App"` would match `apple`. There they are `GLOB`, which is
+* case-sensitive, as `LIKE` is on Postgres. `dialectColumn` names the column the dialect is read
+* from when `column` is an expression over it (a JSON path read).
+*/
+const safeLikeCondition = (column, value, op, insensitive, dialectColumn = column) => {
+	const pattern = op.buildPattern(value);
+	if (!insensitive) return columnDialect(dialectColumn) === "sqlite" ? sql`${column} glob ${op.buildGlob(value)}` : sql`${column} like ${pattern} escape ${LIKE_ESCAPE_CHAR}`;
 	return (column.columnType ?? "").startsWith("Pg") ? sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : sql`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
 };
 /**
@@ -1444,6 +1549,35 @@ const jsonContains = (column, columnName, value) => {
 	}
 };
 /**
+* The nodes of a SQLite JSON document as `(path, kind, value)` rows, for a structural
+* comparison. Integers and reals share one kind so `1` and `1.0` are the same number, as they
+* are on the other two dialects.
+*/
+const sqliteJsonNodes = (document) => sql`select fullkey, case when type in ('integer', 'real') then 'number' else type end, atom from json_tree(${document})`;
+/**
+* Whole-document `eq` / `ne` on a JSON column, comparing documents rather than their text:
+* - Postgres: as `jsonb` (a plain `json` column has no `=` operator at all)
+* - MySQL: against `CAST(? AS JSON)`; a bare string parameter would be a JSON string scalar
+* - SQLite: the two documents' node sets must match both ways, so object key order and
+*   whitespace do not matter, while array order still does
+* A SQL NULL column matches neither, as with `=` / `<>` on any other column.
+*/
+const jsonEquality = (column, columnName, value, negated) => {
+	const serialized = JSON.stringify(value);
+	switch (columnDialect(column)) {
+		case "pg": {
+			const left = column.columnType === "PgJson" ? sql`${column}::jsonb` : sql`${column}`;
+			return negated ? sql`${left} <> ${serialized}::jsonb` : sql`${left} = ${serialized}::jsonb`;
+		}
+		case "mysql": return negated ? sql`${column} <> cast(${serialized} as json)` : sql`${column} = cast(${serialized} as json)`;
+		case "sqlite": {
+			const equal = sql`(not exists (${sqliteJsonNodes(column)} except ${sqliteJsonNodes(serialized)}) and not exists (${sqliteJsonNodes(serialized)} except ${sqliteJsonNodes(column)}))`;
+			return negated ? sql`(${column} is not null and not ${equal})` : sql`(${column} is not null and ${equal})`;
+		}
+		default: throw drizzleError(`WHERE ${columnName}: JSON equality is not supported for this dialect!`, { code: "DRIZZLE_INVALID_FILTER" });
+	}
+};
+/**
 * Constant predicates, used where an operator's operand list is empty and the answer is
 * therefore known without touching the column. Written as `1 = 0` / `1 = 1` rather than the
 * `FALSE` / `TRUE` keywords so they compile identically on all three dialects. Built fresh
@@ -1478,7 +1612,8 @@ const NUMERIC_TEXT_PATTERN = "^\\s*-?(\\d+\\.?\\d*|\\.\\d+)([eE][-+]?\\d+)?\\s*$
 *   pattern guard.
 * - **SQLite** — `json_extract` returns the value in SQLite's own type, so the reads cast
 *   explicitly: without that, SQLite's cross-type ordering puts every string above every
-*   number and `'admin' > 0` would be true.
+*   number and `'admin' > 0` would be true. A JSON boolean comes back as 1 / 0, so every read
+*   also checks `json_type` to keep booleans and numbers apart.
 */
 const jsonPathExprs = (column, path) => {
 	switch (columnDialect(column)) {
@@ -1504,10 +1639,11 @@ const jsonPathExprs = (column, path) => {
 		}
 		default: {
 			const extracted = sql`json_extract(${column}, ${jsonPathString(path)})`;
+			const type = sql`json_type(${column}, ${jsonPathString(path)})`;
 			return {
-				text: sql`cast(${extracted} as text)`,
-				number: sql`(case when typeof(${extracted}) in ('integer', 'real') then ${extracted} end)`,
-				boolean: extracted,
+				text: sql`(case ${type} when 'true' then 'true' when 'false' then 'false' else cast(${extracted} as text) end)`,
+				number: sql`(case when ${type} in ('integer', 'real') then ${extracted} end)`,
+				boolean: sql`(case when ${type} in ('true', 'false') then ${extracted} end)`,
 				encodeBoolean: (value) => value ? 1 : 0
 			};
 		}
@@ -1546,9 +1682,9 @@ const jsonPathCondition = (column, columnName, filter) => {
 			continue;
 		}
 		if (operatorName in safeLikeOps) {
-			const { buildPattern, insensitive } = safeLikeOps[operatorName];
+			const op = safeLikeOps[operatorName];
 			if (typeof operatorValue !== "string") throw drizzleError(`WHERE ${locator}: operator '${operatorName}' takes a string`, { code: "DRIZZLE_INVALID_FILTER" });
-			variants.push(safeLikeCondition(exprs.text, buildPattern(operatorValue), insensitive));
+			variants.push(safeLikeCondition(exprs.text, operatorValue, op, op.insensitive, column));
 			continue;
 		}
 		const comparison = JSON_PATH_COMPARISONS[operatorName];
@@ -1606,20 +1742,25 @@ const extractFiltersColumn = (column, columnName, operators) => {
 	for (const [operatorName, operatorValue] of entries) {
 		if (operatorValue === null || operatorValue === void 0) continue;
 		if (operatorValue === false && FLAG_OPERATORS.has(operatorName)) continue;
-		if (operatorName in singleValueOps) {
+		if ((operatorName === "eq" || operatorName === "ne") && isJsonColumn(column)) variants.push(jsonEquality(column, columnName, operatorValue, operatorName === "ne"));
+		else if (operatorName in singleValueOps) {
 			const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
 			variants.push(foldCase ? lowerComparison(column, operatorName, singleValue) : singleValueOps[operatorName](column, singleValue));
 		} else if (operatorName in stringValueOps) {
-			const insensitivePattern = foldCase && (operatorName === "like" || operatorName === "notLike");
-			variants.push(insensitivePattern ? insensitiveLike(column, operatorValue, operatorName === "notLike") : stringValueOps[operatorName](column, operatorValue));
+			const isLike = operatorName === "like" || operatorName === "notLike";
+			if (isLike && foldCase || (operatorName === "ilike" || operatorName === "notIlike") && columnDialect(column) !== "pg") variants.push(insensitiveLike(column, operatorValue, operatorName === "notLike" || operatorName === "notIlike"));
+			else if (isLike && columnDialect(column) === "sqlite") {
+				const glob = likePatternToGlob(operatorValue);
+				variants.push(operatorName === "like" ? sql`${column} glob ${glob}` : sql`${column} not glob ${glob}`);
+			} else variants.push(stringValueOps[operatorName](column, operatorValue));
 		} else if (operatorName === "path" && isJsonColumn(column)) for (const pathFilter of operatorValue) {
 			const extracted = jsonPathCondition(column, columnName, pathFilter);
 			if (extracted) variants.push(extracted);
 		}
 		else if (operatorName === "contains" && isJsonColumn(column)) variants.push(jsonContains(column, columnName, operatorValue));
 		else if (operatorName in safeLikeOps) {
-			const { buildPattern, insensitive: alwaysInsensitive } = safeLikeOps[operatorName];
-			variants.push(safeLikeCondition(column, buildPattern(operatorValue), alwaysInsensitive || foldCase));
+			const op = safeLikeOps[operatorName];
+			variants.push(safeLikeCondition(column, operatorValue, op, op.insensitive || foldCase));
 		} else if (operatorName in arrayValueOps) {
 			if (!operatorValue.length) {
 				variants.push(operatorName === "inArray" ? sqlFalse() : sqlTrue());
@@ -1627,13 +1768,13 @@ const extractFiltersColumn = (column, columnName, operators) => {
 			}
 			const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
 			variants.push(foldCase ? lowerMembership(column, arrayValue, operatorName === "notInArray") : arrayValueOps[operatorName](column, arrayValue));
-		} else if (operatorName === "has") variants.push(arrayContains(column, [operatorValue]));
+		} else if (operatorName === "has") variants.push(arrayContains(column, [remapFromGraphQLCore(operatorValue, column, columnName)]));
 		else if (operatorName in arrayMembershipOps) {
 			if (!operatorValue.length) {
 				variants.push(operatorName === "hasSome" ? sqlFalse() : sqlTrue());
 				continue;
 			}
-			variants.push(arrayMembershipOps[operatorName](column, operatorValue));
+			variants.push(arrayMembershipOps[operatorName](column, operatorValue.map((element) => remapFromGraphQLCore(element, column, columnName))));
 		} else if (operatorName === "isEmpty") variants.push(sql`cardinality(${column}) = 0`);
 		else if (operatorName in nullableOps) variants.push(nullableOps[operatorName](column));
 		else throw drizzleError(`WHERE ${columnName}: Unknown operator: ${operatorName}`, { code: "DRIZZLE_INVALID_FILTER" });
@@ -1831,17 +1972,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
@@ -2394,6 +2622,32 @@ const withScope = (scope, tableName, table, condition, mode) => {
 	const predicate = scope?.on(tableName, table, mode);
 	return predicate ? and(condition, predicate) : condition;
 };
+/**
+* The junction table a `.through()` relation links through, by its schema key — the key its
+* `scope` and `softDelete` are configured under. `undefined` for a relation with no junction,
+* or a junction that is not one of the build's tables.
+*/
+const junctionTableName = (tables, relEntry) => {
+	const throughTable = (relEntry?.relation ?? relEntry)?.throughTable;
+	return throughTable ? Object.keys(tables).find((name) => tables[name] === throughTable) : void 0;
+};
+/**
+* Whether a `.through()` relation's junction restricts which links exist for this request —
+* a `scope` on the junction table, or a soft delete it declares.
+*/
+const hasJunctionPolicy = (scope, junctionName) => !!junctionName && !!scope?.has(junctionName, "EXCLUDE");
+/**
+* The junction's own row policy, compiled against the junction table as the query names it.
+* A `.through()` relation links only through the junction rows this keeps, on every path that
+* reads the relation — the relation field, `<relation>Aggregate`, and a relation filter — so
+* they all agree on which rows are related.
+*
+* The junction is always read at `EXCLUDE`: a marked junction row is a removed link. The
+* relation's `deleted` argument is about the *target* rows, and the junction's own
+* `softDelete.scope` only governs reads of the junction table's own fields — a link row has no
+* field of its own on the relation that `'root'` could keep rendering.
+*/
+const junctionPolicy = (scope, junctionName, table) => hasJunctionPolicy(scope, junctionName) ? scope.on(junctionName, table, "EXCLUDE") : void 0;
 /** Binds a build's {@link TablePolicies} to its relation context, once, at schema-build time. */
 const bindPolicies = (policies, filterCtx) => policies?.scope || policies?.contextValues || policies?.softDelete || policies?.onWrite || policies?.defaultOrderBy ? {
 	scope: policies.scope || policies.softDelete ? (context) => resolveScope(policies, context, filterCtx) : void 0,
@@ -2444,7 +2698,7 @@ const deletedArg = (softDelete, tableName, resolveName) => softDelete?.(tableNam
 const selectArrayArgs = (orderArgs, filterArgs, distinctEnum, softDelete, tableName, resolveName) => ({
 	offset: { type: GraphQLInt },
 	limit: { type: GraphQLInt },
-	orderBy: { type: orderArgs },
+	...orderArgs ? { orderBy: { type: orderArgs } } : {},
 	where: { type: filterArgs },
 	after: {
 		type: GraphQLString,
@@ -2456,7 +2710,7 @@ const selectArrayArgs = (orderArgs, filterArgs, distinctEnum, softDelete, tableN
 /** GraphQL argument map for a single-row select field (no `limit`). */
 const selectSingleArgs = (orderArgs, filterArgs, softDelete, tableName, resolveName) => ({
 	offset: { type: GraphQLInt },
-	orderBy: { type: orderArgs },
+	...orderArgs ? { orderBy: { type: orderArgs } } : {},
 	where: { type: filterArgs },
 	...deletedArg(softDelete, tableName, resolveName)
 });
@@ -2506,7 +2760,7 @@ const generateDistinctEnum = (table, typeName, resolveName, tableKey) => {
 		defaultName,
 		table: tableKey,
 		operation: "distinct"
-	}) ?? defaultName, `Columns of ${typeName} that a query can be made distinct on`);
+	}) ?? defaultName, `Columns of ${typeName} that a query can be made distinct on`, (column) => !isJsonColumn(column));
 };
 //#endregion
 //#region src/util/builders/common/conflict.ts
@@ -2676,6 +2930,44 @@ const resolveConflictPlan = (params) => {
 		plan
 	}));
 };
+/**
+* Adds a {@link ConflictPlan}'s clause to a PostgreSQL or SQLite insert.
+*
+* SQLite needs two things drizzle's builder does not give it when the target is a partial
+* unique index:
+*
+* - The index predicate written literally. SQLite matches a conflict target to an index by
+*   comparing the predicates as written, and a bound `?` never equals `'active'`, so a
+*   predicate that compares to a value would never find its index. Its params are inlined.
+* - A `DO NOTHING` it can parse. Drizzle writes the predicate after `do nothing`, which is a
+*   syntax error, so the action is spelled as an update that matches no row instead:
+*   `ON CONFLICT (…) WHERE … DO UPDATE SET col = col WHERE 0 = 1`. A row that is not updated is
+*   not returned, which is what `DO NOTHING` does too.
+*/
+const applyConflictPlan = (query, table, plan, setWhere) => {
+	const sqlite = is(table, SQLiteTable);
+	const targetWhere = sqlite && plan.targetWhere ? sql`${plan.targetWhere}`.inlineParams() : plan.targetWhere;
+	if (plan.action === "UPDATE") return query.onConflictDoUpdate({
+		target: plan.target,
+		targetWhere,
+		set: plan.set,
+		setWhere
+	});
+	if (!plan.target) return query.onConflictDoNothing();
+	if (sqlite && targetWhere) {
+		const [key] = Object.entries(getColumns(table)).find(([, column]) => column === plan.target[0]);
+		return query.onConflictDoUpdate({
+			target: plan.target,
+			targetWhere,
+			set: { [key]: sql`${plan.target[0]}` },
+			setWhere: sql`0 = 1`
+		});
+	}
+	return query.onConflictDoNothing({
+		target: plan.target,
+		where: targetWhere
+	});
+};
 /** `excluded.<column>` — PostgreSQL and SQLite name the rejected row this way. */
 const excludedColumnRef = (columnName) => sql`excluded.${sql.identifier(columnName)}`;
 /** `values(<column>)` — MySQL's equivalent inside ON DUPLICATE KEY UPDATE. */
@@ -2957,6 +3249,21 @@ const decodeCursor = (after, entries) => {
 	return payload.v.map(decodeCursorValue);
 };
 /**
+* `col > value` (asc) or `col < value` (desc), compared by the rule the ORDER BY sorts by.
+* MySQL sorts an ENUM by its declaration index but compares it with a string as a string, so
+* there the comparison is between `col + 0` (the 1-based index) and the value's own index.
+*/
+const strictComparison = (col, direction, value) => {
+	if (is(col, MySqlEnumColumn) || is(col, MySqlEnumObjectColumn)) {
+		const index = col.enumValues?.indexOf(value) ?? -1;
+		if (index >= 0) {
+			const position = sql`(${col} + 0)`;
+			return direction === "asc" ? sql`${position} > ${index + 1}` : sql`${position} < ${index + 1}`;
+		}
+	}
+	return direction === "asc" ? gt(col, value) : lt(col, value);
+};
+/**
 * The keyset predicate selecting rows strictly after the cursor position in the given total
 * order — the expanded lexicographic form
 * `after(k0) OR (k0 = v0 AND after(k1)) OR (k0 = v0 AND k1 = v1 AND after(k2)) …`,
@@ -2981,7 +3288,7 @@ const buildCursorCondition = (table, entries, values, nullOrdering) => {
 		let strictlyAfter;
 		if (value === null || value === void 0) strictlyAfter = nullsSortLast ? void 0 : isNotNull(col);
 		else {
-			const comparison = direction === "asc" ? gt(col, value) : lt(col, value);
+			const comparison = strictComparison(col, direction, value);
 			strictlyAfter = nullsSortLast ? or(comparison, isNull(col)) : comparison;
 		}
 		if (strictlyAfter) disjuncts.push(equalities.length ? and(...equalities, strictlyAfter) : strictlyAfter);
@@ -3184,6 +3491,115 @@ const getUniqueTargets = (table, getTableConfig) => {
 */
 const getUniqueColumnSets = (table, getTableConfig, options = {}) => getUniqueTargets(table, getTableConfig).filter((target) => options.partial || !target.where).map((target) => target.columns);
 //#endregion
+//#region src/util/builders/common/limits.ts
+/**
+* The `limit` to send with an `offset` the request gave without one. SQLite and MySQL accept
+* `OFFSET` only after a `LIMIT`, so `offset` alone has to carry a limit that means "all of
+* them": SQLite reads `LIMIT -1` that way, and on MySQL it is the largest integer every driver
+* binds exactly (MySQL's own documented 2^64-1 does not fit a JS number). PostgreSQL takes
+* `OFFSET` alone, so the limit is left as it was.
+*/
+const offsetOnlyLimit = (table, limit, offset) => {
+	if (limit != null || !offset) return limit;
+	const firstColumn = Object.values(getColumns(table))[0];
+	switch (firstColumn ? columnDialect(firstColumn) : void 0) {
+		case "sqlite": return -1;
+		case "mysql": return Number.MAX_SAFE_INTEGER;
+		default: return limit;
+	}
+};
+/**
+* Substitutes a table's default ordering for an absent `orderBy`.
+*
+* Applied where the arguments are first read, so everything downstream — the cursor tuple, a
+* `distinct` pass, the plain-select fallback — sees one effective ordering and cannot
+* disagree about it. Only a missing argument is replaced: `orderBy: {}` is a request for no
+* ordering, and stays one.
+*/
+const withDefaultOrderBy = (args, tableName, defaults) => {
+	if (!defaults || args?.orderBy != null) return args;
+	const fallback = defaults(tableName);
+	return fallback ? {
+		...args,
+		orderBy: fallback
+	} : args;
+};
+/**
+* Rejects a negative `limit` or `offset`. Neither is a page size or a position, and the
+* dialects disagree on what one means: SQLite reads `LIMIT -1` as "no limit" — which would walk
+* straight past `maxLimit` — while PostgreSQL and MySQL fail with a raw database error. Applied
+* whether or not the table has a limit policy.
+*/
+const assertPagingNotNegative = (paging, errorCtx) => {
+	for (const name of ["limit", "offset"]) {
+		const value = paging[name];
+		if (value != null && value < 0) throw drizzleError(`'${name}' must not be negative, got ${value}.`, {
+			code: "DRIZZLE_INVALID_INPUT_VALUE",
+			...errorCtx
+		});
+	}
+};
+/**
+* The `limit` a query actually runs with, given the policy for the table it reads.
+*
+* A request that passes no `limit` falls back to `defaultLimit`, or to `maxLimit` when only
+* that is configured — an absent limit means every row, which is above any maximum. A limit
+* the client did ask for is rejected when it exceeds `maxLimit`, since silently truncating a
+* page tells a paginating client it has reached the end when it has not; `clampToMax` opts
+* into the truncation instead. A limit the *policy* supplied is capped rather than rejected —
+* a misconfigured `defaultLimit` above `maxLimit` is the operator's problem, not something to
+* fail a client's query over.
+*/
+const applyLimitPolicy = (limit, policy, errorCtx) => {
+	assertPagingNotNegative({ limit }, errorCtx);
+	if (!policy) return limit ?? void 0;
+	const { defaultLimit, maxLimit, clampToMax } = policy;
+	if (limit == null) {
+		const fallback = defaultLimit ?? maxLimit;
+		if (fallback === void 0) return;
+		return maxLimit === void 0 ? fallback : Math.min(fallback, maxLimit);
+	}
+	if (maxLimit !== void 0 && limit > maxLimit) {
+		if (clampToMax) return maxLimit;
+		throw drizzleError(`'limit' of ${limit} exceeds the maximum of ${maxLimit}.`, {
+			code: "DRIZZLE_LIMIT_EXCEEDED",
+			...errorCtx
+		});
+	}
+	return limit;
+};
+/** Merges a per-table override over the global policy, or `undefined` when neither bounds anything. */
+const resolveLimitPolicy = (global, table) => {
+	const defaultLimit = table?.defaultLimit ?? global?.defaultLimit;
+	const maxLimit = table?.maxLimit ?? global?.maxLimit;
+	if (defaultLimit === void 0 && maxLimit === void 0) return;
+	return {
+		defaultLimit,
+		maxLimit,
+		clampToMax: table?.clampToMax ?? global?.clampToMax ?? false
+	};
+};
+/**
+* A paginated field costs its page size times whatever one row of it costs, so `users(limit: 100)
+* { posts(limit: 10) { id } }` is charged for the thousand rows it can return rather than the two
+* fields it mentions. `childComplexity` floors at 1 so a row is never free.
+*
+* The page size is the *effective* one: a request without `limit` is priced at the policy's
+* `defaultLimit` (or its `maxLimit` when that is all it sets) rather than the estimator's guess, and no request is priced above `maxLimit`,
+* so the cost a query is charged matches the rows it can actually pull.
+*/
+const listFieldComplexity = (options, policy) => ({ args, childComplexity }) => {
+	const limit = args["limit"];
+	let rows = (typeof limit === "number" && limit > 0 ? limit : void 0) ?? policy?.defaultLimit ?? policy?.maxLimit ?? options.defaultListSize;
+	if (policy?.maxLimit !== void 0) rows = Math.min(rows, policy.maxLimit);
+	return rows * Math.max(childComplexity, 1);
+};
+/**
+* An aggregate returns a single row but reads however many match, so its cost tracks the scan
+* rather than the response.
+*/
+const aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
+//#endregion
 //#region src/util/builders/common/distinct.ts
 /**
 * Alias the parent key comes back under when the pass runs through a junction table. See
@@ -3231,13 +3647,15 @@ const selectDistinctKeys = async (params) => {
 		...junction ? { [DISTINCT_PARENT]: sub[DISTINCT_PARENT] } : {}
 	}).from(sub).where(eq(sub[DISTINCT_RN], 1)).orderBy(...outerOrder);
 	if (offset) query = query.offset(offset);
-	if (limit != null) query = query.limit(limit);
+	const effectiveLimit = offsetOnlyLimit(table, limit, offset);
+	if (effectiveLimit != null) query = query.limit(effectiveLimit < 0 ? sql`${effectiveLimit}` : effectiveLimit);
 	return await query;
 };
 /**
 * Condition matching exactly the rows identified by `keys` — an `IN (…)` for a single-column
-* primary key, an `OR` of per-row equality for a composite one. `table` may be the aliased
-* RQB proxy.
+* primary key, an `OR` of per-row equality for a composite one — nested as a balanced tree, so
+* thousands of keys stay within SQLite's expression-depth limit. `table` may be the aliased RQB
+* proxy.
 */
 const primaryKeyRestriction = (table, pkNames, keys) => {
 	const cols = getColumns(table);
@@ -3245,7 +3663,7 @@ const primaryKeyRestriction = (table, pkNames, keys) => {
 		const name = pkNames[0];
 		return inArray(cols[name], keys.map((key) => key[name]));
 	}
-	return or(...keys.map((key) => and(...pkNames.map((name) => eq(cols[name], key[name])))));
+	return balancedOr(keys.map((key) => and(...pkNames.map((name) => eq(cols[name], key[name])))));
 };
 //#endregion
 //#region src/util/builders/common/docs.ts
@@ -3391,99 +3809,6 @@ const innerOrderType = (typeName) => sharedType(typeName, {
 	}
 }));
 //#endregion
-//#region src/util/builders/common/limits.ts
-/**
-* Substitutes a table's default ordering for an absent `orderBy`.
-*
-* Applied where the arguments are first read, so everything downstream — the cursor tuple, a
-* `distinct` pass, the plain-select fallback — sees one effective ordering and cannot
-* disagree about it. Only a missing argument is replaced: `orderBy: {}` is a request for no
-* ordering, and stays one.
-*/
-const withDefaultOrderBy = (args, tableName, defaults) => {
-	if (!defaults || args?.orderBy != null) return args;
-	const fallback = defaults(tableName);
-	return fallback ? {
-		...args,
-		orderBy: fallback
-	} : args;
-};
-/**
-* Rejects a negative `limit` or `offset`. Neither is a page size or a position, and the
-* dialects disagree on what one means: SQLite reads `LIMIT -1` as "no limit" — which would walk
-* straight past `maxLimit` — while PostgreSQL and MySQL fail with a raw database error. Applied
-* whether or not the table has a limit policy.
-*/
-const assertPagingNotNegative = (paging, errorCtx) => {
-	for (const name of ["limit", "offset"]) {
-		const value = paging[name];
-		if (value != null && value < 0) throw drizzleError(`'${name}' must not be negative, got ${value}.`, {
-			code: "DRIZZLE_INVALID_INPUT_VALUE",
-			...errorCtx
-		});
-	}
-};
-/**
-* The `limit` a query actually runs with, given the policy for the table it reads.
-*
-* A request that passes no `limit` falls back to `defaultLimit`, or to `maxLimit` when only
-* that is configured — an absent limit means every row, which is above any maximum. A limit
-* the client did ask for is rejected when it exceeds `maxLimit`, since silently truncating a
-* page tells a paginating client it has reached the end when it has not; `clampToMax` opts
-* into the truncation instead. A limit the *policy* supplied is capped rather than rejected —
-* a misconfigured `defaultLimit` above `maxLimit` is the operator's problem, not something to
-* fail a client's query over.
-*/
-const applyLimitPolicy = (limit, policy, errorCtx) => {
-	assertPagingNotNegative({ limit }, errorCtx);
-	if (!policy) return limit ?? void 0;
-	const { defaultLimit, maxLimit, clampToMax } = policy;
-	if (limit == null) {
-		const fallback = defaultLimit ?? maxLimit;
-		if (fallback === void 0) return;
-		return maxLimit === void 0 ? fallback : Math.min(fallback, maxLimit);
-	}
-	if (maxLimit !== void 0 && limit > maxLimit) {
-		if (clampToMax) return maxLimit;
-		throw drizzleError(`'limit' of ${limit} exceeds the maximum of ${maxLimit}.`, {
-			code: "DRIZZLE_LIMIT_EXCEEDED",
-			...errorCtx
-		});
-	}
-	return limit;
-};
-/** Merges a per-table override over the global policy, or `undefined` when neither bounds anything. */
-const resolveLimitPolicy = (global, table) => {
-	const defaultLimit = table?.defaultLimit ?? global?.defaultLimit;
-	const maxLimit = table?.maxLimit ?? global?.maxLimit;
-	if (defaultLimit === void 0 && maxLimit === void 0) return;
-	return {
-		defaultLimit,
-		maxLimit,
-		clampToMax: table?.clampToMax ?? global?.clampToMax ?? false
-	};
-};
-/**
-* A paginated field costs its page size times whatever one row of it costs, so `users(limit: 100)
-* { posts(limit: 10) { id } }` is charged for the thousand rows it can return rather than the two
-* fields it mentions. `childComplexity` floors at 1 so a row is never free.
-*
-* The page size is the *effective* one: a request without `limit` is priced at the policy's
-* `defaultLimit` rather than the estimator's guess, and no request is priced above `maxLimit`,
-* so the cost a query is charged matches the rows it can actually pull.
-*/
-const listFieldComplexity = (options, policy) => ({ args, childComplexity }) => {
-	const limit = args["limit"];
-	let rows = (typeof limit === "number" && limit > 0 ? limit : void 0) ?? policy?.defaultLimit ?? options.defaultListSize;
-	if (policy?.maxLimit !== void 0) rows = Math.min(rows, policy.maxLimit);
-	return rows * Math.max(childComplexity, 1);
-};
-/**
-* An aggregate returns a single row but reads however many match, so its cost tracks the scan
-* rather than the response.
-*/
-const aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
-//#endregion
 //#region src/util/parse-resolve-info.ts
 /** Unwraps `[T]!`-style wrappers down to the named type. `getNamedType` without the realm tie. */
 const namedTypeOf = (type) => {
@@ -3647,14 +3972,10 @@ const NUMERIC_SCALARS = /* @__PURE__ */ new Set([
 ]);
 /**
 * Column types that convert to a GraphQL list without being a list *in the database* —
-* a bytea reads as `[Int]`, a vector and a geometry point as `[Float]` — so appending to
-* them is not the operation `push` means.
+* a bytea or SQLite buffer blob reads as `[Int]`, a vector, a point or a line as `[Float]` —
+* so appending to them is not the operation `push` means.
 */
-const NON_LIST_ARRAY_COLUMNS = /* @__PURE__ */ new Set([
-	"PgVector",
-	"PgGeometry",
-	"PgBytea"
-]);
+const isNonListArrayColumn = (column) => isFloatTupleColumn(column) || isBufferColumn(column);
 const kindCache = /* @__PURE__ */ new WeakMap();
 /**
 * Whether a column takes an operations input, and which one.
@@ -3671,7 +3992,7 @@ const fieldUpdateKind = (column, columnName, tableName) => {
 	if (!getColumnScalarOverride(column, true)) {
 		const { type } = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
 		if (NUMERIC_SCALARS.has(type)) kind = "numeric";
-		else if (type instanceof GraphQLList && !NON_LIST_ARRAY_COLUMNS.has(column.columnType)) kind = "list";
+		else if (type instanceof GraphQLList && !isNonListArrayColumn(column)) kind = "list";
 	}
 	kindCache.set(column, kind);
 	return kind;
@@ -3942,6 +4263,16 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		if (!relFieldSelection) continue;
 		const eagerArgs = field.args;
 		if (!is(relEntry.relation ?? relEntry, One) && (eagerArgs?.after != null || !!(eagerArgs?.distinct)?.length || isCursorFieldSelected(relFieldSelection, tables[targetTableName]))) continue;
+		const junctionName = junctionTableName(tables, relEntry);
+		if (hasJunctionPolicy(scope, junctionName)) {
+			if (!extractJunctionColumns(relEntry)) throw drizzleError(`Relation '${tableName}.${relName}' goes through '${junctionName}', which has a scope or soft delete, over a composite key. Its links can only be filtered when the junction joins on one column per side.`, {
+				code: "DRIZZLE_UNSUPPORTED_RELATION",
+				table: tableName,
+				operation: "relation",
+				relation: relName
+			});
+			continue;
+		}
 		const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName], {
 			tableName: targetTableName,
 			relationMap,
@@ -3967,9 +4298,11 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		thisRecord.where = relWhere || scope?.has(targetTableName, relDeleted) ? { RAW: (aliasedTable) => withScope(scope, targetTableName, aliasedTable, relWhere ? extractFilters(aliasedTable, relName, relWhere, relationFilterCtx(filterCtx, targetTableName, scope)) : void 0, relDeleted) } : void 0;
 		const hasPagination = offset != null || limit != null;
 		const pkNames = targetPkNames ?? [];
-		thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName, scope), relWhere) : hasPagination && pkNames.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0;
+		const tiebreak = hasPagination && pkNames.length > 0;
+		const requestOrder = relationArgs?.orderBy;
+		thisRecord.orderBy = requestOrder || tiebreak ? (aliasedTable) => [...requestOrder ? extractOrderBy(aliasedTable, requestOrder, relationFilterCtx(filterCtx, targetTableName, scope), relWhere) : [], ...tiebreak ? primaryKeyOrderExprs(aliasedTable, pkNames) : []] : void 0;
 		thisRecord.offset = offset;
-		thisRecord.limit = limit;
+		thisRecord.limit = offsetOnlyLimit(tables[targetTableName], limit, offset);
 		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, field, relTypeName, options);
 		args[relName] = omitUndefinedKeys(thisRecord);
 	}
@@ -4060,7 +4393,7 @@ const runRelationalSelect = async (opts) => {
 		const preciseProps = Object.keys(cursorPreciseExtras(table, cursorEntries));
 		if (preciseProps.length) params.extras = Object.fromEntries(preciseProps.map((prop) => [prop, (aliasedTable) => cursorPreciseExtras(aliasedTable, cursorEntries)[prop]]));
 	}
-	params.limit = distinctKeys ? void 0 : opts.limit;
+	params.limit = distinctKeys ? void 0 : offsetOnlyLimit(table, opts.limit, offset);
 	const result = await queryBase.findMany(omitUndefinedKeys(params));
 	if (cursorEntries && cursorSelected) attachRowCursors(result, cursorEntries);
 	return remapToGraphQLArrayOutput(result, tableName, table, relationMap);
@@ -4117,6 +4450,8 @@ const eagerLoadMutationRelations = async (db, tableName, rows, pkNames, withPara
 	}
 	return rows;
 };
+/** The longest delay `setTimeout` honours; anything above, Infinity included, fires after 1 ms. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
 const createMutationTxCtx = (options) => options ? {
 	timeoutMs: options.timeoutMs,
 	fieldNames: /* @__PURE__ */ new Set(),
@@ -4143,28 +4478,28 @@ const includedByDirectives = (node, variables) => {
 * this build did not generate — its completion cannot be tracked, so the caller must not
 * open a transaction it might never be able to close.
 */
-const collectRootMutationKeys = (selectionSet, fragments, variables, known, keys, visitedFragments) => {
+const collectRootMutationKeys = (selectionSet, fragments, variables, known, keys, visitedFragments, argumentsCoerce) => {
 	for (const selection of selectionSet.selections) {
 		if (!includedByDirectives(selection, variables)) continue;
 		if (selection.kind === "Field") {
 			const name = selection.name.value;
 			if (name === "__typename") continue;
 			if (!known.has(name)) return false;
-			keys.add(selection.alias?.value ?? name);
+			if (argumentsCoerce(selection)) keys.add(selection.alias?.value ?? name);
 		} else if (selection.kind === "InlineFragment") {
-			if (!collectRootMutationKeys(selection.selectionSet, fragments, variables, known, keys, visitedFragments)) return false;
+			if (!collectRootMutationKeys(selection.selectionSet, fragments, variables, known, keys, visitedFragments, argumentsCoerce)) return false;
 		} else if (selection.kind === "FragmentSpread") {
 			const fragmentName = selection.name.value;
 			if (visitedFragments.has(fragmentName)) continue;
 			visitedFragments.add(fragmentName);
 			const fragment = fragments?.[fragmentName];
 			if (!fragment) return false;
-			if (!collectRootMutationKeys(fragment.selectionSet, fragments, variables, known, keys, visitedFragments)) return false;
+			if (!collectRootMutationKeys(fragment.selectionSet, fragments, variables, known, keys, visitedFragments, argumentsCoerce)) return false;
 		}
 	}
 	return true;
 };
-const abortedBatchError = () => drizzleError("Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back.", { code: "DRIZZLE_TRANSACTION_ABORTED" });
+const abortedBatchError = (state, timeoutMs) => drizzleError(state.timedOut ? `Drizzle-GraphQL Error: Mutation was not executed because the shared transaction timed out after ${timeoutMs}ms waiting for the remaining mutation fields and was rolled back.` : "Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back.", { code: "DRIZZLE_TRANSACTION_ABORTED" });
 /** Opens the request-wide transaction and wires up latch, inactivity timer and cleanup. */
 const openSharedTx = (db, context, txCtx, stateKey, expected) => {
 	let release;
@@ -4199,6 +4534,7 @@ const openSharedTx = (db, context, txCtx, stateKey, expected) => {
 		completed: 0,
 		failure: void 0,
 		aborted: false,
+		timedOut: false,
 		done: false,
 		ready,
 		settled,
@@ -4213,8 +4549,9 @@ const openSharedTx = (db, context, txCtx, stateKey, expected) => {
 		suspendTimer: clearTimer,
 		bumpTimer: () => {
 			clearTimer();
-			if (state.done) return;
+			if (state.done || txCtx.timeoutMs === Number.POSITIVE_INFINITY) return;
 			timer = setTimeout(() => {
+				if (!state.aborted) state.timedOut = true;
 				state.abort(drizzleError(`Drizzle-GraphQL Error: Shared mutation transaction timed out after ${txCtx.timeoutMs}ms waiting for the remaining mutation fields; rolling back.`, { code: "DRIZZLE_TRANSACTION_ABORTED" }));
 			}, txCtx.timeoutMs);
 			timer.unref?.();
@@ -4233,15 +4570,15 @@ const openSharedTx = (db, context, txCtx, stateKey, expected) => {
 	state.bumpTimer();
 	return state;
 };
-const runOnSharedTx = async (state, body) => {
+const runOnSharedTx = async (state, timeoutMs, body) => {
 	if (state.aborted) {
 		await state.settled.catch(() => {});
-		throw abortedBatchError();
+		throw abortedBatchError(state, timeoutMs);
 	}
 	state.suspendTimer();
 	const tx = await state.ready;
 	try {
-		if (state.aborted) throw abortedBatchError();
+		if (state.aborted) throw abortedBatchError(state, timeoutMs);
 		const result = await body(tx);
 		state.completed += 1;
 		if (state.completed >= state.expected) {
@@ -4274,14 +4611,24 @@ const runMutation = async (db, context, info, txCtx, body, forceTx) => {
 		if (contextIsObject && context[drizzleExecutorKey]) return body(context[drizzleExecutorKey]);
 		if (!txCtx || info.operation.operation !== "mutation") return forceTx ? db.transaction((tx) => body(tx)) : body(db);
 		const keys = /* @__PURE__ */ new Set();
-		state = !collectRootMutationKeys(info.operation.selectionSet, info.fragments, info.variableValues, txCtx.fieldNames, keys, /* @__PURE__ */ new Set()) || keys.size <= 1 ? { kind: "passthrough" } : openSharedTx(db, context, txCtx, stateKey, keys.size);
+		const mutationFields = info.schema.getMutationType()?.getFields() ?? {};
+		state = !collectRootMutationKeys(info.operation.selectionSet, info.fragments, info.variableValues, txCtx.fieldNames, keys, /* @__PURE__ */ new Set(), (node) => {
+			const fieldDef = mutationFields[node.name.value];
+			if (!fieldDef) return false;
+			try {
+				getArgumentValues(fieldDef, node, info.variableValues);
+				return true;
+			} catch {
+				return false;
+			}
+		}) || keys.size <= 1 ? { kind: "passthrough" } : openSharedTx(db, context, txCtx, stateKey, keys.size);
 		txCtx.states.set(stateKey, state);
 	}
 	if (state.kind === "passthrough") {
 		const executor = resolveExecutor(db, context);
 		return forceTx && executor === db ? db.transaction((tx) => body(tx)) : body(executor);
 	}
-	return runOnSharedTx(state, body);
+	return runOnSharedTx(state, txCtx.timeoutMs, body);
 };
 //#endregion
 //#region src/util/builders/common/write-hooks.ts
@@ -4435,10 +4782,11 @@ const hardDeleteArg = {
 	description: "Remove the matched rows instead of marking them deleted. Reads at `INCLUDE`, so it reaches rows that are already marked; a `scope` still confines what it can reach."
 };
 const prepareMutationRelationColumns = (params) => {
-	const { relationMap, tables, tableName, typeNameMapper, table, pkNames, parsedInfo, resolveName } = params;
+	const { relationMap, filterCtx, tables, tableName, typeNameMapper, table, pkNames, parsedInfo, resolveName } = params;
 	const typeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
 	const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, {
 		typeNameMapper,
+		filterCtx,
 		limits: params.limits,
 		scope: params.scope,
 		defaultOrderBy: params.defaultOrderBy,
@@ -4448,7 +4796,8 @@ const prepareMutationRelationColumns = (params) => {
 	const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table, {
 		tableName,
 		relationMap,
-		tables
+		tables,
+		allRelations: filterCtx?.relationMap
 	});
 	return {
 		columns: hasRelations ? withPrimaryKeyColumns(baseColumns, table, pkNames) : baseColumns,
@@ -4584,7 +4933,7 @@ const assertSingleMatch = async (executor, table, filters) => {
 *   MySQL (no `RETURNING`; its hooks see `rows: []` as on every MySQL mutation), skips the
 *   `RETURNING` and reads the count off the driver's result via {@link rowsAffected}.
 */
-const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested, policies, pkNames = [], returnsRows }) => {
+const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested, policies, pkNames = [], returnsRows, writeFilter }) => {
 	const softDelete = kind === "delete" ? policies?.softDelete?.(tableName) : void 0;
 	const canHardDelete = softDelete?.hardDelete === true;
 	const queryArgs = {
@@ -4627,7 +4976,7 @@ const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, f
 				required: requireWhere,
 				deleted: hard ? "INCLUDE" : void 0
 			});
-			if (filters) query = query.where(filters);
+			if (filters) query = query.where(writeFilter ? writeFilter(filters) : filters);
 			if (!readsRows) {
 				const result = await query;
 				await after();
@@ -4687,27 +5036,40 @@ const getOrCreateLoader = (context, key, batchFn) => {
 	if (!loaders.has(key)) loaders.set(key, new BatchLoader(batchFn));
 	return loaders.get(key);
 };
+const requestCacheNode = () => ({
+	children: /* @__PURE__ */ new WeakMap(),
+	entries: /* @__PURE__ */ new Map()
+});
 /**
 * Memoizes a value that a resolver derives from its own field — its args and its selection —
 * for the length of one request. Resolvers run once per parent row, so anything derived only
 * from the field is otherwise recomputed for every row of a batch.
 *
-* The cache lives on the context (weakly keyed by the AST node the value is derived from, so a
-* document cached across requests never carries values between them) and `key` separates fields
-* that share a node: one fragment selection can resolve for more than one parent type. Without a
-* context object there is nowhere request-scoped to cache, so the value is simply computed.
+* The value is keyed by every AST node of the field — `info.fieldNodes`, the nodes graphql-js
+* merged into this one response field — not only the first. A fragment's field node is the first
+* node wherever the fragment is spread, but the merged selection differs when a sibling selection
+* at one spread site adds to it, so keying on one node would serve one site the other's selection.
+* The nodes are matched by identity, in order, through a chain of weak maps, so a document cached
+* across requests never carries values between them (the root lives on the context), and an array
+* graphql rebuilds per call still hits. `key` separates fields that share nodes: one fragment
+* selection can resolve for more than one parent type. Without a context object, or without
+* nodes, there is nowhere request-scoped to cache, so the value is simply computed.
 *
 * `compute` must not read the parent row.
 */
-const getOrCreateRequestValue = (context, node, key, compute) => {
-	if (!context || typeof context !== "object" || !node || typeof node !== "object") return compute();
-	if (!context[DRIZZLE_REQUEST_CACHE_KEY]) context[DRIZZLE_REQUEST_CACHE_KEY] = /* @__PURE__ */ new WeakMap();
-	const cache = context[DRIZZLE_REQUEST_CACHE_KEY];
-	let entries = cache.get(node);
-	if (!entries) {
-		entries = /* @__PURE__ */ new Map();
-		cache.set(node, entries);
+const getOrCreateRequestValue = (context, nodes, key, compute) => {
+	if (!context || typeof context !== "object" || !Array.isArray(nodes) || !nodes.length || nodes.some((node) => !node || typeof node !== "object")) return compute();
+	if (!context[DRIZZLE_REQUEST_CACHE_KEY]) context[DRIZZLE_REQUEST_CACHE_KEY] = requestCacheNode();
+	let level = context[DRIZZLE_REQUEST_CACHE_KEY];
+	for (const node of nodes) {
+		let next = level.children.get(node);
+		if (!next) {
+			next = requestCacheNode();
+			level.children.set(node, next);
+		}
+		level = next;
 	}
+	const entries = level.entries;
 	if (entries.has(key)) return entries.get(key);
 	const value = compute();
 	entries.set(key, value);
@@ -4937,11 +5299,12 @@ 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);
 	const groupKeys = junction ? [PARENT_KEY] : joinPairs.map((pair) => pair.foreignColPropName);
+	const junctionName = junction ? junctionTableName(tables, relEntry) : void 0;
 	const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, joinPairs.map((pair) => pair.localCol), groupCols);
 	const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, isOne && relEntry.relation?.optional === false);
 	const limitPolicy = isOne ? void 0 : limits?.(targetTableName);
@@ -4983,10 +5346,10 @@ 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}`, () => {
+		const { orderByArg, limit, distinct, cursorEntries, cursorValues, columns, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes, `relation:${tableName}::${relationName}`, () => {
 			const orderByArg = isOne ? args?.orderBy : withDefaultOrderBy(args ?? {}, targetTableName, policies?.defaultOrderBy).orderBy;
 			const limit = applyLimitPolicy(requestedLimit, limitPolicy, errorCtx);
 			assertPagingNotNegative({ offset }, errorCtx);
@@ -5027,55 +5390,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, junction ? junctionPolicy(scope, junctionName, junction.table) : void 0, 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 ? balancedOr(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) => {
@@ -5180,7 +5548,7 @@ const generateTableOrderCached = (table, innerOrder) => {
 	try {
 		const columns = visibleColumns(table);
 		const columnEntries = Object.entries(columns);
-		remapped = Object.fromEntries(columnEntries.map(([columnName, _columnDescription]) => [columnName, { type: innerOrder }]));
+		remapped = Object.fromEntries(columnEntries.filter(([, column]) => isOrderableColumn(column)).map(([columnName]) => [columnName, { type: innerOrder }]));
 		if (cacheable) {
 			let byInnerOrder = orderMap.get(table);
 			if (!byInnerOrder) {
@@ -5223,43 +5591,71 @@ const generateTableSelectTypeFieldsCached = (table, tableName, cacheCtx) => {
 	return remapped;
 };
 /**
+* The to-one relations a table's OrderBy can order through, as `[relationName, targetTableName]`.
+* To-many relations are left out: "order a parent by its many children" has no single defined
+* value to sort on. A relation whose name collides with a column is skipped — the column keeps
+* the name, even one with no ordering of its own, so `extractOrderBy` never reads it as a relation.
+*/
+const orderRelations = (tableName, relationMap, tables) => {
+	const relations = relationMap?.[tableName];
+	const table = tables?.[tableName];
+	if (!relations || !tables || !table) return [];
+	const columns = visibleColumns(table);
+	return Object.entries(relations).filter(([relationName, relEntry]) => {
+		const relation = relEntry.relation ?? relEntry;
+		return !(relationName in columns) && !!tables[relEntry.targetTableName] && is(relation, One) && isFilterableRelation(relation);
+	}).map(([relationName, relEntry]) => [relationName, relEntry.targetTableName]);
+};
+/**
+* Whether a table's OrderBy would have any field: an orderable column of its own, or a to-one
+* relation to a table that has one. A table of nothing but JSON columns has none, and an input
+* object with no fields is an invalid schema, so such a table gets no OrderBy and no `orderBy`
+* argument at all.
+*/
+const hasOrderFields = (tableName, relationMap, tables, visiting = /* @__PURE__ */ new Set()) => {
+	const table = tables[tableName];
+	if (table && Object.values(visibleColumns(table)).some((column) => isOrderableColumn(column))) return true;
+	if (visiting.has(tableName)) return false;
+	visiting.add(tableName);
+	return orderRelations(tableName, relationMap, tables).some(([, target]) => hasOrderFields(target, relationMap, tables, visiting));
+};
+/**
 * Order fields for a table's to-one relations: each takes the target table's own OrderBy
 * input, so a list can be sorted by a related row's column (compiled as a correlated
-* subquery in the ORDER BY — see `extractOrderBy`). To-many relations are left out: "order
-* a parent by its many children" has no single defined value to sort on. A relation whose
-* name collides with a column is skipped — the column keeps the field.
+* subquery in the ORDER BY — see `extractOrderBy`). A target with no OrderBy of its own is
+* left out.
 */
-const generateRelationOrderFields = (tableName, cacheCtx, typeNameMapper, columnFields, relationMap, tables) => {
-	const relations = relationMap?.[tableName];
-	if (!relations || !tables) return {};
+const generateRelationOrderFields = (tableName, cacheCtx, typeNameMapper, relationMap, tables) => {
 	const fields = {};
-	for (const [relationName, relEntry] of Object.entries(relations)) {
-		if (relationName in columnFields) continue;
-		const targetTable = tables[relEntry.targetTableName];
-		const relation = relEntry.relation ?? relEntry;
-		if (!targetTable || !is(relation, One) || !isFilterableRelation(relation)) continue;
-		fields[relationName] = {
-			type: generateTableOrderTypeCached(targetTable, relEntry.targetTableName, typeNameMapper, cacheCtx, relationMap, tables),
+	for (const [relationName, targetTableName] of orderRelations(tableName, relationMap, tables)) {
+		const type = generateTableOrderTypeCached(tables[targetTableName], targetTableName, typeNameMapper, cacheCtx, relationMap, tables);
+		if (type) fields[relationName] = {
+			type,
 			description: `Order by columns of the related ${relationName} row`
 		};
 	}
 	return fields;
 };
+/**
+* The table's `<Type>OrderBy` input, or `undefined` when it would have no fields (see
+* {@link hasOrderFields}); the caller then leaves the `orderBy` argument out.
+*/
 const generateTableOrderTypeCached = (table, tableName, typeNameMapper, cacheCtx, relationMap, tables) => {
 	if (cacheCtx.orderTypeCache.has(table)) return cacheCtx.orderTypeCache.get(table);
+	if (!hasOrderFields(tableName, relationMap, {
+		...tables,
+		[tableName]: table
+	})) return;
 	const order = new GraphQLInputObjectType({
 		name: cacheCtx.typeName({
 			kind: "orderBy",
 			defaultName: `${resolveTypeName(tableName, typeNameMapper)}OrderBy`,
 			table: tableName
 		}),
-		fields: () => {
-			const orderColumns = generateTableOrderCached(table, innerOrderType(cacheCtx.typeName));
-			return {
-				...orderColumns,
-				...generateRelationOrderFields(tableName, cacheCtx, typeNameMapper, orderColumns, relationMap, tables)
-			};
-		}
+		fields: () => ({
+			...generateTableOrderCached(table, innerOrderType(cacheCtx.typeName)),
+			...generateRelationOrderFields(tableName, cacheCtx, typeNameMapper, relationMap, tables)
+		})
 	});
 	cacheCtx.orderTypeCache.set(table, order);
 	return order;
@@ -5478,7 +5874,7 @@ const generateSelectFields = (tables, tableName, relationMap, fromTableName, fro
 				type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(relType))),
 				args: {
 					where: { type: relSelectData.filters },
-					orderBy: { type: relSelectData.order },
+					...relSelectData.order ? { orderBy: { type: relSelectData.order } } : {},
 					offset: { type: GraphQLInt },
 					limit: { type: GraphQLInt },
 					...deletedArg(cacheCtx.softDeleteOf, targetTableName, cacheCtx.typeName),
@@ -5706,6 +6102,7 @@ const resolveBuildConfig = (config, schema) => {
 	};
 	const transactionsOpt = config?.transactions;
 	const transactions = transactionsOpt === void 0 || transactionsOpt === "none" ? void 0 : { timeoutMs: (transactionsOpt === "auto" ? void 0 : transactionsOpt.timeoutMs) ?? 3e4 };
+	if (transactions && transactions.timeoutMs !== Number.POSITIVE_INFINITY && !(Number.isInteger(transactions.timeoutMs) && transactions.timeoutMs >= 1 && transactions.timeoutMs <= MAX_TIMER_MS)) throw new Error(`Drizzle-GraphQL Error: config.transactions.timeoutMs must be a positive integer no greater than ${MAX_TIMER_MS}, or Infinity for no timeout; got ${transactions.timeoutMs}.`);
 	const limitsConfig = config?.limits;
 	if (limitsConfig) {
 		const check = (policy, where) => {
@@ -5738,6 +6135,7 @@ const resolveBuildConfig = (config, schema) => {
 			for (const [columnName, entry] of Object.entries(orderBy)) {
 				if (!columns[columnName]) throw new Error(`Drizzle-GraphQL Error: config.defaults.${tableName}.orderBy names '${columnName}', which is not a column of '${tableName}'.`);
 				if (config?.exclude?.columns?.[tableName]?.includes(columnName)) throw new Error(`Drizzle-GraphQL Error: config.defaults.${tableName}.orderBy names '${columnName}', which config.exclude.columns hides. A default ordering is encoded into every row's cursor, so it can only use columns the schema exposes.`);
+				if (!isOrderableColumn(columns[columnName])) throw new Error(`Drizzle-GraphQL Error: config.defaults.${tableName}.orderBy names '${columnName}', which has no meaningful ordering (a JSON column, or a SQLite blob bigint), so the generated orderBy does not offer it either.`);
 				const direction = typeof entry === "string" ? entry : entry?.direction;
 				if (direction !== "asc" && direction !== "desc") throw new Error(`Drizzle-GraphQL Error: config.defaults.${tableName}.orderBy.${columnName} must be 'asc', 'desc', or { direction, priority? }.`);
 				const priority = typeof entry === "string" ? void 0 : entry?.priority;
@@ -5796,7 +6194,7 @@ const resolveBuildConfig = (config, schema) => {
 			}
 		}
 	}
-	const onWrite = writeHooks.size ? (tableName) => writeHooks.get(tableName) : void 0;
+	const onWrite = [...writeHooks.values()].some(Boolean) ? (tableName) => writeHooks.get(tableName) : void 0;
 	const policies = scopeConfig || contextValuesConfig || softDeleteInfos.size || onWrite || defaultOrderBy ? {
 		scope: scopeConfig ? (tableName) => scopeConfig[tableName] : void 0,
 		contextValues: contextValuesConfig ? (tableName) => contextValuesConfig[tableName] : void 0,
@@ -5887,8 +6285,14 @@ const AGGREGATE_OPS = [
 ];
 /** Ops whose result is a row count: never null, and returned as `Int!` rather than the column's type. */
 const COUNT_OPS = /* @__PURE__ */ new Set(["countNonNull", "countDistinct"]);
+/**
+* `avg`, except on MySQL, where AVG over an integer column is a DECIMAL rounded to
+* `div_precision_increment` (4 by default) digits. Averaging the value as a DOUBLE keeps the
+* fraction the `Float` output promises, as the other two dialects do.
+*/
+const avgOf = (col) => columnDialect(col) === "mysql" ? sql`avg(cast(${col} as double))`.mapWith(String) : avg(col);
 const OP_FNS = {
-	avg,
+	avg: avgOf,
 	sum,
 	min,
 	max,
@@ -5898,6 +6302,18 @@ const OP_FNS = {
 /** Separator for flat select aliases (`avg__price`) — reassembled into nested output by the resolver. */
 const SEP = "__";
 /**
+* Column types PostgreSQL can test for equality but has no `min`/`max` aggregate for, plus the
+* SQLite bigint blob, whose bytes compare as text (`max(9, 10)` is 9). They still count
+* distinct values and group.
+*/
+const NO_MIN_MAX_COLUMN_TYPES = /* @__PURE__ */ new Set([
+	"PgUUID",
+	"PgMacaddr",
+	"PgMacaddr8",
+	"PgBinaryVector",
+	"SQLiteBigInt"
+]);
+/**
 * Classifies a table's columns for aggregation. avg/sum only make sense on numeric scalars;
 * min/max work on any orderable scalar (numbers, strings, bigints, dates, enums). Booleans,
 * arrays (including array-typed number columns), JSON, buffers, and object-shaped columns
@@ -5929,6 +6345,7 @@ const classifyAggregateColumns = (table, tableName) => {
 	if (cached) return cached;
 	const numeric = {};
 	const orderable = {};
+	const comparable = {};
 	const all = {};
 	for (const [columnName, column] of Object.entries(visibleColumns(table))) {
 		all[columnName] = column;
@@ -5938,7 +6355,11 @@ const classifyAggregateColumns = (table, tableName) => {
 		const { type: dataType, constraint } = extractExtendedColumnType(column);
 		if (dataType === "boolean" || dataType === "array" || dataType === "custom") continue;
 		if (dataType === "object" && constraint !== "date") continue;
-		orderable[columnName] = {
+		comparable[columnName] = {
+			column,
+			converted
+		};
+		if (!NO_MIN_MAX_COLUMN_TYPES.has(column.columnType)) orderable[columnName] = {
 			column,
 			converted
 		};
@@ -5947,6 +6368,7 @@ const classifyAggregateColumns = (table, tableName) => {
 	const sets = {
 		numeric,
 		orderable,
+		comparable,
 		all
 	};
 	byName.set(tableName, sets);
@@ -5959,13 +6381,13 @@ const classifyAggregateColumns = (table, tableName) => {
 *   and avg/sum of integers overflow Int / produce decimals)
 * - `min` / `max` — per orderable column, the column's own (nullable) scalar type
 * - `countNonNull` — per column, `Int!`: how many matching rows have a non-null value there
-* - `countDistinct` — per orderable column, `Int!`: how many distinct non-null values there are
+* - `countDistinct` — per comparable column, `Int!`: how many distinct non-null values there are
 * Each wrapper is omitted when no column qualifies for it.
 */
 const generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
 	const cached = cacheCtx?.aggregateTypeCache.get(tableName);
 	if (cached) return cached;
-	const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
+	const { numeric, orderable, comparable, all } = classifyAggregateColumns(table, tableName);
 	const nameOf = (op) => cacheCtx?.typeName({
 		kind: "aggregate",
 		defaultName: `${typeName}${capitalize(op)}Aggregate`,
@@ -5986,7 +6408,7 @@ const generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
 	}) };
 	const countSets = {
 		countNonNull: all,
-		countDistinct: orderable
+		countDistinct: comparable
 	};
 	for (const [op, columns] of Object.entries(countSets)) {
 		const columnNames = Object.keys(columns);
@@ -6161,11 +6583,12 @@ 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;
 		const groupCols = junction ? [junction.sourceCol] : joinPairs.map((pair) => pair.foreignCol);
+		const junctionName = junction ? junctionTableName(tables, relEntry) : void 0;
 		const groupAliases = groupCols.map((_, i) => `${GROUP_KEY}${i}`);
 		const ownCondition = relationOwnCondition(relEntry, parentTable, targetTable, joinPairs.map((pair) => pair.localCol), groupCols);
 		const defaultDeleted = relationDeletedDefault(policies?.softDelete, targetTableName, false);
@@ -6179,7 +6602,7 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 		};
 		const resolve = async (parent, args, context, info) => {
 			try {
-				const { request, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `aggregate:${tableName}::${relationName}`, () => {
+				const { request, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes, `aggregate:${tableName}::${relationName}`, () => {
 					const request = parseAggregateRequest(info, target);
 					return {
 						request,
@@ -6191,23 +6614,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, junction ? junctionPolicy(scope, junctionName, junction.table) : void 0, 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) {
@@ -6233,12 +6659,12 @@ const HAVING_OPS = {
 };
 /**
 * Columns a query can group on. Grouping needs an equality operator, which is the same
-* requirement min/max has, plus booleans — orderable excludes them because a min/max over
+* requirement countDistinct has, plus booleans — comparable excludes them because a min/max over
 * true/false says nothing, but `GROUP BY isConfirmed` is perfectly ordinary.
 */
 const groupableColumns = (table, tableName) => {
-	const { orderable } = classifyAggregateColumns(table, tableName);
-	const groupable = { ...orderable };
+	const { comparable } = classifyAggregateColumns(table, tableName);
+	const groupable = { ...comparable };
 	for (const [columnName, column] of Object.entries(visibleColumns(table))) {
 		if (groupable[columnName]) continue;
 		const { type: dataType } = extractExtendedColumnType(column);
@@ -6279,7 +6705,7 @@ const aggregateNumberFilterType = (typeName) => sharedType(typeName, {
 * nothing to compare against.
 */
 const generateHavingInput = (table, tableName, typeName, cacheCtx) => {
-	const { numeric, orderable, all } = classifyAggregateColumns(table, tableName);
+	const { numeric, comparable, all } = classifyAggregateColumns(table, tableName);
 	const resolveName = cacheCtx?.typeName ?? ((info) => info.defaultName);
 	const numberFilter = aggregateNumberFilterType(resolveName);
 	const fields = { count: {
@@ -6292,7 +6718,7 @@ const generateHavingInput = (table, tableName, typeName, cacheCtx) => {
 		min: numeric,
 		max: numeric,
 		countNonNull: all,
-		countDistinct: orderable
+		countDistinct: comparable
 	};
 	for (const [op, columns] of Object.entries(opColumns)) {
 		const columnNames = Object.keys(columns);
@@ -6357,22 +6783,34 @@ const generateGroupByType = (table, tableName, typeName, cacheCtx) => {
 		}
 	});
 };
-/** Turns one `${typeName}Having` entry into SQL conditions over the matching aggregate expression. */
-const havingComparisons = (expression, filter) => Object.entries(filter).filter(([op, value]) => value != null && op in HAVING_OPS).map(([op, value]) => HAVING_OPS[op](expression, value));
+/**
+* Turns one `${typeName}Having` entry into SQL conditions over the matching aggregate expression.
+*
+* The operand is a `Float`, but PostgreSQL types an untyped parameter after what it is compared
+* with: count and sum of integers are bigint, min/max of an int column int, so `gt: 1.5` would
+* fail to parse. There the aggregate is compared as `numeric`, which holds every one of them
+* exactly. MySQL and SQLite already compare numbers across types.
+*/
+const havingComparisons = (expression, filter, isPg) => {
+	const compared = isPg ? sql`cast(${expression} as numeric)` : expression;
+	return Object.entries(filter).filter(([op, value]) => value != null && op in HAVING_OPS).map(([op, value]) => HAVING_OPS[op](compared, value));
+};
 const buildHavingCondition = (having, columns) => {
 	if (!having) return;
 	const conditions = [];
+	const firstColumn = Object.values(columns)[0];
+	const isPg = firstColumn ? columnDialect(firstColumn) === "pg" : false;
 	for (const [key, value] of Object.entries(having)) {
 		if (value == null) continue;
 		if (key === "count") {
-			conditions.push(...havingComparisons(count(), value));
+			conditions.push(...havingComparisons(count(), value, isPg));
 			continue;
 		}
 		if (!AGGREGATE_OPS.includes(key)) continue;
 		for (const [columnName, filter] of Object.entries(value)) {
 			const column = columns[columnName];
 			if (!column || filter == null) continue;
-			conditions.push(...havingComparisons(OP_FNS[key](column), filter));
+			conditions.push(...havingComparisons(OP_FNS[key](column), filter, isPg));
 		}
 	}
 	return conditions.length ? and(...conditions) : void 0;
@@ -6524,12 +6962,32 @@ const isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault ||
 * 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 ownWherePlan = (relEntry, parentTable, targetTable, localCol, parentPrimaryKey) => {
 	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 };
+	const relation = relEntry.relation ?? relEntry;
+	if (!isRelationFilterReversed(relation)) return { ownCondition: () => condition() };
+	const parentColumns = getColumns(parentTable);
+	const parentKeyColumns = Object.fromEntries(parentPrimaryKey.filter((name) => parentColumns[name]).map((name) => [name, parentColumns[name]]));
+	const keyNames = Object.keys(parentKeyColumns);
+	return {
+		parentShows: async (executor, key) => (await executor.select({ key: localCol }).from(parentTable).where(and(eq(localCol, key), condition())).limit(1)).length > 0,
+		parentHidden: async (executor, rows) => {
+			if (!rows.length) return false;
+			if (!keyNames.length || !rows.every((row) => keyNames.every((name) => name in row))) throw drizzleError(`Drizzle-GraphQL Error: cannot check the \`where\` of this relation: the written row cannot be identified by a primary key.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
+			const keyOf = (row) => keyNames.map((name) => keyString(row[name])).join("\0");
+			const match = or(...rows.map((row) => and(...keyNames.map((name) => eq(parentColumns[name], row[name])))));
+			const shown = new Set((await executor.select(parentKeyColumns).from(parentTable).where(and(match, relationsFilterToSQL(parentTable, relationOwnWhere(relation))))).map(keyOf));
+			return rows.some((row) => !shown.has(keyOf(row)));
+		},
+		parentKeyColumns
+	};
 };
+/**
+* A key value in a form that compares equal across the two reads of it — the driver may hand
+* back a `Date` or a `bigint` that is a different object each time.
+*/
+const keyString = (value) => value instanceof Date ? `d${value.getTime()}` : value === null || value === void 0 ? "" : `v${String(value)}`;
 /** The property name a column is stored under on its table, matched by identity. */
 const propNameOf = (table, column) => {
 	if (!column) return;
@@ -6591,7 +7049,7 @@ const buildThroughPlan = (relationName, relEntry, relation, table, targetTableNa
 			targetCol
 		},
 		targetKeyColumns: { [foreignColPropName]: foreignCol },
-		...ownWherePlan(relEntry, table, targetTable, localCol),
+		...ownWherePlan(relEntry, table, targetTable, localCol, []),
 		allowed: /* @__PURE__ */ new Set([
 			"connect",
 			"disconnect",
@@ -6670,7 +7128,7 @@ const buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePr
 			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 ownWhere = ownWherePlan(relEntry, table, targetTable, localCol, resolvePrimaryKeys(table));
 			const ops = !fkColumn.notNull ? isOne ? [
 				"create",
 				"connect",
@@ -7103,6 +7561,16 @@ const createNestedWriteRuntime = (params) => {
 		}
 		if (supplied(op["connect"])) await link(asArray(op["connect"]), "connect");
 	};
+	/**
+	* The value a parent-side `connect` / `disconnect` writes to an existing row's key: `next`,
+	* unless the key points at a row the relation's own `where` hides, which it then keeps.
+	*/
+	const keepingHidden = (plan, next) => {
+		if (!plan.ownCondition) return next;
+		const shown = sql`select ${plan.foreignCol} from ${plan.targetTable} where ${plan.ownCondition()}`;
+		const replacement = next === null ? sql`null` : sql`${sql.param(next, plan.localCol)}`;
+		return sql`case when ${plan.localCol} is null or ${plan.localCol} in (${shown}) then ${replacement} else ${plan.localCol} end`;
+	};
 	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],
@@ -7128,7 +7596,10 @@ const createNestedWriteRuntime = (params) => {
 			const allColumns = getColumns(table);
 			for (const relationName of Object.keys(ops)) {
 				const plan = tablePlans[relationName];
-				if (plan?.fkSide === "child" && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) columns[plan.localColPropName] = allColumns[plan.localColPropName];
+				if (plan && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) columns[plan.localColPropName] = allColumns[plan.localColPropName];
+				if (plan?.fkSide === "parent" && plan.parentHidden) {
+					for (const [name, column] of Object.entries(plan.parentKeyColumns ?? {})) if (!(name in columns)) columns[name] = column;
+				}
 			}
 			for (const name of selfTargetingPlan(tablePlans, tableName, ops)?.targetPrimaryKey ?? []) if (!(name in columns) && allColumns[name]) columns[name] = allColumns[name];
 			return columns;
@@ -7148,10 +7619,15 @@ const createNestedWriteRuntime = (params) => {
 				...fresh.get(keyOf(row))
 			}));
 		},
-		applyParentSide: async (executor, tableName, ops, request) => {
+		applyParentSide: async (executor, tableName, ops, request, existing = false) => {
 			const tablePlans = plans[tableName];
-			const patch = {};
-			if (!tablePlans) return patch;
+			const result = {
+				values: {},
+				expected: {},
+				existing
+			};
+			const patch = result.values;
+			if (!tablePlans) return result;
 			const context = request?.context;
 			const scope = resolveScope(policies, context, filterCtx);
 			for (const [relationName, op] of Object.entries(ops)) {
@@ -7170,14 +7646,30 @@ const createNestedWriteRuntime = (params) => {
 					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];
+					result.expected[relationName] = 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 connectMatchError(relationName, rows.length);
-					patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
-				} else if (op["disconnect"] === true) patch[plan.localColPropName] = null;
+					const key = rows[0][plan.foreignColPropName];
+					patch[plan.localColPropName] = existing ? keepingHidden(plan, key) : key;
+					result.expected[relationName] = key;
+				} else if (op["disconnect"] === true) patch[plan.localColPropName] = existing ? keepingHidden(plan, null) : null;
 			}
 			for (const columnName of Object.keys(contextValues?.(tableName) ?? {})) delete patch[columnName];
-			return patch;
+			return result;
+		},
+		checkParentSide: async (executor, tableName, ops, rows, patch) => {
+			const tablePlans = plans[tableName];
+			if (!tablePlans || !rows.length) return;
+			for (const relationName of Object.keys(ops)) {
+				const plan = tablePlans[relationName];
+				if (plan?.fkSide !== "parent") continue;
+				if (relationName in patch.expected) {
+					const expected = keyString(patch.expected[relationName]);
+					if (rows.some((row) => keyString(row[plan.localColPropName]) !== expected)) throw drizzleError(patch.existing ? `Drizzle-GraphQL Error: cannot connect through '${relationName}': the row it holds now is one its \`where\` hides, which a write through it cannot detach.` : `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row was not written with it — an upsert whose conflict branch did not write '${plan.localColPropName}'. Include it in onConflict.update, or leave update unset.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
+				}
+				if (plan.parentHidden && await plan.parentHidden(executor, rows)) throw drizzleError(`Drizzle-GraphQL Error: cannot write through '${relationName}': its \`where\` hides the relation on this ${tableName} row.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
+			}
 		},
 		applyChildSide: async (executor, tableName, ops, parentRows, request) => {
 			const tablePlans = plans[tableName];
@@ -7244,12 +7736,13 @@ var NoParentRow = class extends Error {};
 * `executor` must already be a transaction.
 */
 const writeNestedEntry = async (params) => {
-	const { executor, runtime, tableName, ops, write, request } = params;
+	const { executor, runtime, tableName, ops, write, request, existing } = 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);
+		const patch = await runtime.applyParentSide(tx, tableName, ops, request, existing);
+		const rows = await write(tx, patch.values);
 		if (guarded && !rows.length) throw new NoParentRow();
+		await runtime.checkParentSide(tx, tableName, ops, rows, patch);
 		await runtime.applyChildSide(tx, tableName, ops, rows, request);
 		return runtime.refreshed(tx, tableName, ops, rows);
 	};
@@ -7311,7 +7804,8 @@ const updateWithNestedOps = async (params) => {
 			...remapValues(columns),
 			...patch
 		}),
-		request
+		request,
+		existing: true
 	}));
 };
 //#endregion
@@ -7464,6 +7958,7 @@ const createSchemaBuilder = (adapter) => {
 		const anyTable = (feature) => tableEntries.some(([name]) => featureOf(name)[feature]);
 		if (!tableEntries.length) throw new Error("Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?");
 		registerScalarOverrides(tables, options);
+		installSqliteBlobJsonDecoders(tables);
 		registerEnumConfig(options);
 		registerColumnExclusions(tables, options.exclude);
 		resetAggregateColumnCache();
@@ -7695,7 +8190,7 @@ const createSchemaBuilder = (adapter) => {
 				...tableFeatures.update ? [updateInput] : [],
 				...built.updateManyInput ? [built.updateManyInput] : [],
 				tableFilters,
-				tableOrder
+				...tableOrder ? [tableOrder] : []
 			].forEach((e) => {
 				inputs[e.name] = e;
 			});
@@ -7825,14 +8320,12 @@ const generateUpsert = (db, tableName, table, baseType, onConflictType, fieldNam
 				withTarget: false,
 				serverOwned: Object.keys(contextColumns ?? {})
 			});
-			const requestedNothing = args.onConflict?.action === "NOTHING";
 			const runBatch = async (target, { values, plan }) => {
-				if (plan.action === "NOTHING" && !requestedNothing) {
+				if (plan.action === "NOTHING") {
 					const columns = getColumns(table);
 					const keyName = pkNames[0] ?? Object.keys(columns)[0];
 					await target.insert(table).values(values).onDuplicateKeyUpdate({ set: { [keyName]: sql`${sql.identifier(columns[keyName].name)}` } });
-				} else if (plan.action === "NOTHING") await target.insert(table).ignore().values(values);
-				else await target.insert(table).values(values).onDuplicateKeyUpdate({ set: plan.set });
+				} else await target.insert(table).values(values).onDuplicateKeyUpdate({ set: plan.set });
 			};
 			if (batches.length === 1) await runBatch(executor, batches[0]);
 			else await executor.transaction(async (tx) => {
@@ -7872,7 +8365,7 @@ const generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, si
 		});
 		if (single) await assertSingleMatch(executor, table, filters);
 		let query = executor.update(table).set(input);
-		if (filters) query = query.where(filters);
+		if (filters) query = query.where(mysqlWriteFilter(table, filters));
 		await query;
 		await after();
 		return isSuccess;
@@ -7887,7 +8380,7 @@ const generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, si
 * in order. MySQL has no RETURNING, so — like every other MySQL mutation — the result is
 * `{ isSuccess: true }` rather than the updated rows.
 */
-const generateUpdateMany$2 = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx, policies) => writeResolver({
+const generateUpdateMany$2 = (db, tableName, table, updateManyInput, fieldName, requireWhere, filterCtx, txCtx, policies) => writeResolver({
 	db,
 	tableName,
 	operation: "updateMany",
@@ -7907,13 +8400,20 @@ const generateUpdateMany$2 = (db, tableName, table, updateManyInput, fieldName,
 			if (!Object.keys(input).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
 			return {
 				set: input,
-				filters: withScope(scope, tableName, table, where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName, scope)) : void 0)
+				filters: scopedWhere({
+					scope,
+					tableName,
+					table,
+					where,
+					relationCtx: relationFilterCtx(filterCtx, tableName, scope),
+					required: requireWhere
+				})
 			};
 		});
 		await executor.transaction(async (tx) => {
 			for (const entry of entries) {
 				let query = tx.update(table).set(entry.set);
-				if (entry.filters) query = query.where(entry.filters);
+				if (entry.filters) query = query.where(mysqlWriteFilter(table, entry.filters));
 				await query;
 			}
 		});
@@ -7962,7 +8462,7 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 			});
 			if (single) await assertSingleMatch(executor, table, filters);
 			let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
-			if (filters) query = query.where(filters);
+			if (filters) query = query.where(mysqlWriteFilter(table, filters));
 			await query;
 			await after();
 			return isSuccess;
@@ -7973,6 +8473,34 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 const getTableConfig$5 = memoizeTableConfig(getTableConfig);
 /** Primary-key property names for a MySQL table, including table-level composite keys. */
 const mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$5);
+const TABLE_ORIGINAL_NAME = Symbol.for("drizzle:OriginalName");
+const TABLE_SCHEMA = Symbol.for("drizzle:Schema");
+/** Whether `chunk` reads `table` anywhere — under an alias, in a subquery, however deep. */
+const readsTable = (chunk, table) => {
+	if (Array.isArray(chunk)) return chunk.some((part) => readsTable(part, table));
+	if (is(chunk, Table)) return chunk[TABLE_ORIGINAL_NAME] === table[TABLE_ORIGINAL_NAME] && chunk[TABLE_SCHEMA] === table[TABLE_SCHEMA];
+	if (is(chunk, SQL)) return readsTable(chunk.queryChunks, table);
+	if (is(chunk, SQL.Aliased)) return readsTable(chunk.sql, table);
+	if (is(chunk, Subquery)) return readsTable(chunk._.sql, table);
+	return false;
+};
+/**
+* The `where` of an UPDATE or DELETE, in a form MySQL accepts. MySQL refuses a statement whose
+* `where` reads the table it writes (error 1093, "You can't specify target table … for update
+* in FROM clause") — which a relation filter through a self-referencing relation, or a scope
+* written as one, does. Such a filter is resolved to the primary keys it matches first, through
+* a derived table MySQL materializes (`DISTINCT` keeps the optimizer from merging it back in),
+* and the write matches those keys. Any other filter is returned as it is.
+*/
+const mysqlWriteFilter = (table, filters) => {
+	if (!filters || !readsTable(filters, table)) return filters;
+	const columns = getColumns(table);
+	const keys = mysqlPrimaryKeyPropNames(table).map((name) => columns[name]);
+	if (!keys.length) return filters;
+	const keyList = sql.join(keys.map((column) => sql.identifier(column.name)), sql`, `);
+	const target = keys.length === 1 ? sql`${keys[0]}` : sql`(${sql.join(keys, sql`, `)})`;
+	return sql`${target} in (select ${keyList} from (select distinct ${sql.join(keys, sql`, `)} from ${table} where ${filters}) as ${sql.identifier("dgql_write_target")})`;
+};
 const { prepareBuild, forEachTable, finalizeBuild } = createSchemaBuilder({
 	tableClass: MySqlTable,
 	getTableConfig: getTableConfig$5,
@@ -8026,7 +8554,7 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			tableFilters,
 			cacheCtx
 		}) : void 0;
-		const updateManyGenerated = updateManyInput ? generateUpdateMany$2(db, tableName, schema[tableName], updateManyInput, updateManyFieldName, filterCtx, mutationTxCtx, policies) : void 0;
+		const updateManyGenerated = updateManyInput ? generateUpdateMany$2(db, tableName, schema[tableName], updateManyInput, updateManyFieldName, tableFeatures.requireWhere, filterCtx, mutationTxCtx, policies) : void 0;
 		const deleteGenerated = tableFeatures.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteFieldName, false, tableFeatures.requireWhere, filterCtx, mutationTxCtx, policies) : void 0;
 		const deleteSingleGenerated = tableFeatures.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteSingleFieldName, true, tableFeatures.requireWhere, filterCtx, mutationTxCtx, policies) : void 0;
 		const restoreGenerated = softDeleteInfo ? generateDelete(db, tableName, schema[tableName], tableFilters, restoreFieldName, false, tableFeatures.requireWhere, filterCtx, mutationTxCtx, policies, true) : void 0;
@@ -8043,7 +8571,8 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			filterCtx,
 			txCtx: mutationTxCtx,
 			policies,
-			returnsRows: false
+			returnsRows: false,
+			writeFilter: (filters) => mysqlWriteFilter(schema[tableName], filters)
 		}) : void 0;
 		const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 			db,
@@ -8056,7 +8585,8 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			filterCtx,
 			txCtx: mutationTxCtx,
 			policies,
-			returnsRows: false
+			returnsRows: false,
+			writeFilter: (filters) => mysqlWriteFilter(schema[tableName], filters)
 		}) : void 0;
 		const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 		const withMeta = (generated, meta) => ({
@@ -8168,7 +8698,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 	* one-element list.
 	*/
 	const generateInsert = (build, opts) => {
-		const { db, tables, relationMap, typeNameMapper, txCtx, nested, limits, policies, resolveName } = build;
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
 		const { tableName, table, baseType, fieldName, typeName, single, conflictDoNothing = false } = opts;
 		const queryArgs = { values: { type: single ? new GraphQLNonNull(baseType) : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(baseType))) } };
 		const pkNames = primaryKeyPropNames(table);
@@ -8192,6 +8722,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
 				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
+					filterCtx,
 					tables,
 					tableName,
 					typeName,
@@ -8270,6 +8801,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
 				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
+					filterCtx,
 					tables,
 					tableName,
 					typeName,
@@ -8294,24 +8826,25 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 						serverOwned: Object.keys(contextColumns ?? {}),
 						buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName, scope))
 					});
-					const runBatch = async (executor, { values: rows, plan }) => {
-						let query = executor.insert(table).values(rows).returning(returning);
+					const batchQuery = (executor, { values: rows, plan }) => {
+						const query = executor.insert(table).values(rows).returning(returning);
 						const setWhere = withScope(scope, tableName, table, plan.setWhere);
-						query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? {
-							target: plan.target,
-							where: plan.targetWhere
-						} : void 0) : query.onConflictDoUpdate({
-							target: plan.target,
-							targetWhere: plan.targetWhere,
-							set: plan.set,
-							setWhere
-						});
-						return await query;
+						return applyConflictPlan(query, table, plan, setWhere);
 					};
-					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;
 					});
 				};
@@ -8359,6 +8892,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				await before();
 				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
+					filterCtx,
 					tables,
 					tableName,
 					typeName,
@@ -8597,7 +9131,8 @@ const createSchemaDataGenerator = (adapter) => {
 				table: schema[tableName],
 				updateManyInput,
 				fieldName: updateManyFieldName,
-				typeName
+				typeName,
+				requireWhere: tableFeatures.requireWhere
 			}) : void 0;
 			const deleteGenerated = tableFeatures.delete ? generateDelete(writeBuild, {
 				tableName,
@@ -8852,7 +9387,8 @@ const runUpdateManyBatch = ({ executor, entries, table, returning, nested, table
 			tableName,
 			ops: entry.ops,
 			write,
-			request
+			request,
+			existing: true
 		}) : await write(tx, {}));
 	}
 	return results;
@@ -8873,7 +9409,7 @@ const runUpdateManyBatch = ({ executor, entries, table, returning, nested, table
 const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateManyBatch) => {
 	return (build, opts) => {
 		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
-		const { tableName, table, updateManyInput, fieldName, typeName } = opts;
+		const { tableName, table, updateManyInput, fieldName, typeName, requireWhere } = opts;
 		const queryArgs = { updates: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(updateManyInput))) } };
 		const pkNames = primaryKeyPropNames(table);
 		return writeResolver({
@@ -8893,6 +9429,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 				const contextColumns = policies?.contextValues?.(tableName);
 				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
+					filterCtx,
 					tables,
 					tableName,
 					typeName,
@@ -8912,7 +9449,14 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					return {
 						set: input,
 						ops,
-						filters: withScope(scope, tableName, table, where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName, scope)) : void 0)
+						filters: scopedWhere({
+							scope,
+							tableName,
+							table,
+							where,
+							relationCtx: relationFilterCtx(filterCtx, tableName, scope),
+							required: requireWhere
+						})
 					};
 				});
 				const anyNested = entries.some((entry) => entry.ops);
@@ -9001,7 +9545,8 @@ const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNest
 			tableName,
 			ops: entry.ops,
 			write,
-			request
+			request,
+			existing: true
 		}) : write(tx, {});
 	};
 	return executor.transaction((tx) => {
@@ -9031,6 +9576,7 @@ const sqliteSchemaData = createSchemaDataGenerator({
 	preflight: (db, options) => {
 		if (options.features.nestedWrites && db.resultKind === "sync") throw new Error("Drizzle-GraphQL Error: features.nestedWrites requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers cannot run the multi-statement transaction a nested write needs.");
 		if (options.transactions && db.resultKind === "sync") throw new Error("Drizzle-GraphQL Error: transactions: 'auto' requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers cannot hold a transaction open across resolvers.");
+		if (options.policies?.onWrite && db.resultKind === "sync") throw new Error("Drizzle-GraphQL Error: onWrite requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers commit before an awaited hook runs, so a throwing hook could not roll the mutation back.");
 	},
 	generateUpdateMany
 });