@vantreeseba/drizzle-graphql 10.0.3 → 11.0.1

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

@@ -3569,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 = [];
@@ -3612,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
 /**
@@ -3829,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)];
@@ -3926,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,
@@ -3962,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*`
@@ -5303,17 +5364,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)];
@@ -6324,7 +6390,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,
@@ -6337,8 +6403,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,
@@ -6348,8 +6414,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,
@@ -6362,8 +6428,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,
@@ -6376,7 +6442,7 @@ const createSchemaBuilder = (adapter) => {
 				}),
 				...complexity ? { complexity: aggregateFieldComplexity(complexity) } : {}
 			}
-		};
+		});
 		return {
 			aggregateType,
 			groupByType,
@@ -6754,7 +6820,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,
@@ -6762,19 +6828,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] : [],
@@ -7220,7 +7286,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,
@@ -7230,8 +7296,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,
@@ -7241,8 +7307,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,
@@ -7252,8 +7318,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,
@@ -7263,8 +7329,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,
@@ -7274,8 +7340,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,
@@ -7286,8 +7352,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,
@@ -7297,8 +7363,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,
@@ -7309,8 +7375,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,
@@ -7321,8 +7387,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,
@@ -7332,8 +7398,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,
@@ -7343,19 +7409,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] : [],