@vantreeseba/drizzle-graphql 10.0.2 → 11.0.0

package/README.md

@@ -353,9 +353,23 @@ const { schema } = buildSchema(db, {
 })
 ```
 
+Both suffixes reach every operation that comes in a list/single pair, mutations included:
+the config above gives `usersAll` / `users` on the query side and `addUsersAll` / `addUsers`,
+`editUsersAll` / `editUsers`, `removeUsersAll` / `removeUsers` on the mutation side. The
+variants that carry their own disambiguator — `usersAggregate`, `usersGroupBy`,
+`updateUsersMany`, `updateUsersCount`, `deleteUsersCount` — take neither suffix.
+
 The list and single suffixes cannot be identical unless a `typeNameMapper` is also given —
 `users` and `usersSingle` would otherwise collapse onto one field name, and `buildSchema`
-throws rather than generating a schema that silently drops one of them.
+throws rather than generating a schema that silently drops one of them. With a mapper the
+plural and singular nouns keep the queries and the inserts apart, but the bulk update,
+delete and restore mutations are singular on both sides, so those three keep a `Single`
+suffix whenever the two configured suffixes are the same string.
+
+That check compares the configured suffixes, which is only part of what a name is made of.
+Every generated root field is also registered by name, and a build that puts two operations
+on one field name throws naming the field rather than dropping whichever registered first —
+whatever combination of prefixes, suffixes and mapper produced it.
 
 `typeNameMapper` renames the table itself, which is what a plural-keyed schema usually wants:
 `export const users = pgTable('users', …)` otherwise produces `type Users` and a

package/dist/index.cjs

@@ -3178,16 +3178,23 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 	if (!info) return;
 	const relationsForTable = relationMap[tableName];
 	if (!relationsForTable) return;
-	const baseField = Object.entries(info.fieldsByTypeName).find(([key, _value]) => key === typeName)?.[1];
+	const baseField = info.fieldsByTypeName[typeName];
 	if (!baseField) return;
+	const selectionsByName = /* @__PURE__ */ new Map();
+	for (const selection of Object.values(baseField)) {
+		const selections = selectionsByName.get(selection.name);
+		if (selections) selections.push(selection);
+		else selectionsByName.set(selection.name, [selection]);
+	}
 	const args = {};
 	for (const [relName, relEntry] of Object.entries(relationsForTable)) {
 		const { targetTableName, targetPkNames } = relEntry;
 		const relTypeName = resolveObjectTypeName(targetTableName, typeNameMapper, resolveName);
-		const field = baseField[relName] ?? Object.values(baseField).find((f) => f.name === relName);
-		if (!field) continue;
-		if (Object.values(baseField).reduce((n, f) => n + (f.name === relName ? 1 : 0), 0) > 1) continue;
-		const relFieldSelection = (field?.fieldsByTypeName)?.[relTypeName];
+		const selections = selectionsByName.get(relName);
+		if (!selections) continue;
+		const field = selections[0];
+		if (selections.length > 1) continue;
+		const relFieldSelection = field.fieldsByTypeName[relTypeName];
 		if (!relFieldSelection) continue;
 		const eagerArgs = field.args;
 		if (!(0, drizzle_orm.is)(relEntry.relation ?? relEntry, drizzle_orm.One) && (eagerArgs?.after != null || !!(eagerArgs?.distinct)?.length || isCursorFieldSelected(relFieldSelection, tables[targetTableName]))) continue;
@@ -3199,8 +3206,7 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		});
 		const thisRecord = {};
 		thisRecord.columns = columns;
-		const relationField = Object.values(baseField).find((e) => e.name === relName);
-		const relationArgs = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? relationField?.args : relationField && withDefaultOrderBy(relationField.args ?? {}, targetTableName, defaultOrderBy);
+		const relationArgs = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? field.args : withDefaultOrderBy(field.args ?? {}, targetTableName, defaultOrderBy);
 		const offset = relationArgs?.offset ?? void 0;
 		const limit = (0, drizzle_orm.is)(relEntry.relation, drizzle_orm.One) ? relationArgs?.limit ?? void 0 : applyLimitPolicy(relationArgs?.limit, limits?.(targetTableName), {
 			table: targetTableName,
@@ -3215,7 +3221,7 @@ const extractRelationsParams = (relationMap, tables, tableName, info, typeName,
 		thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName), relWhere) : hasPagination && pkNames.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0;
 		thisRecord.offset = offset;
 		thisRecord.limit = limit;
-		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, relationField, relTypeName, options);
+		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, field, relTypeName, options);
 		args[relName] = thisRecord;
 	}
 	return args;
@@ -3563,6 +3569,7 @@ const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, f
 //#endregion
 //#region src/util/batch-loader/index.ts
 const DRIZZLE_LOADERS_KEY = Symbol("drizzle-graphql-loaders");
+const DRIZZLE_REQUEST_CACHE_KEY = Symbol("drizzle-graphql-request-cache");
 var BatchLoader = class {
 	batchFn;
 	batch = [];
@@ -3606,6 +3613,32 @@ const getOrCreateLoader = (context, key, batchFn) => {
 	if (!loaders.has(key)) loaders.set(key, new BatchLoader(batchFn));
 	return loaders.get(key);
 };
+/**
+* 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.
+*
+* `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);
+	}
+	if (entries.has(key)) return entries.get(key);
+	const value = compute();
+	entries.set(key, value);
+	return value;
+};
 //#endregion
 //#region src/util/extensions.ts
 /**
@@ -3823,30 +3856,40 @@ const createRelationResolverFactory = (db, tables, nullOrdering, filterCtx, limi
 		const localValue = parent[localColPropName];
 		if (localValue == null) return isOne ? null : [];
 		const { where: whereArg, limit: requestedLimit, offset, after, deleted } = args ?? {};
-		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;
-		const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
-		let cursorEntries;
-		if (!isOne && (after != null || cursorSelected)) {
-			if (after != null && distinct) throw drizzleError("'after' cannot be combined with 'distinct'.", { code: "DRIZZLE_INVALID_CURSOR" });
-			if (orderByHasRelationEntry(orderByArg)) {
-				if (after != null) throw drizzleError("'after' cannot be combined with an orderBy that orders through a relation — a related row's value cannot be encoded into a cursor.", { code: "DRIZZLE_INVALID_CURSOR" });
-			} else if (!targetPkNames.length) {
-				if (after != null) throw drizzleError(`Table ${targetTableName} has no primary key, so cursor pagination cannot be used on it.`, { code: "DRIZZLE_INVALID_CURSOR" });
-			} else cursorEntries = cursorOrderingEntries(orderByArg, targetPkNames);
-		}
-		const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
-		const loaderKey = `${tableName}::${relationName}::${JSON.stringify({
-			where: whereArg ?? null,
-			orderBy: orderByArg ?? null,
-			limit: limit ?? null,
-			offset: offset ?? null,
-			deleted: deleted ?? defaultDeleted ?? null,
-			after: after ?? null,
-			distinct: distinct ?? null,
-			cursor: cursorEntries ? 1 : 0
-		})}`;
+		const { orderByArg, limit, distinct, cursorEntries, cursorValues, 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;
+			const cursorSelected = !isOne && !!info && selectsCursorField(info, targetTable);
+			let cursorEntries;
+			if (!isOne && (after != null || cursorSelected)) {
+				if (after != null && distinct) throw drizzleError("'after' cannot be combined with 'distinct'.", { code: "DRIZZLE_INVALID_CURSOR" });
+				if (orderByHasRelationEntry(orderByArg)) {
+					if (after != null) throw drizzleError("'after' cannot be combined with an orderBy that orders through a relation — a related row's value cannot be encoded into a cursor.", { code: "DRIZZLE_INVALID_CURSOR" });
+				} else if (!targetPkNames.length) {
+					if (after != null) throw drizzleError(`Table ${targetTableName} has no primary key, so cursor pagination cannot be used on it.`, { code: "DRIZZLE_INVALID_CURSOR" });
+				} else cursorEntries = cursorOrderingEntries(orderByArg, targetPkNames);
+			}
+			const cursorValues = after != null && cursorEntries ? decodeCursor(after, cursorEntries) : void 0;
+			const argsKey = JSON.stringify({
+				where: whereArg ?? null,
+				orderBy: orderByArg ?? null,
+				limit: limit ?? null,
+				offset: offset ?? null,
+				deleted: deleted ?? defaultDeleted ?? null,
+				after: after ?? null,
+				distinct: distinct ?? null,
+				cursor: cursorEntries ? 1 : 0
+			});
+			return {
+				orderByArg,
+				limit,
+				distinct,
+				cursorEntries,
+				cursorValues,
+				loaderKey: `${tableName}::${relationName}::${argsKey}`
+			};
+		});
 		return getOrCreateLoader(context, loaderKey, async (parentIds) => {
 			const executor = resolveExecutor(db, context);
 			const uniqueIds = [...new Set(parentIds)];
@@ -3920,20 +3963,24 @@ const computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes
 	const singleFieldName = mapped?.singular ?? uncapitalize(tableName) + suffixes.single;
 	const aggregateFieldName = `${mapped?.plural ?? uncapitalize(tableName)}Aggregate`;
 	const groupByFieldName = `${mapped?.plural ?? uncapitalize(tableName)}GroupBy`;
-	const createArrayFieldName = `${prefixes.insert}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
+	const pluralNoun = mapped ? capitalize(mapped.plural) : capitalize(tableName);
+	const singularNoun = mapped ? capitalize(mapped.singular) : capitalize(tableName);
+	const createArrayFieldName = `${prefixes.insert}${pluralNoun}${suffixes.list}`;
 	const createSingleFieldName = mapped ? `${prefixes.insert}${capitalize(mapped.singular)}` : `${prefixes.insert}${capitalize(tableName)}${suffixes.single}`;
 	const upsertPrefix = prefixes.upsert ?? "upsert";
-	const upsertArrayFieldName = `${upsertPrefix}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}`;
+	const upsertArrayFieldName = `${upsertPrefix}${pluralNoun}${suffixes.list}`;
 	const upsertSingleFieldName = mapped ? `${upsertPrefix}${capitalize(mapped.singular)}` : `${upsertPrefix}${capitalize(tableName)}${suffixes.single}`;
-	const updateFieldName = `${prefixes.update}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
-	const updateManyFieldName = `${prefixes.update}${mapped ? capitalize(mapped.plural) : capitalize(tableName)}Many`;
-	const deleteFieldName = `${prefixes.delete}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
-	const restoreFieldName = `${prefixes.restore ?? "restore"}${mapped ? capitalize(mapped.singular) : capitalize(tableName)}`;
-	const writeSingleSuffix = suffixes.single === "" ? "Single" : suffixes.single;
-	const updateSingleFieldName = `${updateFieldName}${writeSingleSuffix}`;
-	const deleteSingleFieldName = `${deleteFieldName}${writeSingleSuffix}`;
-	const restoreSingleFieldName = `${restoreFieldName}${writeSingleSuffix}`;
-	const pluralNoun = mapped ? capitalize(mapped.plural) : capitalize(tableName);
+	const updateBase = `${prefixes.update}${singularNoun}`;
+	const deleteBase = `${prefixes.delete}${singularNoun}`;
+	const restoreBase = `${prefixes.restore ?? "restore"}${singularNoun}`;
+	const updateFieldName = `${updateBase}${suffixes.list}`;
+	const updateManyFieldName = `${prefixes.update}${pluralNoun}Many`;
+	const deleteFieldName = `${deleteBase}${suffixes.list}`;
+	const restoreFieldName = `${restoreBase}${suffixes.list}`;
+	const writeSingleSuffix = suffixes.single === suffixes.list ? "Single" : suffixes.single;
+	const updateSingleFieldName = `${updateBase}${writeSingleSuffix}`;
+	const deleteSingleFieldName = `${deleteBase}${writeSingleSuffix}`;
+	const restoreSingleFieldName = `${restoreBase}${writeSingleSuffix}`;
 	return {
 		typeName,
 		listFieldName,
@@ -3956,6 +4003,26 @@ const computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes
 	};
 };
 //#endregion
+//#region src/util/builders/common/root-fields.ts
+/**
+* Registers one generated root field, refusing to overwrite a name already taken.
+*
+* A generated name is the table name run through `typeNameMapper`, a prefix and a suffix,
+* and the pluralization each operation applies — so whether two operations collide is a
+* property of the finished names, not of any one piece of the config. `buildSchema` checks
+* what it can up front (identical list and single suffixes with no mapper), but that check
+* compares the suffix *strings*, which cannot see a collision the rest of the naming rules
+* produce: `{ list: 'All', single: '' }` used to give both insert mutations the name
+* `createUsers`, and the array insert simply disappeared from the schema.
+*
+* Assigning into the record silently kept the last registration. Throwing here means a
+* naming config that cannot work says so at build time, naming the field it lost.
+*/
+const defineRootField = (fields, kind, name, config) => {
+	if (Object.getOwnPropertyDescriptor(fields, name) !== void 0) throw new Error(`Drizzle-GraphQL Error: two generated ${kind} fields are both named '${name}'. Generated names come from the table name plus config.prefixes, config.suffixes and config.typeNameMapper — some combination of those gives two operations the same name. Adjust one of them so each operation gets its own.`);
+	fields[name] = config;
+};
+//#endregion
 //#region src/util/builders/common/select-runtime.ts
 /**
 * Runs the relational-query-builder select shared by every dialect's `generateSelect*`
@@ -6318,7 +6385,7 @@ const createSchemaBuilder = (adapter) => {
 		const groupByEnum = groupByType ? generateGroupByEnum(table, tableName, typeName, cacheCtx) : void 0;
 		const havingInput = groupByEnum ? generateHavingInput(table, tableName, typeName, cacheCtx) : void 0;
 		const groupByGenerated = groupByType && groupByEnum && havingInput ? generateGroupBy(db, tableName, table, typeName, groupByFieldName, tableFilters, groupByEnum, havingInput, filterCtx, tablePolicies, cacheCtx.typeName) : void 0;
-		ctx.queries[selectArrGenerated.name] = {
+		defineRootField(ctx.queries, "query", selectArrGenerated.name, {
 			type: selectArrOutput,
 			args: selectArrGenerated.args,
 			resolve: selectArrGenerated.resolver,
@@ -6331,8 +6398,8 @@ const createSchemaBuilder = (adapter) => {
 				}),
 				...complexity ? { complexity: listFieldComplexity(complexity, limits?.(tableName)) } : {}
 			}
-		};
-		ctx.queries[selectSingleGenerated.name] = {
+		});
+		defineRootField(ctx.queries, "query", selectSingleGenerated.name, {
 			type: selectSingleOutput,
 			args: selectSingleGenerated.args,
 			resolve: selectSingleGenerated.resolver,
@@ -6342,8 +6409,8 @@ const createSchemaBuilder = (adapter) => {
 				single: true,
 				targetArg: "where"
 			}) }
-		};
-		if (aggregateGenerated && aggregateType) ctx.queries[aggregateGenerated.name] = {
+		});
+		if (aggregateGenerated && aggregateType) defineRootField(ctx.queries, "query", aggregateGenerated.name, {
 			type: new graphql.GraphQLNonNull(aggregateType),
 			args: aggregateGenerated.args,
 			resolve: aggregateGenerated.resolver,
@@ -6356,8 +6423,8 @@ const createSchemaBuilder = (adapter) => {
 				}),
 				...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
 			}
-		};
-		if (groupByGenerated && groupByType) ctx.queries[groupByGenerated.name] = {
+		});
+		if (groupByGenerated && groupByType) defineRootField(ctx.queries, "query", groupByGenerated.name, {
 			type: new graphql.GraphQLNonNull(new graphql.GraphQLList(new graphql.GraphQLNonNull(groupByType))),
 			args: groupByGenerated.args,
 			resolve: groupByGenerated.resolver,
@@ -6370,7 +6437,7 @@ const createSchemaBuilder = (adapter) => {
 				}),
 				...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
 			}
-		};
+		});
 		return {
 			aggregateType,
 			groupByType,
@@ -6748,7 +6815,7 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 				targetArg: "where"
 			}]
 		];
-		for (const [generated, meta] of generatedMutations) if (generated) mutations[generated.name] = {
+		for (const [generated, meta] of generatedMutations) if (generated) defineRootField(mutations, "mutation", generated.name, {
 			type: mutationReturnType,
 			args: generated.args,
 			resolve: generated.resolver,
@@ -6756,19 +6823,19 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 				kind: "mutation",
 				...meta
 			}) }
-		};
-		if (updateCountGenerated) mutations[updateCountGenerated.name] = {
+		});
+		if (updateCountGenerated) defineRootField(mutations, "mutation", updateCountGenerated.name, {
 			type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
 			args: updateCountGenerated.args,
 			resolve: updateCountGenerated.resolver,
 			description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
-		};
-		if (deleteCountGenerated) mutations[deleteCountGenerated.name] = {
+		});
+		if (deleteCountGenerated) defineRootField(mutations, "mutation", deleteCountGenerated.name, {
 			type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
 			args: deleteCountGenerated.args,
 			resolve: deleteCountGenerated.resolver,
 			description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
-		};
+		});
 		[
 			...tableFeatures.insert || onConflictInput ? [insertInput] : [],
 			...onConflictInput ? [onConflictInput] : [],
@@ -7214,7 +7281,7 @@ const createSchemaDataGenerator = (adapter) => {
 				filterCtx,
 				txCtx: mutationTxCtx
 			}) : void 0;
-			if (insertArrGenerated) mutations[insertArrGenerated.name] = {
+			if (insertArrGenerated) defineRootField(mutations, "mutation", insertArrGenerated.name, {
 				type: arrTableItemOutput,
 				args: insertArrGenerated.args,
 				resolve: insertArrGenerated.resolver,
@@ -7224,8 +7291,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: false,
 					targetArg: "values"
 				}) }
-			};
-			if (insertSingleGenerated) mutations[insertSingleGenerated.name] = {
+			});
+			if (insertSingleGenerated) defineRootField(mutations, "mutation", insertSingleGenerated.name, {
 				type: conflictDoNothing ? singleTableItemOutput : new graphql.GraphQLNonNull(singleTableItemOutput),
 				args: insertSingleGenerated.args,
 				resolve: insertSingleGenerated.resolver,
@@ -7235,8 +7302,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: true,
 					targetArg: "values"
 				}) }
-			};
-			if (upsertArrGenerated) mutations[upsertArrGenerated.name] = {
+			});
+			if (upsertArrGenerated) defineRootField(mutations, "mutation", upsertArrGenerated.name, {
 				type: arrTableItemOutput,
 				args: upsertArrGenerated.args,
 				resolve: upsertArrGenerated.resolver,
@@ -7246,8 +7313,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: false,
 					targetArg: "values"
 				}) }
-			};
-			if (upsertSingleGenerated) mutations[upsertSingleGenerated.name] = {
+			});
+			if (upsertSingleGenerated) defineRootField(mutations, "mutation", upsertSingleGenerated.name, {
 				type: singleTableItemOutput,
 				args: upsertSingleGenerated.args,
 				resolve: upsertSingleGenerated.resolver,
@@ -7257,8 +7324,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: true,
 					targetArg: "values"
 				}) }
-			};
-			if (updateGenerated) mutations[updateGenerated.name] = {
+			});
+			if (updateGenerated) defineRootField(mutations, "mutation", updateGenerated.name, {
 				type: arrTableItemOutput,
 				args: updateGenerated.args,
 				resolve: updateGenerated.resolver,
@@ -7268,8 +7335,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: false,
 					targetArg: "where"
 				}) }
-			};
-			if (updateManyGenerated) mutations[updateManyGenerated.name] = {
+			});
+			if (updateManyGenerated) defineRootField(mutations, "mutation", updateManyGenerated.name, {
 				type: new graphql.GraphQLNonNull(new graphql.GraphQLList(singleTableItemOutput)),
 				args: updateManyGenerated.args,
 				resolve: updateManyGenerated.resolver,
@@ -7280,8 +7347,8 @@ const createSchemaDataGenerator = (adapter) => {
 					targetArg: "updates"
 				}) },
 				description: "Each entry's updated rows, in entry order. An entry whose `where` matched no rows contributes `null` in its slot; an entry that matched several contributes each of its rows."
-			};
-			if (updateSingleGenerated) mutations[updateSingleGenerated.name] = {
+			});
+			if (updateSingleGenerated) defineRootField(mutations, "mutation", updateSingleGenerated.name, {
 				type: singleTableItemOutput,
 				args: updateSingleGenerated.args,
 				resolve: updateSingleGenerated.resolver,
@@ -7291,8 +7358,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: true,
 					targetArg: "where"
 				}) }
-			};
-			if (deleteGenerated) mutations[deleteGenerated.name] = {
+			});
+			if (deleteGenerated) defineRootField(mutations, "mutation", deleteGenerated.name, {
 				type: arrTableItemOutput,
 				args: deleteGenerated.args,
 				resolve: deleteGenerated.resolver,
@@ -7303,8 +7370,8 @@ const createSchemaDataGenerator = (adapter) => {
 					targetArg: "where",
 					...softDeleteInfo?.hardDelete ? { hardDelete: true } : {}
 				}) }
-			};
-			if (deleteSingleGenerated) mutations[deleteSingleGenerated.name] = {
+			});
+			if (deleteSingleGenerated) defineRootField(mutations, "mutation", deleteSingleGenerated.name, {
 				type: singleTableItemOutput,
 				args: deleteSingleGenerated.args,
 				resolve: deleteSingleGenerated.resolver,
@@ -7315,8 +7382,8 @@ const createSchemaDataGenerator = (adapter) => {
 					targetArg: "where",
 					...softDeleteInfo?.hardDelete ? { hardDelete: true } : {}
 				}) }
-			};
-			if (restoreGenerated) mutations[restoreGenerated.name] = {
+			});
+			if (restoreGenerated) defineRootField(mutations, "mutation", restoreGenerated.name, {
 				type: arrTableItemOutput,
 				args: restoreGenerated.args,
 				resolve: restoreGenerated.resolver,
@@ -7326,8 +7393,8 @@ const createSchemaDataGenerator = (adapter) => {
 					single: false,
 					targetArg: "where"
 				}) }
-			};
-			if (restoreSingleGenerated) mutations[restoreSingleGenerated.name] = {
+			});
+			if (restoreSingleGenerated) defineRootField(mutations, "mutation", restoreSingleGenerated.name, {
 				type: singleTableItemOutput,
 				args: restoreSingleGenerated.args,
 				resolve: restoreSingleGenerated.resolver,
@@ -7337,19 +7404,19 @@ const createSchemaDataGenerator = (adapter) => {
 					single: true,
 					targetArg: "where"
 				}) }
-			};
-			if (updateCountGenerated) mutations[updateCountGenerated.name] = {
+			});
+			if (updateCountGenerated) defineRootField(mutations, "mutation", updateCountGenerated.name, {
 				type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
 				args: updateCountGenerated.args,
 				resolve: updateCountGenerated.resolver,
 				description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
-			};
-			if (deleteCountGenerated) mutations[deleteCountGenerated.name] = {
+			});
+			if (deleteCountGenerated) defineRootField(mutations, "mutation", deleteCountGenerated.name, {
 				type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
 				args: deleteCountGenerated.args,
 				resolve: deleteCountGenerated.resolver,
 				description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
-			};
+			});
 			[
 				...tableFeatures.insert || onConflictInput ? [insertInput] : [],
 				...onConflictInput ? [onConflictInput] : [],