@vantreeseba/drizzle-graphql 11.0.0 → 11.0.2

package/dist/index.cjs

@@ -3792,6 +3792,154 @@ const identifyRows = (field, args) => {
 	};
 };
 //#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) => {
+	let current = type;
+	while (current?.ofType) current = current.ofType;
+	return current;
+};
+/**
+* Whether a field's named output type has sub-selections. Object types and interfaces expose
+* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
+* also expose `getFields`, but an input type can never be a field's output type, so there is
+* nothing here for that to collide with.
+*/
+const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
+/**
+* The fields declared on a type, or `undefined` when it has none to declare. A union is the
+* case that matters: it has no fields of its own, so a selection directly against one resolves
+* to nothing and is dropped — only the inline fragments underneath contribute.
+*/
+const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
+/**
+* The runtime variable values, in the plain-map form the directive check wants. graphql 17
+* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
+*/
+const coercedVariables = (info) => {
+	const values = info.variableValues;
+	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
+	return values ?? {};
+};
+/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
+const directiveIfValue = (info, value) => {
+	if (value.kind === graphql.Kind.VARIABLE) return coercedVariables(info)[value.name.value];
+	if (value.kind === graphql.Kind.BOOLEAN) return value.value;
+};
+/**
+* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
+* spreads and inline fragments alike, which is where graphql puts them.
+*/
+const isExcluded = (info, node) => {
+	for (const directive of node.directives ?? []) {
+		const directiveName = directive.name.value;
+		if (directiveName !== "skip" && directiveName !== "include") continue;
+		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
+		if (!ifArgument) continue;
+		const value = directiveIfValue(info, ifArgument.value);
+		if (directiveName === "skip" ? !!value : !value) return true;
+	}
+	return false;
+};
+/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
+const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
+/**
+* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
+* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
+* to declare a field by that name.
+*/
+const isMetaField = (name) => name.startsWith("__") && name !== "__id";
+/**
+* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
+* level, this owns the entries under `parentType`'s name.
+*
+* `activeFragments` is the set of fragment names on the current spread path. A document that
+* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
+* caller assembled by hand, and an unbounded walk would hang rather than fail.
+*/
+const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
+	const parentTypeName = parentType?.name;
+	if (!parentTypeName) return tree;
+	let fields = tree[parentTypeName];
+	if (!fields) {
+		fields = {};
+		tree[parentTypeName] = fields;
+	}
+	const parentFields = fieldsOf(parentType);
+	for (const selection of selections) {
+		if (isExcluded(info, selection)) continue;
+		if (selection.kind === graphql.Kind.FIELD) {
+			const name = selection.name.value;
+			if (isMetaField(name)) continue;
+			const fieldDef = parentFields?.[name];
+			if (!fieldDef) continue;
+			const fieldType = namedTypeOf(fieldDef.type);
+			if (!fieldType) continue;
+			const composite = isCompositeLike(fieldType);
+			const alias = selection.alias?.value || name;
+			let node = fields[alias];
+			if (!node) {
+				node = {
+					name,
+					alias,
+					args: { ...(0, graphql.getArgumentValues)(fieldDef, selection, info.variableValues) },
+					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
+				};
+				fields[alias] = node;
+			}
+			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
+			continue;
+		}
+		if (!deep) continue;
+		if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
+			const fragmentName = selection.name.value;
+			const fragment = info.fragments?.[fragmentName];
+			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
+			if (activeFragments.has(fragmentName)) continue;
+			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			activeFragments.add(fragmentName);
+			try {
+				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+			} finally {
+				activeFragments.delete(fragmentName);
+			}
+			continue;
+		}
+		if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+		}
+	}
+	return tree;
+};
+/** The first key of an object, without materializing the whole key array to discard it. */
+const firstKey = (object) => {
+	for (const key in object) return key;
+};
+/**
+* Reads the selection under a resolver's own field out of its `info`, as a tree of
+* {@link ResolveTree} nodes.
+*
+* ```ts
+* const parsed = parseResolveInfo(info, { deep: true })!;
+* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+* ```
+*
+* Returns `undefined` when the resolver's field produced no node at all, which in practice
+* means `info` carried no field nodes.
+*/
+const parseResolveInfo = (info, options = {}) => {
+	const fieldNodes = info.fieldNodes;
+	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
+	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
+	const typeKey = firstKey(tree);
+	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
+	const fieldKey = fields && firstKey(fields);
+	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
+};
+//#endregion
 //#region src/util/builders/common/relation-resolvers.ts
 /**
 * Fetches a to-many relation with per-parent limit/offset for ALL parents in a
@@ -3804,8 +3952,8 @@ const identifyRows = (field, args) => {
 * Window functions require PostgreSQL, MySQL >= 8.0, or SQLite >= 3.25.
 * Returns raw rows (NOT remapped); the caller groups + remaps them.
 */
-const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx, whereArgs) => {
-	const cols = (0, drizzle_orm.getColumns)(targetTable);
+const batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, columns, orderCtx, whereArgs) => {
+	const cols = columns ?? (0, drizzle_orm.getColumns)(targetTable);
 	const orderExprs = [...orderByArg ? extractOrderBy(targetTable, orderByArg, orderCtx, whereArgs) : [], ...primaryKeyOrderExprs(targetTable, pkNames)];
 	const orderClause = orderExprs.length ? drizzle_orm.sql` order by ${drizzle_orm.sql.join(orderExprs, drizzle_orm.sql`, `)}` : drizzle_orm.sql``;
 	const RN = "__drizzle_graphql_rn";
@@ -3851,12 +3999,39 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 		operation: "relation",
 		relation: relationName
 	};
+	/**
+	* The columns one batch reads: the ones the selection names, plus the ones the batch needs
+	* whatever the client asked for — the key it groups the rows by, and the ordering columns a
+	* row cursor is encoded from. Nested relation fields contribute their own join column
+	* through the selection context, the same way the root select path narrows.
+	*
+	* `undefined` means "every column", which is what a resolver with no readable resolve info
+	* has to fall back to.
+	*/
+	const selectedColumns = (info, cursorEntries) => {
+		const parsed = info ? parseResolveInfo(info) : void 0;
+		if (!parsed) return;
+		const tree = Object.assign({}, ...Object.values(parsed.fieldsByTypeName));
+		const columns = extractSelectedColumnsFromTreeSQLFormat(tree, targetTable, {
+			tableName: targetTableName,
+			relationMap: filterCtx?.relationMap ?? {},
+			tables,
+			allRelations: filterCtx?.relationMap
+		});
+		const targetColumns = (0, drizzle_orm.getColumns)(targetTable);
+		columns[foreignColPropName] = foreignCol;
+		for (const [columnName] of cursorEntries ?? []) {
+			const column = targetColumns[columnName];
+			if (column) columns[columnName] = column;
+		}
+		return columns;
+	};
 	const resolve = async (parent, args, context, info) => {
 		if (parent[relationName] !== void 0) return parent[relationName];
 		const localValue = parent[localColPropName];
 		if (localValue == null) return isOne ? null : [];
 		const { where: whereArg, limit: requestedLimit, offset, after, deleted } = args ?? {};
-		const { orderByArg, limit, distinct, cursorEntries, cursorValues, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `relation:${tableName}::${relationName}`, () => {
+		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);
 			const distinct = (args ?? {}).distinct?.length ? (args ?? {}).distinct : void 0;
@@ -3871,6 +4046,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				} else cursorEntries = cursorOrderingEntries(orderByArg, targetPkNames);
 			}
 			const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
+			const columns = selectedColumns(info, cursorEntries);
 			const argsKey = JSON.stringify({
 				where: whereArg ?? null,
 				orderBy: orderByArg ?? null,
@@ -3879,7 +4055,8 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				deleted: deleted ?? defaultDeleted ?? null,
 				after: after ?? null,
 				distinct: distinct ?? null,
-				cursor: cursorEntries ? 1 : 0
+				cursor: cursorEntries ? 1 : 0,
+				columns: columns ? Object.keys(columns).sort() : null
 			});
 			return {
 				orderByArg,
@@ -3887,6 +4064,7 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				distinct,
 				cursorEntries,
 				cursorValues,
+				columns,
 				loaderKey: `${tableName}::${relationName}::${argsKey}`
 			};
 		});
@@ -3910,9 +4088,9 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 				whereCondition = (0, drizzle_orm.and)(whereCondition, primaryKeyRestriction(targetTable, targetPkNames, keys));
 			}
 			let rows;
-			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, relationFilterCtx(filterCtx, targetTableName), whereArg);
+			if (limit != null || offset != null) rows = await batchedPaginatedRelationQuery(executor, targetTable, foreignCol, whereCondition, orderByArg, limit ?? null, offset ?? null, targetPkNames, columns, relationFilterCtx(filterCtx, targetTableName), whereArg);
 			else {
-				let q = executor.select().from(targetTable).where(whereCondition);
+				let q = (columns ? executor.select(columns) : executor.select()).from(targetTable).where(whereCondition);
 				const orderExprs = cursorEntries ? cursorOrderExprs(targetTable, cursorEntries) : orderByArg ? extractOrderBy(targetTable, orderByArg, relationFilterCtx(filterCtx, targetTableName), whereArg) : [];
 				if (orderExprs.length) q = q.orderBy(...orderExprs);
 				rows = await q;
@@ -4927,154 +5105,6 @@ const resolveBuildConfig = (config, schema) => {
 	};
 };
 //#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) => {
-	let current = type;
-	while (current?.ofType) current = current.ofType;
-	return current;
-};
-/**
-* Whether a field's named output type has sub-selections. Object types and interfaces expose
-* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
-* also expose `getFields`, but an input type can never be a field's output type, so there is
-* nothing here for that to collide with.
-*/
-const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
-/**
-* The fields declared on a type, or `undefined` when it has none to declare. A union is the
-* case that matters: it has no fields of its own, so a selection directly against one resolves
-* to nothing and is dropped — only the inline fragments underneath contribute.
-*/
-const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
-/**
-* The runtime variable values, in the plain-map form the directive check wants. graphql 17
-* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
-*/
-const coercedVariables = (info) => {
-	const values = info.variableValues;
-	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
-	return values ?? {};
-};
-/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
-const directiveIfValue = (info, value) => {
-	if (value.kind === graphql.Kind.VARIABLE) return coercedVariables(info)[value.name.value];
-	if (value.kind === graphql.Kind.BOOLEAN) return value.value;
-};
-/**
-* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
-* spreads and inline fragments alike, which is where graphql puts them.
-*/
-const isExcluded = (info, node) => {
-	for (const directive of node.directives ?? []) {
-		const directiveName = directive.name.value;
-		if (directiveName !== "skip" && directiveName !== "include") continue;
-		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
-		if (!ifArgument) continue;
-		const value = directiveIfValue(info, ifArgument.value);
-		if (directiveName === "skip" ? !!value : !value) return true;
-	}
-	return false;
-};
-/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
-const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
-/**
-* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
-* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
-* to declare a field by that name.
-*/
-const isMetaField = (name) => name.startsWith("__") && name !== "__id";
-/**
-* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
-* level, this owns the entries under `parentType`'s name.
-*
-* `activeFragments` is the set of fragment names on the current spread path. A document that
-* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
-* caller assembled by hand, and an unbounded walk would hang rather than fail.
-*/
-const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
-	const parentTypeName = parentType?.name;
-	if (!parentTypeName) return tree;
-	let fields = tree[parentTypeName];
-	if (!fields) {
-		fields = {};
-		tree[parentTypeName] = fields;
-	}
-	const parentFields = fieldsOf(parentType);
-	for (const selection of selections) {
-		if (isExcluded(info, selection)) continue;
-		if (selection.kind === graphql.Kind.FIELD) {
-			const name = selection.name.value;
-			if (isMetaField(name)) continue;
-			const fieldDef = parentFields?.[name];
-			if (!fieldDef) continue;
-			const fieldType = namedTypeOf(fieldDef.type);
-			if (!fieldType) continue;
-			const composite = isCompositeLike(fieldType);
-			const alias = selection.alias?.value || name;
-			let node = fields[alias];
-			if (!node) {
-				node = {
-					name,
-					alias,
-					args: { ...(0, graphql.getArgumentValues)(fieldDef, selection, info.variableValues) },
-					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
-				};
-				fields[alias] = node;
-			}
-			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
-			continue;
-		}
-		if (!deep) continue;
-		if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
-			const fragmentName = selection.name.value;
-			const fragment = info.fragments?.[fragmentName];
-			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
-			if (activeFragments.has(fragmentName)) continue;
-			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
-			if (!isCompositeLike(fragmentType)) continue;
-			activeFragments.add(fragmentName);
-			try {
-				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
-			} finally {
-				activeFragments.delete(fragmentName);
-			}
-			continue;
-		}
-		if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
-			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
-			if (!isCompositeLike(fragmentType)) continue;
-			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
-		}
-	}
-	return tree;
-};
-/** The first key of an object, without materializing the whole key array to discard it. */
-const firstKey = (object) => {
-	for (const key in object) return key;
-};
-/**
-* Reads the selection under a resolver's own field out of its `info`, as a tree of
-* {@link ResolveTree} nodes.
-*
-* ```ts
-* const parsed = parseResolveInfo(info, { deep: true })!;
-* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
-* ```
-*
-* Returns `undefined` when the resolver's field produced no node at all, which in practice
-* means `info` carried no field nodes.
-*/
-const parseResolveInfo = (info, options = {}) => {
-	const fieldNodes = info.fieldNodes;
-	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
-	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
-	const typeKey = firstKey(tree);
-	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
-	const fieldKey = fields && firstKey(fields);
-	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
-};
-//#endregion
 //#region src/util/builders/aggregates.ts
 /** Operations that aggregate over a set of column values. `count` is handled separately (whole rows). */
 const AGGREGATE_OPS = [
@@ -5364,17 +5394,22 @@ const createRelationAggregateFactory = (db, tables, cacheCtx, typeNameMapper, fi
 		};
 		const resolve = async (parent, args, context, info) => {
 			try {
-				const request = parseAggregateRequest(info, target);
+				const { request, loaderKey } = getOrCreateRequestValue(context, info?.fieldNodes?.[0], `aggregate:${tableName}::${relationName}`, () => {
+					const request = parseAggregateRequest(info, target);
+					return {
+						request,
+						loaderKey: `${tableName}::${relationName}::aggregate::${JSON.stringify({
+							where: args?.where ?? null,
+							deleted: args?.deleted ?? defaultDeleted ?? null,
+							selection: Object.keys(request.selection).sort()
+						})}`
+					};
+				});
 				if (!Object.keys(request.selection).length) return {};
 				const localValue = parent[localColPropName];
 				if (localValue == null) return assembleAggregateRow({}, request, target);
 				const whereArg = args?.where;
 				const deleted = args?.deleted;
-				const loaderKey = `${tableName}::${relationName}::aggregate::${JSON.stringify({
-					where: whereArg ?? null,
-					deleted: deleted ?? defaultDeleted ?? null,
-					selection: Object.keys(request.selection).sort()
-				})}`;
 				const loader = getOrCreateLoader(context, loaderKey, async (parentIds) => {
 					const executor = resolveExecutor(db, context);
 					const uniqueIds = [...new Set(parentIds)];
@@ -5954,7 +5989,7 @@ const createNestedWriteRuntime = (params) => {
 	};
 	/** The values the junction stores for the target rows one operand selects. */
 	const selectedTargetKeys = async (executor, plan, filter, operation, scope) => {
-		return (await executor.select().from(plan.targetTable).where(conditionOf(plan, filter, operation, scope))).map((row) => row[plan.foreignColPropName]).filter((value) => value !== void 0 && value !== null);
+		return (await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, filter, operation, scope))).map((row) => row[plan.foreignColPropName]).filter((value) => value !== void 0 && value !== null);
 	};
 	/**
 	* The link half of a many-to-many write: junction rows are inserted and deleted, and both
@@ -5969,7 +6004,7 @@ const createNestedWriteRuntime = (params) => {
 		const through = plan.through;
 		const unlinkAll = () => executor.delete(through.table).where((0, drizzle_orm.eq)(through.sourceCol, key));
 		const link = async (operands, operation) => {
-			const existing = new Set((await executor.select().from(through.table).where((0, drizzle_orm.eq)(through.sourceCol, key))).map((row) => row[through.targetColPropName]));
+			const existing = new Set((await executor.select({ [through.targetColPropName]: through.targetCol }).from(through.table).where((0, drizzle_orm.eq)(through.sourceCol, key))).map((row) => row[through.targetColPropName]));
 			const rows = [];
 			for (const filter of operands) for (const targetKey of await selectedTargetKeys(executor, plan, filter, operation, scope)) if (!existing.has(targetKey)) {
 				existing.add(targetKey);
@@ -6030,11 +6065,11 @@ const createNestedWriteRuntime = (params) => {
 				assertSingleOperation(plan, op);
 				if (op["create"] !== void 0) {
 					const values = applyContextValues(remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable), contextValues?.(plan.targetTableName), context);
-					const created = (await executor.insert(plan.targetTable).values(values).returning())[0];
+					const created = (await executor.insert(plan.targetTable).values(values).returning({ [plan.foreignColPropName]: plan.foreignCol }))[0];
 					if (!created) throw drizzleError(`Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					patch[plan.localColPropName] = created[plan.foreignColPropName];
 				} else if (op["connect"] !== void 0) {
-					const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
+					const rows = await executor.select({ [plan.foreignColPropName]: plan.foreignCol }).from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect", scope));
 					if (rows.length !== 1) throw drizzleError(`Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows — it attaches a single row, so its filter must match exactly one.`, { code: "DRIZZLE_NESTED_WRITE_INVALID" });
 					patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
 				} else if (op["disconnect"] === true) patch[plan.localColPropName] = null;