@vantreeseba/drizzle-graphql 15.1.0 → 15.1.2

package/dist/index.cjs

@@ -1616,13 +1616,20 @@ const nullableOps = {
 	isNull: drizzle_orm.isNull,
 	isNotNull: drizzle_orm.isNotNull
 };
+/** Operators whose operand is an on/off flag rather than a value: `false` adds no condition. */
+const FLAG_OPERATORS = /* @__PURE__ */ new Set([
+	"isNull",
+	"isNotNull",
+	"isEmpty"
+]);
 const extractFiltersColumn = (column, columnName, operators) => {
 	const { OR, AND, NOT, insensitive, ...restOperators } = operators;
 	const foldCase = insensitive === true;
 	const entries = Object.entries(restOperators);
 	const variants = [];
 	for (const [operatorName, operatorValue] of entries) {
-		if (operatorValue === null || operatorValue === false) continue;
+		if (operatorValue === null || operatorValue === void 0) continue;
+		if (operatorValue === false && FLAG_OPERATORS.has(operatorName)) continue;
 		if (operatorName in singleValueOps) {
 			const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
 			variants.push(foldCase ? lowerComparison(column, operatorName, singleValue) : singleValueOps[operatorName](column, singleValue));
@@ -2411,8 +2418,8 @@ const columnEnumCache = /* @__PURE__ */ new WeakMap();
 * input field the enum would have typed, rather than emitting an empty enum, which is
 * invalid GraphQL.
 */
-const generateColumnEnum = (table, enumName, description, predicate = () => true) => {
-	const cacheKey = `${enumName}\u0000${excludedColumnsKey(table)}`;
+const generateColumnEnum = (table, enumName, description, predicate = () => true, variant = "") => {
+	const cacheKey = `${enumName}\u0000${excludedColumnsKey(table)}\u0000${variant}`;
 	let tableCache = columnEnumCache.get(table);
 	const cached = tableCache?.get(cacheKey);
 	if (cached) return cached;
@@ -2472,6 +2479,9 @@ const conflictActionEnumType = (typeName) => sharedType(typeName, {
 * `ON DUPLICATE KEY UPDATE` fires on any unique key and takes no predicate, so offering
 * either there would mean silently ignoring it.
 *
+* `update` never offers a `contextValues` column: the server owns it, and the conflict
+* branch is an update, which must not hand the row to another owner.
+*
 * Returns `undefined` when the table has nothing to conflict on (`withTarget` dialects
 * only) — the caller then generates no upsert mutations for that table at all, rather than
 * an operation whose every call is a database error.
@@ -2479,12 +2489,13 @@ const conflictActionEnumType = (typeName) => sharedType(typeName, {
 const generateOnConflictInput = (params) => {
 	const { table, tableName, typeName, uniqueSets, tableFilters, withTarget, cacheCtx } = params;
 	const resolveName = cacheCtx.typeName;
+	const serverOwned = Object.keys(cacheCtx.contextValuesOf?.(tableName) ?? {}).sort();
 	const updateEnum = generateColumnEnum(table, resolveName({
 		kind: "columnEnum",
 		defaultName: `${typeName}UpdateColumn`,
 		table: tableName,
 		operation: "conflictUpdate"
-	}), `Columns of ${typeName} that an upsert can overwrite`);
+	}), `Columns of ${typeName} that an upsert can overwrite`, (_column, columnName) => !serverOwned.includes(columnName), serverOwned.join(","));
 	if (!updateEnum) return;
 	const fields = {
 		action: {
@@ -2494,11 +2505,11 @@ const generateOnConflictInput = (params) => {
 		},
 		update: {
 			type: new graphql.GraphQLList(new graphql.GraphQLNonNull(updateEnum)),
-			description: "Columns to overwrite on conflict. Defaults to every column the request supplied, minus the conflict target. Columns the request did not supply cannot be listed here — there would be no value to write."
+			description: `Columns to overwrite on conflict. Defaults to every column the request supplied, minus the ${withTarget ? "conflict target" : "primary key"}. Columns the request did not supply cannot be listed here — there would be no value to write.`
 		}
 	};
 	if (withTarget) {
-		const uniqueColumns = new Set(uniqueSets.flat());
+		const uniqueColumns = new Set(uniqueSets.flatMap((set) => set.columns));
 		const targetEnum = generateColumnEnum(table, resolveName({
 			kind: "columnEnum",
 			defaultName: `${typeName}ConflictTarget`,
@@ -2526,55 +2537,88 @@ const generateOnConflictInput = (params) => {
 	});
 };
 /**
-* Turns the request's `onConflict` argument and the rows it is inserting into the clause a
-* dialect should attach.
+* Turns the request's `onConflict` argument and the rows it is inserting into the
+* statements a dialect should run — one per run of consecutive rows that write the same
+* columns on conflict.
+*
+* The split is what keeps a partial row partial. A multi-row insert fills a key one row
+* left out with DEFAULT, and `excluded.<column>` would carry that default onto the existing
+* row, so rows that supply different columns cannot share a `SET` list. Splitting into
+* *consecutive* runs, rather than grouping, keeps the rows a caller gets back in the order
+* it sent them. A batch whose rows agree — the usual case — is still one statement.
 *
 * `excludedRef` names the row that failed to insert in the dialect's own terms
 * (`excluded.col` on PostgreSQL and SQLite, `values(col)` on MySQL), which is what makes a
 * batch upsert update each row with its own values instead of the last row's.
 *
+* Never written on conflict, even when supplied: the conflict target (it already matches);
+* the primary key on a dialect with no target (MySQL's conflict can be on another unique
+* key, and copying a generated id over the existing row's would move it); and `serverOwned`
+* — the `contextValues` columns, which an update never reassigns.
+*
 * An UPDATE with nothing left to write degrades to NOTHING: `DO UPDATE SET` with an empty
 * body is not valid SQL, and doing nothing is what the request asked for anyway.
 */
 const resolveConflictPlan = (params) => {
 	const { table, values, onConflict, pkNames, uniqueSets, excludedRef, withTarget, buildWhere } = params;
 	const columns = (0, drizzle_orm.getColumns)(table);
+	const serverOwned = new Set(params.serverOwned ?? []);
 	let target;
+	let targetWhere;
 	if (withTarget) {
 		const targetNames = onConflict?.target?.length ? onConflict.target : [...pkNames];
 		if (!targetNames.length) throw drizzleError("Unable to upsert: no conflict target was given and this table has no primary key. Pass onConflict.target.", { code: "DRIZZLE_INVALID_ON_CONFLICT" });
 		const requested = [...targetNames].sort().join(",");
-		if (!uniqueSets.some((set) => [...set].sort().join(",") === requested)) throw drizzleError(`Unable to upsert: [${targetNames.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set) => `[${set.join(", ")}]`).join(", ")}.`, { code: "DRIZZLE_INVALID_ON_CONFLICT" });
+		const matched = uniqueSets.find((set) => [...set.columns].sort().join(",") === requested);
+		if (!matched) throw drizzleError(`Unable to upsert: [${targetNames.join(", ")}] is not a unique constraint on this table. Valid conflict targets: ${uniqueSets.map((set) => `[${set.columns.join(", ")}]`).join(", ")}.`, { code: "DRIZZLE_INVALID_ON_CONFLICT" });
 		target = targetNames.map((name) => columns[name]);
+		targetWhere = matched.where;
 	}
-	if ((onConflict?.action ?? "UPDATE") === "NOTHING") return {
+	const nothing = {
 		action: "NOTHING",
 		target,
+		targetWhere,
 		set: {},
 		setWhere: void 0
 	};
+	if ((onConflict?.action ?? "UPDATE") === "NOTHING") return [{
+		values,
+		plan: nothing
+	}];
 	const supplied = new Set(values.flatMap((row) => Object.keys(row)));
-	const targetNames = new Set(withTarget ? onConflict?.target?.length ? onConflict.target : pkNames : []);
-	let updateNames;
+	const neverWritten = new Set(withTarget && onConflict?.target?.length ? onConflict.target : pkNames);
+	let candidates;
 	if (onConflict?.update?.length) {
+		const owned = onConflict.update.filter((name) => serverOwned.has(name));
+		if (owned.length) throw drizzleError(`Unable to upsert: onConflict.update lists ${owned.join(", ")}, which the server sets and an update never overwrites.`, { code: "DRIZZLE_INVALID_ON_CONFLICT" });
 		const unsupplied = onConflict.update.filter((name) => !supplied.has(name));
 		if (unsupplied.length) throw drizzleError(`Unable to upsert: onConflict.update lists ${unsupplied.join(", ")}, which the values do not supply.`, { code: "DRIZZLE_INVALID_ON_CONFLICT" });
-		updateNames = onConflict.update;
-	} else updateNames = [...supplied].filter((name) => !targetNames.has(name));
-	if (!updateNames.length) return {
-		action: "NOTHING",
-		target,
-		set: {},
-		setWhere: void 0
-	};
-	const set = Object.fromEntries(updateNames.map((name) => [name, excludedRef(columns[name].name)]));
+		candidates = onConflict.update;
+	} else candidates = [...supplied].filter((name) => !neverWritten.has(name) && !serverOwned.has(name));
 	const setWhere = onConflict?.where && buildWhere ? buildWhere(onConflict.where) : void 0;
-	return {
+	const planFor = (updateNames) => updateNames.length ? {
 		action: "UPDATE",
 		target,
-		set,
+		targetWhere,
+		set: Object.fromEntries(updateNames.map((name) => [name, excludedRef(columns[name].name)])),
 		setWhere
-	};
+	} : nothing;
+	const batches = [];
+	for (const row of values) {
+		const updateNames = candidates.filter((name) => name in row);
+		const key = updateNames.join(",");
+		const last = batches[batches.length - 1];
+		if (last?.key === key) last.values.push(row);
+		else batches.push({
+			key,
+			values: [row],
+			plan: planFor(updateNames)
+		});
+	}
+	return batches.map(({ values: rows, plan }) => ({
+		values: rows,
+		plan
+	}));
 };
 /** `excluded.<column>` — PostgreSQL and SQLite name the rejected row this way. */
 const excludedColumnRef = (columnName) => drizzle_orm.sql`excluded.${drizzle_orm.sql.identifier(columnName)}`;
@@ -2756,6 +2800,45 @@ const cursorOrderExprs = (table, entries) => {
 	return entries.flatMap(([column, direction, nulls]) => orderExpressions(cols[column], direction, nulls ?? void 0, cols[column]));
 };
 /**
+* Property a row carries an ordering column's full-precision text under, when the column holds
+* more than a JS Date can. Namespaced like {@link ROW_CURSOR_PROP}, and removed from the row
+* once its cursor is encoded.
+*/
+const preciseTextProp = (column) => `__drizzle_graphql_cursor_text_${column}`;
+/**
+* Whether a column reads into a JS Date (milliseconds) while the database keeps finer
+* fractional seconds: a PostgreSQL `timestamp` / `timestamptz` in `mode: 'date'` (precision 6
+* unless it says otherwise) or a MySQL `datetime` / `timestamp` in `mode: 'date'` with
+* `fsp` above 3. String-mode columns already arrive as the database's own text, and `time` is
+* always a string, so neither loses anything.
+*/
+const outgrowsJsDate = (column) => {
+	if ((0, drizzle_orm.is)(column, drizzle_orm_pg_core.PgTimestamp)) return column.precision === void 0 || column.precision > 3;
+	if ((0, drizzle_orm.is)(column, drizzle_orm_mysql_core.MySqlDateTime) || (0, drizzle_orm.is)(column, drizzle_orm_mysql_core.MySqlTimestamp)) return (column.fsp ?? 0) > 3;
+	return false;
+};
+/**
+* Extra SQL expressions a cursor-computing query selects alongside the row: for each ordering
+* column whose values a JS Date would truncate, the value as the database's own text. The
+* cursor then encodes that text rather than the Date, and `after` compares the column against
+* it — so two rows a microsecond apart stay distinct positions. `table` may be the aliased RQB
+* proxy. Empty when no ordering column needs it.
+*/
+const cursorPreciseExtras = (table, entries) => {
+	const cols = (0, drizzle_orm.getColumns)(table);
+	const extras = {};
+	for (const [name] of entries) {
+		const column = cols[name];
+		if (column && outgrowsJsDate(column)) extras[preciseTextProp(name)] = (0, drizzle_orm.is)(column, drizzle_orm_pg_core.PgTimestamp) ? drizzle_orm.sql`${column}::text` : drizzle_orm.sql`cast(${column} as char)`;
+	}
+	return extras;
+};
+/**
+* {@link cursorPreciseExtras} aliased under their property names, for a `select({...})` that
+* may be wrapped in a subquery (where a bare SQL expression would have no name).
+*/
+const cursorPreciseSelection = (table, entries) => Object.fromEntries(Object.entries(cursorPreciseExtras(table, entries)).map(([prop, expression]) => [prop, expression.as(prop)]));
+/**
 * Serializes one ordering-tuple value into a JSON-safe shape. Dates and bigints don't survive
 * JSON.stringify losslessly (bigint throws, Date turns into an untagged string), so they are
 * tagged; decimals already arrive from the driver as strings, which are lossless as-is.
@@ -2790,7 +2873,11 @@ const cursorEncoder = (entries) => {
 	const spec = JSON.stringify(entries);
 	const columns = entries.map(([column]) => column);
 	return (row) => {
-		const values = JSON.stringify(columns.map((column) => encodeCursorValue(row[column] ?? null)));
+		const values = JSON.stringify(columns.map((column) => {
+			const value = row[column] ?? null;
+			const precise = row[preciseTextProp(column)];
+			return value !== null && typeof precise === "string" ? precise : encodeCursorValue(value);
+		}));
 		return Buffer.from(`{"o":${spec},"v":${values}}`, "utf8").toString("base64url");
 	};
 };
@@ -2883,7 +2970,11 @@ const selectsCursorField = (info, table) => {
 */
 const attachRowCursors = (rows, entries) => {
 	const encode = cursorEncoder(entries);
-	for (const row of rows) row[ROW_CURSOR_PROP] = encode(row);
+	const preciseProps = entries.map(([column]) => preciseTextProp(column));
+	for (const row of rows) {
+		row[ROW_CURSOR_PROP] = encode(row);
+		for (const prop of preciseProps) delete row[prop];
+	}
 };
 /** Resolver for the `cursor` meta field: reads the value a list resolver attached, if any. */
 const rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
@@ -2971,9 +3062,9 @@ const primaryKeyOrderExprs = (table, pkNames) => {
 	return pkNames.map((n) => cols[n]).filter(Boolean).map((col) => (0, drizzle_orm.asc)(col));
 };
 /**
-* Every set of columns that uniquely identifies a row of `table`: the primary key first,
-* then each unique constraint and unique index, then each column declared `.unique()`
-* inline. Sets are property names (what GraphQL inputs use), not database column names.
+* Every set of columns that is unique on `table`: the primary key first, then each unique
+* constraint and unique index, then each column declared `.unique()` inline. Sets are
+* property names (what GraphQL inputs use), not database column names.
 *
 * `getTableConfig` is the dialect's own — the three dialects expose the same
 * `{ primaryKeys, uniqueConstraints, indexes }` shape but from different modules, so the
@@ -2982,9 +3073,13 @@ const primaryKeyOrderExprs = (table, pkNames) => {
 * Index entries whose columns are SQL expressions rather than plain columns are skipped:
 * an expression index is a valid conflict target in the database but cannot be named by a
 * column enum. Deduplicated, order-insensitive — a column that is both the primary key and
-* a unique constraint yields one set.
+* a unique constraint yields one set, and a set that is unique both outright and under a
+* partial index keeps the outright one.
+*
+* A partial unique index carries its predicate as `where`: it is a conflict target only
+* together with that predicate, and it does not make the set unique across the whole table.
 */
-const getUniqueColumnSets = (table, getTableConfig) => {
+const getUniqueTargets = (table, getTableConfig) => {
 	const cols = visibleColumns(table);
 	const propNameByColumnName = new Map(Object.entries(cols).map(([propName, col]) => [col.name, propName]));
 	const toPropNames = (columnNames) => {
@@ -2996,25 +3091,40 @@ const getUniqueColumnSets = (table, getTableConfig) => {
 		}
 		return propNames.length ? propNames : void 0;
 	};
+	const whole = (columns) => columns ? { columns } : void 0;
 	const config = getTableConfig(table);
 	const candidates = [
-		Object.entries(cols).filter(([, col]) => col.primary).map(([propName]) => propName),
-		...config.primaryKeys.map((pk) => toPropNames(pk.columns.map((c) => c.name))),
-		...(config.uniqueConstraints ?? []).map((uc) => toPropNames(uc.columns.map((c) => c.name))),
-		...(config.indexes ?? []).filter((index) => index.config.unique).map((index) => toPropNames(index.config.columns.map((c) => c?.name))),
-		...Object.entries(cols).filter(([, col]) => col.isUnique).map(([propName]) => [propName])
+		whole(Object.entries(cols).filter(([, col]) => col.primary).map(([propName]) => propName)),
+		...config.primaryKeys.map((pk) => whole(toPropNames(pk.columns.map((c) => c.name)))),
+		...(config.uniqueConstraints ?? []).map((uc) => whole(toPropNames(uc.columns.map((c) => c.name)))),
+		...(config.indexes ?? []).filter((index) => index.config.unique).map((index) => {
+			const columns = toPropNames(index.config.columns.map((c) => c?.name));
+			return columns ? {
+				columns,
+				...index.config.where ? { where: index.config.where } : {}
+			} : void 0;
+		}),
+		...Object.entries(cols).filter(([, col]) => col.isUnique).map(([propName]) => ({ columns: [propName] }))
 	];
-	const seen = /* @__PURE__ */ new Set();
-	const sets = [];
-	for (const set of candidates) {
-		if (!set?.length) continue;
-		const key = [...set].sort().join(",");
-		if (seen.has(key)) continue;
-		seen.add(key);
-		sets.push(set);
+	const byKey = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		if (!candidate?.columns.length) continue;
+		const key = [...candidate.columns].sort().join(",");
+		const seen = byKey.get(key);
+		if (!seen) byKey.set(key, candidate);
+		else if (seen.where && !candidate.where) byKey.set(key, { columns: seen.columns });
 	}
-	return sets;
+	return [...byKey.values()];
 };
+/**
+* The column sets that identify at most one row of `table` — {@link getUniqueTargets}
+* without the partial unique indexes, which only constrain the rows their predicate
+* matches (a soft-deleted duplicate is allowed), and so do not.
+*
+* Pass `{ partial: true }` to keep them, for callers that only need to know a set is
+* unique among the rows that matter.
+*/
+const getUniqueColumnSets = (table, getTableConfig, options = {}) => getUniqueTargets(table, getTableConfig).filter((target) => options.partial || !target.where).map((target) => target.columns);
 //#endregion
 //#region src/util/builders/common/distinct.ts
 /**
@@ -3241,6 +3351,21 @@ const withDefaultOrderBy = (args, tableName, defaults) => {
 	} : 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
@@ -3252,6 +3377,7 @@ const withDefaultOrderBy = (args, tableName, defaults) => {
 * 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) {
@@ -3769,6 +3895,11 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		thisRecord.columns = columns;
 		const relationArgs = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? field.args : withDefaultOrderBy(field.args ?? {}, targetTableName, defaultOrderBy);
 		const offset = relationArgs?.offset ?? void 0;
+		assertPagingNotNegative({ offset }, {
+			table: targetTableName,
+			operation: "relation",
+			relation: relName
+		});
 		const limit = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), {
 			table: targetTableName,
 			operation: "relation",
@@ -3812,6 +3943,10 @@ const pruneNonEagerRelations = (relationMap, shouldEagerLoad) => {
 const runRelationalSelect = async (opts) => {
 	const { queryBase, tables, tableName, table, relationMap, typeName, typeNameMapper, parsedInfo, offset, orderBy, where, single, filterCtx, pkNames, after, scope, deleted } = opts;
 	const distinct = opts.distinct?.length ? opts.distinct : void 0;
+	assertPagingNotNegative({
+		limit: opts.limit,
+		offset
+	});
 	const cursorSelected = !single && isCursorFieldSelected(parsedInfo.fieldsByTypeName[typeName], table);
 	let cursorEntries;
 	if (!single && (after != null || cursorSelected)) {
@@ -3863,7 +3998,11 @@ const runRelationalSelect = async (opts) => {
 		const result = await queryBase.findFirst(omitUndefinedKeys(params));
 		return result ? remapToGraphQLSingleOutput(result, tableName, table, relationMap) : void 0;
 	}
-	if (cursorEntries && cursorSelected) for (const [column] of cursorEntries) params.columns[column] = true;
+	if (cursorEntries && cursorSelected) {
+		for (const [column] of cursorEntries) params.columns[column] = true;
+		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;
 	const result = await queryBase.findMany(omitUndefinedKeys(params));
 	if (cursorEntries && cursorSelected) attachRowCursors(result, cursorEntries);
@@ -4615,6 +4754,19 @@ const keysFromWhere = (where, primaryKey) => {
 	return none;
 };
 /**
+* Whether an upsert's `onConflict` leaves the primary-key values in `values` naming exactly
+* the rows it writes. It does not when the conflict is detected on another unique key — the
+* row updated is whichever one holds that key, not the one the supplied primary key names —
+* nor when conflicting rows can be skipped: `action: NOTHING`, or a `where` guard.
+*/
+const conflictsOnKeyAlone = (onConflict, primaryKey) => {
+	if (!onConflict || typeof onConflict !== "object") return true;
+	const { target, action, where } = onConflict;
+	if (action === "NOTHING" || where !== void 0 && where !== null) return false;
+	if (!Array.isArray(target) || !target.length) return true;
+	return [...target].sort().join(",") === [...primaryKey].sort().join(",");
+};
+/**
 * The rows a generated field's arguments are about, as primary-key values.
 *
 * The row identity of a mutation lives in a different argument for every operation —
@@ -4650,7 +4802,7 @@ const identifyRows = (field, args) => {
 			table,
 			primaryKey,
 			rows: rows.filter((row) => !!row),
-			complete: entries.length > 0 && rows.every(Boolean)
+			complete: entries.length > 0 && rows.every(Boolean) && (meta.operation !== "upsert" || conflictsOnKeyAlone(args?.["onConflict"], primaryKey))
 		};
 	}
 	if (targetArg === "updates") {
@@ -4767,7 +4919,10 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 			const column = targetColumns[columnName];
 			if (column) columns[columnName] = column;
 		}
-		return columns;
+		return cursorEntries ? {
+			...columns,
+			...cursorPreciseSelection(targetTable, cursorEntries)
+		} : columns;
 	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
@@ -4777,6 +4932,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 		const { orderByArg, limit, distinct, cursorEntries, cursorValues, columns, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
 			const orderByArg = isOne ? args?.orderBy : withDefaultOrderBy(args ?? {}, targetTableName, policies?.defaultOrderBy).orderBy;
 			const limit = applyLimitPolicy(requestedLimit, limitPolicy, errorCtx);
+			assertPagingNotNegative({ offset }, errorCtx);
 			const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
 			const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
 			let cursorEntries;
@@ -7123,7 +7279,7 @@ const createSchemaBuilder = (adapter) => {
 			uniqueKeysOf: (tableName) => uniqueKeys[tableName]
 		};
 		adapter.preflight?.(db, options);
-		const nestedPlans = features.nestedWrites ? buildNestedWritePlans(tables, namedRelations, (target) => uniqueColumnSets(target), (target) => primaryKeyPropNames(target), extractRelationJoinColumns, (junction) => schemaEntries.find(([, value]) => value === junction)?.[0]) : void 0;
+		const nestedPlans = features.nestedWrites ? buildNestedWritePlans(tables, namedRelations, (target) => getUniqueColumnSets(target, adapter.getTableConfig, { partial: true }), (target) => primaryKeyPropNames(target), extractRelationJoinColumns, (junction) => schemaEntries.find(([, value]) => value === junction)?.[0]) : void 0;
 		if (nestedPlans) {
 			const omitted = gateNestedWritePlans(nestedPlans, featureOf, (tableName) => excludedTables.has(tableName));
 			if (omitted.length) {
@@ -7411,20 +7567,33 @@ const generateUpsert = (db, tableName, table, baseType, onConflictType, fieldNam
 			}
 		},
 		run: async ({ executor, args, context, before, after }) => {
-			const input = applyContextValuesAll(single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table), policies?.contextValues?.(tableName), context);
+			const contextColumns = policies?.contextValues?.(tableName);
+			const input = applyContextValuesAll(single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table), contextColumns, context);
 			if (!input.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
 			await before();
-			const plan = resolveConflictPlan({
+			const batches = resolveConflictPlan({
 				table,
 				values: input,
 				onConflict: args.onConflict,
 				pkNames,
 				uniqueSets: [],
 				excludedRef: mysqlValuesColumnRef,
-				withTarget: false
+				withTarget: false,
+				serverOwned: Object.keys(contextColumns ?? {})
+			});
+			const requestedNothing = args.onConflict?.action === "NOTHING";
+			const runBatch = async (target, { values, plan }) => {
+				if (plan.action === "NOTHING" && !requestedNothing) {
+					const columns = (0, drizzle_orm.getColumns)(table);
+					const keyName = pkNames[0] ?? Object.keys(columns)[0];
+					await target.insert(table).values(values).onDuplicateKeyUpdate({ set: { [keyName]: drizzle_orm.sql`${drizzle_orm.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 });
+			};
+			if (batches.length === 1) await runBatch(executor, batches[0]);
+			else await executor.transaction(async (tx) => {
+				for (const batch of batches) await runBatch(tx, batch);
 			});
-			if (plan.action === "NOTHING") await executor.insert(table).ignore().values(input);
-			else await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
 			await after();
 			return isSuccess;
 		}
@@ -7870,7 +8039,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				});
 				const returning = withHookReturning(nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns);
 				const runUpsert = async (target, values) => {
-					const plan = resolveConflictPlan({
+					const batches = resolveConflictPlan({
 						table,
 						values,
 						onConflict: args.onConflict,
@@ -7878,16 +8047,29 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 						uniqueSets,
 						excludedRef: excludedColumnRef,
 						withTarget: true,
+						serverOwned: Object.keys(contextColumns ?? {}),
 						buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
 					});
-					let query = target.insert(table).values(values).returning(returning);
-					const setWhere = withScope(scope, tableName, table, plan.setWhere);
-					query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({
-						target: plan.target,
-						set: plan.set,
-						setWhere
+					const runBatch = async (executor, { values: rows, plan }) => {
+						let query = executor.insert(table).values(rows).returning(returning);
+						const setWhere = withScope(scope, tableName, table, plan.setWhere);
+						query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? {
+							target: plan.target,
+							where: plan.targetWhere
+						} : void 0) : query.onConflictDoUpdate({
+							target: plan.target,
+							targetWhere: plan.targetWhere,
+							set: plan.set,
+							setWhere
+						});
+						return await query;
+					};
+					if (batches.length === 1) return runBatch(target, batches[0]);
+					return target.transaction(async (tx) => {
+						const rows = [];
+						for (const batch of batches) rows.push(...await runBatch(tx, batch));
+						return rows;
 					});
-					return await query;
 				};
 				const written = nestedEntries ? await writeWithNestedOps({
 					executor,
@@ -8067,7 +8249,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 */
 const createSchemaDataGenerator = (adapter) => {
 	const primaryKeyPropNames = adapter.primaryKeyPropNames;
-	const uniqueColumnSets = (table) => getUniqueColumnSets(table, adapter.getTableConfig);
+	const uniqueTargets = (table) => getUniqueTargets(table, adapter.getTableConfig);
 	const { generateInsert, generateUpsert, generateUpdate, generateDelete } = buildWriteResolvers(primaryKeyPropNames);
 	const { prepareBuild, forEachTable, finalizeBuild } = createSchemaBuilder(adapter);
 	return (db, schema, relations, options) => {
@@ -8108,7 +8290,7 @@ const createSchemaDataGenerator = (adapter) => {
 				single: true,
 				conflictDoNothing
 			}) : void 0;
-			const uniqueSets = tableFeatures.upsert ? uniqueColumnSets(schema[tableName]) : [];
+			const uniqueSets = tableFeatures.upsert ? uniqueTargets(schema[tableName]) : [];
 			const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
 				table: schema[tableName],
 				tableName,