@vantreeseba/drizzle-graphql 12.0.0 → 13.0.0

package/dist/index.cjs

@@ -4320,17 +4320,15 @@ const computeResolverFieldNames = (tableName, typeNameMapper, prefixes, suffixes
 	const upsertPrefix = prefixes.upsert ?? "upsert";
 	const upsertArrayFieldName = `${upsertPrefix}${pluralNoun}${suffixes.list}`;
 	const upsertSingleFieldName = mapped ? `${upsertPrefix}${capitalize(mapped.singular)}` : `${upsertPrefix}${capitalize(tableName)}${suffixes.single}`;
-	const updateBase = `${prefixes.update}${singularNoun}`;
-	const deleteBase = `${prefixes.delete}${singularNoun}`;
-	const restoreBase = `${prefixes.restore ?? "restore"}${singularNoun}`;
-	const updateFieldName = `${updateBase}${suffixes.list}`;
+	const restorePrefix = prefixes.restore ?? "restore";
+	const updateFieldName = `${prefixes.update}${pluralNoun}${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}`;
+	const deleteFieldName = `${prefixes.delete}${pluralNoun}${suffixes.list}`;
+	const restoreFieldName = `${restorePrefix}${pluralNoun}${suffixes.list}`;
+	const singleWrite = (prefix) => mapped ? `${prefix}${singularNoun}` : `${prefix}${singularNoun}${suffixes.single}`;
+	const updateSingleFieldName = singleWrite(prefixes.update);
+	const deleteSingleFieldName = singleWrite(prefixes.delete);
+	const restoreSingleFieldName = singleWrite(restorePrefix);
 	return {
 		typeName,
 		listFieldName,
@@ -6530,6 +6528,72 @@ const createSchemaBuilder = (adapter) => {
 			havingInput
 		};
 	};
+	/**
+	* The per-table loop, run once for every table the build covers.
+	*
+	* The dialect's callback receives the values the loop has already worked out — the feature
+	* flags, the extension factory, the field names, the table's generated types and its
+	* soft-delete config — and answers with the mutations it generated. Registering them, and
+	* registering the inputs and outputs those mutations reference, happens here: both sides
+	* did it identically, down to the `description` strings on the count mutations, so a gate
+	* changed on one side and forgotten on the other used to be a silent dialect divergence.
+	*
+	* What stays in the dialect is what genuinely differs — which generators run, what each
+	* mutation returns, and (on MySQL) that a write cannot report the rows it touched.
+	*/
+	const forEachTable = (ctx, perTable) => {
+		const { schema, featureOf, softDeleteOf, typeNameMapper, gqlSchemaTypes, mutations, inputs, outputs } = ctx;
+		const { prefixes, suffixes } = ctx.options;
+		for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
+			const tableFeatures = featureOf(tableName);
+			const drizzleMeta = tableFieldExtensions(tableName, primaryKeyPropNames(schema[tableName]));
+			const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+			const softDeleteInfo = softDeleteOf?.(tableName);
+			const readTypes = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
+			const built = perTable({
+				tableName,
+				table: schema[tableName],
+				tableFeatures,
+				drizzleMeta,
+				names,
+				types: tableTypes,
+				softDeleteInfo
+			});
+			for (const { generated, type, meta, description } of built.mutations) if (generated) defineRootField(mutations, "mutation", generated.name, {
+				type,
+				args: generated.args,
+				resolve: generated.resolver,
+				...meta ? { extensions: { drizzle: drizzleMeta({
+					kind: "mutation",
+					...meta
+				}) } } : {},
+				...description ? { description } : {}
+			});
+			const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
+			[
+				...tableFeatures.insert || built.onConflictInput ? [insertInput] : [],
+				...built.onConflictInput ? [built.onConflictInput] : [],
+				...tableFeatures.update ? [updateInput] : [],
+				...built.updateManyInput ? [built.updateManyInput] : [],
+				tableFilters,
+				tableOrder
+			].forEach((e) => {
+				inputs[e.name] = e;
+			});
+			const { selectSingleOutput } = tableTypes.outputs;
+			outputs[selectSingleOutput.name] = selectSingleOutput;
+			if (adapter.returnsRows) {
+				const { singleTableItemOutput } = tableTypes.outputs;
+				outputs[singleTableItemOutput.name] = singleTableItemOutput;
+			}
+			const { aggregateType, groupByType, havingInput } = readTypes;
+			if (aggregateType) outputs[aggregateType.name] = aggregateType;
+			if (groupByType && havingInput) {
+				outputs[groupByType.name] = groupByType;
+				inputs[havingInput.name] = havingInput;
+			}
+		}
+	};
 	/** The relation field resolvers and the transaction roster, once every root field exists. */
 	const finalizeBuild = (ctx) => {
 		if (ctx.mutationTxCtx) for (const name of Object.keys(ctx.mutations)) ctx.mutationTxCtx.fieldNames.add(name);
@@ -6560,7 +6624,7 @@ const createSchemaBuilder = (adapter) => {
 		primaryKeyPropNames,
 		uniqueColumnSets,
 		prepareBuild,
-		addReadFields,
+		forEachTable,
 		finalizeBuild
 	};
 };
@@ -6769,7 +6833,7 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 const getTableConfig$2 = memoizeTableConfig(drizzle_orm_mysql_core.getTableConfig);
 /** Primary-key property names for a MySQL table, including table-level composite keys. */
 const mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$2);
-const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder({
+const { prepareBuild, forEachTable, finalizeBuild } = createSchemaBuilder({
 	tableClass: drizzle_orm_mysql_core.MySqlTable,
 	getTableConfig: getTableConfig$2,
 	primaryKeyPropNames: mysqlPrimaryKeyPropNames,
@@ -6780,9 +6844,9 @@ const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder({
 	}
 });
 const generateSchemaData$2 = (db, schema, relations, options) => {
-	const { prefixes, suffixes, typeNameMapper } = options;
+	const { prefixes } = options;
 	const ctx = prepareBuild(db, schema, relations, options);
-	const { featureOf, anyTable, filterCtx, policies, softDeleteOf, cacheCtx, mutationTxCtx, gqlSchemaTypes, mutations, inputs, outputs } = ctx;
+	const { anyTable, filterCtx, policies, cacheCtx, mutationTxCtx, outputs } = ctx;
 	const mutationReturnType = new graphql.GraphQLObjectType({
 		name: cacheCtx.typeName({
 			kind: "shared",
@@ -6796,15 +6860,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 		"update",
 		"delete"
 	].some((feature) => anyTable(feature))) outputs["MutationReturn"] = mutationReturnType;
-	for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-		const tableFeatures = featureOf(tableName);
-		const drizzleMeta = tableFieldExtensions(tableName, mysqlPrimaryKeyPropNames(schema[tableName]));
-		const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-		const { selectSingleOutput } = tableTypes.outputs;
-		const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+	forEachTable(ctx, ({ tableName, tableFeatures, names, types, softDeleteInfo }) => {
+		const { insertInput, updateInput, tableFilters } = types.inputs;
 		const { typeName, createArrayFieldName, createSingleFieldName, upsertArrayFieldName, upsertSingleFieldName, updateFieldName, updateManyFieldName, updateSingleFieldName, updateCountFieldName, deleteFieldName, deleteSingleFieldName, restoreFieldName, restoreSingleFieldName, deleteCountFieldName } = names;
-		const softDeleteInfo = softDeleteOf?.(tableName);
-		const { aggregateType, groupByType, havingInput } = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
 		const insertArrGenerated = tableFeatures.insert ? generateInsertArray(db, tableName, schema[tableName], insertInput, createArrayFieldName, mutationTxCtx, policies) : void 0;
 		const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(db, tableName, schema[tableName], insertInput, createSingleFieldName, mutationTxCtx, policies) : void 0;
 		const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
@@ -6857,103 +6915,85 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			txCtx: mutationTxCtx
 		}) : void 0;
 		const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
-		const generatedMutations = [
-			[insertArrGenerated, {
-				operation: "insert",
-				single: false,
-				targetArg: "values"
-			}],
-			[insertSingleGenerated, {
-				operation: "insert",
-				single: true,
-				targetArg: "values"
-			}],
-			[upsertArrGenerated, {
-				operation: "upsert",
-				single: false,
-				targetArg: "values"
-			}],
-			[upsertSingleGenerated, {
-				operation: "upsert",
-				single: true,
-				targetArg: "values"
-			}],
-			[updateGenerated, {
-				operation: "update",
-				single: false,
-				targetArg: "where"
-			}],
-			[updateManyGenerated, {
-				operation: "updateMany",
-				single: false,
-				targetArg: "updates"
-			}],
-			[updateSingleGenerated, {
-				operation: "update",
-				single: true,
-				targetArg: "where"
-			}],
-			[deleteGenerated, {
-				operation: "delete",
-				single: false,
-				targetArg: "where",
-				...hardDeleteMeta
-			}],
-			[deleteSingleGenerated, {
-				operation: "delete",
-				single: true,
-				targetArg: "where",
-				...hardDeleteMeta
-			}],
-			[restoreGenerated, {
-				operation: "restore",
-				single: false,
-				targetArg: "where"
-			}],
-			[restoreSingleGenerated, {
-				operation: "restore",
-				single: true,
-				targetArg: "where"
-			}]
-		];
-		for (const [generated, meta] of generatedMutations) if (generated) defineRootField(mutations, "mutation", generated.name, {
+		const withMeta = (generated, meta) => ({
+			generated,
 			type: mutationReturnType,
-			args: generated.args,
-			resolve: generated.resolver,
-			extensions: { drizzle: drizzleMeta({
-				kind: "mutation",
-				...meta
-			}) }
-		});
-		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) 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."
+			meta
 		});
-		[
-			...tableFeatures.insert || onConflictInput ? [insertInput] : [],
-			...onConflictInput ? [onConflictInput] : [],
-			...tableFeatures.update ? [updateInput] : [],
-			...updateManyInput ? [updateManyInput] : [],
-			tableFilters,
-			tableOrder
-		].forEach((e) => {
-			inputs[e.name] = e;
-		});
-		outputs[selectSingleOutput.name] = selectSingleOutput;
-		if (aggregateType) outputs[aggregateType.name] = aggregateType;
-		if (groupByType && havingInput) {
-			outputs[groupByType.name] = groupByType;
-			inputs[havingInput.name] = havingInput;
-		}
-	}
+		return {
+			mutations: [
+				withMeta(insertArrGenerated, {
+					operation: "insert",
+					single: false,
+					targetArg: "values"
+				}),
+				withMeta(insertSingleGenerated, {
+					operation: "insert",
+					single: true,
+					targetArg: "values"
+				}),
+				withMeta(upsertArrGenerated, {
+					operation: "upsert",
+					single: false,
+					targetArg: "values"
+				}),
+				withMeta(upsertSingleGenerated, {
+					operation: "upsert",
+					single: true,
+					targetArg: "values"
+				}),
+				withMeta(updateGenerated, {
+					operation: "update",
+					single: false,
+					targetArg: "where"
+				}),
+				withMeta(updateManyGenerated, {
+					operation: "updateMany",
+					single: false,
+					targetArg: "updates"
+				}),
+				withMeta(updateSingleGenerated, {
+					operation: "update",
+					single: true,
+					targetArg: "where"
+				}),
+				withMeta(deleteGenerated, {
+					operation: "delete",
+					single: false,
+					targetArg: "where",
+					...hardDeleteMeta
+				}),
+				withMeta(deleteSingleGenerated, {
+					operation: "delete",
+					single: true,
+					targetArg: "where",
+					...hardDeleteMeta
+				}),
+				withMeta(restoreGenerated, {
+					operation: "restore",
+					single: false,
+					targetArg: "where"
+				}),
+				withMeta(restoreSingleGenerated, {
+					operation: "restore",
+					single: true,
+					targetArg: "where"
+				}),
+				{
+					generated: updateCountGenerated,
+					type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
+					description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+				},
+				{
+					generated: deleteCountGenerated,
+					type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
+					description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+				}
+			],
+			onConflictInput,
+			updateManyInput
+		};
+	});
 	return finalizeBuild(ctx);
 };
 //#endregion
@@ -6963,26 +7003,36 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 * result, so the generator call sites read exactly as they did when the functions were local.
 */
 const buildWriteResolvers = (primaryKeyPropNames) => {
-	const generateInsertArray = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies, resolveName) => {
-		const queryArgs = { values: { type: new graphql.GraphQLNonNull(new graphql.GraphQLList(new graphql.GraphQLNonNull(baseType))) } };
+	/**
+	* `insert<Table>` / `insert<Table>Single` — one generator for both shapes, the way
+	* {@link generateUpsert} handles its pair. `single` decides the argument type, whether the
+	* result is remapped as a row or a list, and whether an empty return is an error; the write
+	* itself is the same multi-row statement either way, with the single variant supplying a
+	* one-element list.
+	*/
+	const generateInsert = (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, baseType, fieldName, typeName, single, conflictDoNothing = false } = opts;
+		const queryArgs = { values: { type: single ? new graphql.GraphQLNonNull(baseType) : new graphql.GraphQLNonNull(new graphql.GraphQLList(new graphql.GraphQLNonNull(baseType))) } };
 		const pkNames = primaryKeyPropNames(table);
 		return writeResolver({
 			db,
 			tableName,
 			operation: "insert",
-			single: false,
+			single,
 			fieldName,
 			txCtx,
 			policies,
 			args: queryArgs,
 			run: async ({ executor, args, context, info, before, after }) => {
-				if (!args.values.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
+				const supplied = single ? [args.values] : args.values;
+				if (!supplied.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
 				await before();
-				const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+				const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
 				const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
-				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table), contextColumns, context);
+				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
 				const { columns, hasRelations, withParams } = mutationSelection(info, {
 					relationMap,
 					tables,
@@ -7012,65 +7062,12 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					context
 				}) : await runInsert(executor, input);
 				await after(result);
-				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
-				return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
-			}
-		});
-	};
-	const generateInsertSingle = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested, limits, policies, resolveName) => {
-		const queryArgs = { values: { type: new graphql.GraphQLNonNull(baseType) } };
-		const pkNames = primaryKeyPropNames(table);
-		return writeResolver({
-			db,
-			tableName,
-			operation: "insert",
-			single: true,
-			fieldName,
-			txCtx,
-			policies,
-			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
-				await before();
-				const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
-				const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
-				const contextColumns = policies?.contextValues?.(tableName);
-				const scope = policies?.scope?.(context);
-				const input = nestedEntry ? {} : applyContextValues(remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table), contextColumns, context);
-				const { columns, hasRelations, withParams } = mutationSelection(info, {
-					relationMap,
-					tables,
-					tableName,
-					typeName,
-					typeNameMapper,
-					resolveName,
-					table,
-					pkNames,
-					limits,
-					scope,
-					defaultOrderBy: policies?.defaultOrderBy
-				});
-				const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
-				const runInsert = async (target, values) => {
-					let query = target.insert(table).values(values).returning(returning);
-					if (conflictDoNothing) query = query.onConflictDoNothing();
-					return await query;
-				};
-				const result = nestedEntry ? await writeWithNestedOps({
-					executor,
-					runtime: nested,
-					tableName,
-					entries: [nestedEntry],
-					remapValues: (values) => applyContextValues(remapFromGraphQLSingleInput(values, table), contextColumns, context),
-					write: runInsert,
-					context
-				}) : await runInsert(executor, input);
-				await after(result);
-				if (!result[0]) {
+				if (single && !result[0]) {
 					if (!conflictDoNothing) throw drizzleError("The insert returned no row.", { code: "DRIZZLE_NO_ROW_RETURNED" });
 					return;
 				}
 				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
-				return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
+				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
 			}
 		});
 	};
@@ -7080,7 +7077,9 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 	*
 	* Shares the insert input: an upsert supplies a whole row, same as a create.
 	*/
-	const generateUpsert = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
+	const generateUpsert = (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, baseType, onConflictType, uniqueSets, fieldName, typeName, single } = opts;
 		const queryArgs = {
 			values: { type: single ? new graphql.GraphQLNonNull(baseType) : new graphql.GraphQLNonNull(new graphql.GraphQLList(new graphql.GraphQLNonNull(baseType))) },
 			onConflict: {
@@ -7157,7 +7156,9 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 			}
 		});
 	};
-	const generateUpdate = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
+	const generateUpdate = (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, setArgs, filterArgs, fieldName, typeName, single, requireWhere } = opts;
 		const queryArgs = {
 			set: { type: new graphql.GraphQLNonNull(setArgs) },
 			where: { type: single || requireWhere ? new graphql.GraphQLNonNull(filterArgs) : filterArgs }
@@ -7240,7 +7241,10 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 	* `DELETE` — emptying the trash, reclaiming a unique key. It reads at `INCLUDE`, since the
 	* rows it mostly exists to remove are the ones already marked; a `scope` still confines it.
 	*/
-	const generateDelete = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx, policies, restore = false, resolveName) => {
+	const generateDelete = (build, opts) => {
+		const { db, filterCtx, txCtx, policies, resolveName } = build;
+		const { tableName, table, filterArgs, fieldName, typeName, single, requireWhere, selectionCtx } = opts;
+		const restore = opts.restore ?? false;
 		const softDelete = policies?.softDelete?.(tableName);
 		const operation = restore ? "restore" : "delete";
 		const canHardDelete = !restore && softDelete?.hardDelete === true;
@@ -7287,8 +7291,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 		});
 	};
 	return {
-		generateInsertArray,
-		generateInsertSingle,
+		generateInsert,
 		generateUpsert,
 		generateUpdate,
 		generateDelete
@@ -7305,23 +7308,46 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 const createSchemaDataGenerator = (adapter) => {
 	const primaryKeyPropNames = adapter.primaryKeyPropNames;
 	const uniqueColumnSets = (table) => getUniqueColumnSets(table, adapter.getTableConfig);
-	const { generateInsertArray, generateInsertSingle, generateUpsert, generateUpdate, generateDelete } = buildWriteResolvers(primaryKeyPropNames);
-	const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder(adapter);
+	const { generateInsert, generateUpsert, generateUpdate, generateDelete } = buildWriteResolvers(primaryKeyPropNames);
+	const { prepareBuild, forEachTable, finalizeBuild } = createSchemaBuilder(adapter);
 	return (db, schema, relations, options) => {
-		const { prefixes, suffixes, conflictDoNothing, typeNameMapper, limits } = options;
+		const { prefixes, conflictDoNothing, typeNameMapper, limits } = options;
 		const ctx = prepareBuild(db, schema, relations, options);
-		const { tables, featureOf, eagerRelations, filterCtx, policies, softDeleteOf, namedRelations, cacheCtx, nestedRuntime, mutationTxCtx, gqlSchemaTypes, mutations, inputs, outputs } = ctx;
-		for (const [tableName, tableTypes] of Object.entries(gqlSchemaTypes)) {
-			const tableFeatures = featureOf(tableName);
-			const drizzleMeta = tableFieldExtensions(tableName, primaryKeyPropNames(schema[tableName]));
-			const { insertInput, updateInput, tableFilters, tableOrder } = tableTypes.inputs;
-			const { selectSingleOutput, singleTableItemOutput, arrTableItemOutput } = tableTypes.outputs;
-			const names = computeResolverFieldNames(tableName, typeNameMapper, prefixes, suffixes);
+		const { tables, eagerRelations, filterCtx, policies, namedRelations, cacheCtx, nestedRuntime, mutationTxCtx } = ctx;
+		const writeBuild = {
+			db,
+			tables,
+			relationMap: eagerRelations,
+			typeNameMapper,
+			filterCtx,
+			txCtx: mutationTxCtx,
+			nested: nestedRuntime,
+			limits,
+			policies,
+			resolveName: cacheCtx.typeName
+		};
+		forEachTable(ctx, ({ tableName, tableFeatures, names, types, softDeleteInfo }) => {
+			const { insertInput, updateInput, tableFilters } = types.inputs;
+			const { singleTableItemOutput, arrTableItemOutput } = types.outputs;
 			const { typeName, createArrayFieldName, createSingleFieldName, upsertArrayFieldName, upsertSingleFieldName, updateFieldName, updateManyFieldName, updateSingleFieldName, updateCountFieldName, deleteFieldName, deleteSingleFieldName, restoreFieldName, restoreSingleFieldName, deleteCountFieldName } = names;
-			const softDeleteInfo = softDeleteOf?.(tableName);
-			const { aggregateType, groupByType, havingInput } = addReadFields(ctx, tableName, names, tableTypes, drizzleMeta);
-			const insertArrGenerated = tableFeatures.insert ? generateInsertArray(db, tableName, schema[tableName], tables, eagerRelations, insertInput, createArrayFieldName, typeName, typeNameMapper, conflictDoNothing, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const insertSingleGenerated = tableFeatures.insert ? generateInsertSingle(db, tableName, schema[tableName], tables, eagerRelations, insertInput, createSingleFieldName, typeName, typeNameMapper, conflictDoNothing, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
+			const insertArrGenerated = tableFeatures.insert ? generateInsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				fieldName: createArrayFieldName,
+				typeName,
+				single: false,
+				conflictDoNothing
+			}) : void 0;
+			const insertSingleGenerated = tableFeatures.insert ? generateInsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				fieldName: createSingleFieldName,
+				typeName,
+				single: true,
+				conflictDoNothing
+			}) : void 0;
 			const uniqueSets = tableFeatures.upsert ? uniqueColumnSets(schema[tableName]) : [];
 			const onConflictInput = tableFeatures.upsert ? generateOnConflictInput({
 				table: schema[tableName],
@@ -7332,10 +7358,46 @@ const createSchemaDataGenerator = (adapter) => {
 				withTarget: true,
 				cacheCtx
 			}) : void 0;
-			const upsertArrGenerated = onConflictInput ? generateUpsert(db, tableName, schema[tableName], tables, eagerRelations, insertInput, onConflictInput, uniqueSets, upsertArrayFieldName, typeName, false, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const upsertSingleGenerated = onConflictInput ? generateUpsert(db, tableName, schema[tableName], tables, eagerRelations, insertInput, onConflictInput, uniqueSets, upsertSingleFieldName, typeName, true, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const updateGenerated = tableFeatures.update ? generateUpdate(db, tableName, schema[tableName], tables, eagerRelations, updateInput, tableFilters, updateFieldName, typeName, false, tableFeatures.requireWhere, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const updateSingleGenerated = tableFeatures.update ? generateUpdate(db, tableName, schema[tableName], tables, eagerRelations, updateInput, tableFilters, updateSingleFieldName, typeName, true, tableFeatures.requireWhere, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
+			const upsertArrGenerated = onConflictInput ? generateUpsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				onConflictType: onConflictInput,
+				uniqueSets,
+				fieldName: upsertArrayFieldName,
+				typeName,
+				single: false
+			}) : void 0;
+			const upsertSingleGenerated = onConflictInput ? generateUpsert(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				baseType: insertInput,
+				onConflictType: onConflictInput,
+				uniqueSets,
+				fieldName: upsertSingleFieldName,
+				typeName,
+				single: true
+			}) : void 0;
+			const updateGenerated = tableFeatures.update ? generateUpdate(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				setArgs: updateInput,
+				filterArgs: tableFilters,
+				fieldName: updateFieldName,
+				typeName,
+				single: false,
+				requireWhere: tableFeatures.requireWhere
+			}) : void 0;
+			const updateSingleGenerated = tableFeatures.update ? generateUpdate(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				setArgs: updateInput,
+				filterArgs: tableFilters,
+				fieldName: updateSingleFieldName,
+				typeName,
+				single: true,
+				requireWhere: tableFeatures.requireWhere
+			}) : void 0;
 			const updateManyInput = tableFeatures.update && tableFeatures.updateMany ? generateUpdateManyInput({
 				tableName,
 				typeName,
@@ -7344,27 +7406,73 @@ const createSchemaDataGenerator = (adapter) => {
 				tableFilters,
 				cacheCtx
 			}) : void 0;
-			const updateManyGenerated = updateManyInput ? adapter.generateUpdateMany(db, tableName, schema[tableName], tables, eagerRelations, updateManyInput, updateManyFieldName, typeName, typeNameMapper, filterCtx, mutationTxCtx, nestedRuntime, limits, policies, cacheCtx.typeName) : void 0;
-			const deleteGenerated = tableFeatures.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteFieldName, typeName, false, tableFeatures.requireWhere, filterCtx, {
+			const updateManyGenerated = updateManyInput ? adapter.generateUpdateMany(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, false, cacheCtx.typeName) : void 0;
-			const deleteSingleGenerated = tableFeatures.delete ? generateDelete(db, tableName, schema[tableName], tableFilters, deleteSingleFieldName, typeName, true, tableFeatures.requireWhere, filterCtx, {
+				table: schema[tableName],
+				updateManyInput,
+				fieldName: updateManyFieldName,
+				typeName
+			}) : void 0;
+			const deleteGenerated = tableFeatures.delete ? generateDelete(writeBuild, {
+				tableName,
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: deleteFieldName,
+				typeName,
+				single: false,
+				requireWhere: tableFeatures.requireWhere,
+				restore: false,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
+			const deleteSingleGenerated = tableFeatures.delete ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, false, cacheCtx.typeName) : void 0;
-			const restoreGenerated = softDeleteInfo ? generateDelete(db, tableName, schema[tableName], tableFilters, restoreFieldName, typeName, false, tableFeatures.requireWhere, filterCtx, {
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: deleteSingleFieldName,
+				typeName,
+				single: true,
+				requireWhere: tableFeatures.requireWhere,
+				restore: false,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
+			const restoreGenerated = softDeleteInfo ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, true, cacheCtx.typeName) : void 0;
-			const restoreSingleGenerated = softDeleteInfo ? generateDelete(db, tableName, schema[tableName], tableFilters, restoreSingleFieldName, typeName, true, tableFeatures.requireWhere, filterCtx, {
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: restoreFieldName,
+				typeName,
+				single: false,
+				requireWhere: tableFeatures.requireWhere,
+				restore: true,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
+			const restoreSingleGenerated = softDeleteInfo ? generateDelete(writeBuild, {
 				tableName,
-				relationMap: namedRelations,
-				tables
-			}, mutationTxCtx, policies, true, cacheCtx.typeName) : void 0;
+				table: schema[tableName],
+				filterArgs: tableFilters,
+				fieldName: restoreSingleFieldName,
+				typeName,
+				single: true,
+				requireWhere: tableFeatures.requireWhere,
+				restore: true,
+				selectionCtx: {
+					tableName,
+					relationMap: namedRelations,
+					tables
+				}
+			}) : void 0;
 			const updateCountGenerated = tableFeatures.update && tableFeatures.countMutations ? generateWriteCount({
 				db,
 				tableName,
@@ -7389,160 +7497,126 @@ const createSchemaDataGenerator = (adapter) => {
 				filterCtx,
 				txCtx: mutationTxCtx
 			}) : void 0;
-			if (insertArrGenerated) defineRootField(mutations, "mutation", insertArrGenerated.name, {
-				type: arrTableItemOutput,
-				args: insertArrGenerated.args,
-				resolve: insertArrGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "insert",
-					single: false,
-					targetArg: "values"
-				}) }
-			});
-			if (insertSingleGenerated) defineRootField(mutations, "mutation", insertSingleGenerated.name, {
-				type: conflictDoNothing ? singleTableItemOutput : new graphql.GraphQLNonNull(singleTableItemOutput),
-				args: insertSingleGenerated.args,
-				resolve: insertSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "insert",
-					single: true,
-					targetArg: "values"
-				}) }
-			});
-			if (upsertArrGenerated) defineRootField(mutations, "mutation", upsertArrGenerated.name, {
-				type: arrTableItemOutput,
-				args: upsertArrGenerated.args,
-				resolve: upsertArrGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "upsert",
-					single: false,
-					targetArg: "values"
-				}) }
-			});
-			if (upsertSingleGenerated) defineRootField(mutations, "mutation", upsertSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: upsertSingleGenerated.args,
-				resolve: upsertSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "upsert",
-					single: true,
-					targetArg: "values"
-				}) }
-			});
-			if (updateGenerated) defineRootField(mutations, "mutation", updateGenerated.name, {
-				type: arrTableItemOutput,
-				args: updateGenerated.args,
-				resolve: updateGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "update",
-					single: false,
-					targetArg: "where"
-				}) }
-			});
-			if (updateManyGenerated) defineRootField(mutations, "mutation", updateManyGenerated.name, {
-				type: new graphql.GraphQLNonNull(new graphql.GraphQLList(singleTableItemOutput)),
-				args: updateManyGenerated.args,
-				resolve: updateManyGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "updateMany",
-					single: false,
-					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) defineRootField(mutations, "mutation", updateSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: updateSingleGenerated.args,
-				resolve: updateSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "update",
-					single: true,
-					targetArg: "where"
-				}) }
-			});
-			if (deleteGenerated) defineRootField(mutations, "mutation", deleteGenerated.name, {
-				type: arrTableItemOutput,
-				args: deleteGenerated.args,
-				resolve: deleteGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "delete",
-					single: false,
-					targetArg: "where",
-					...softDeleteInfo?.hardDelete ? { hardDelete: true } : {}
-				}) }
-			});
-			if (deleteSingleGenerated) defineRootField(mutations, "mutation", deleteSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: deleteSingleGenerated.args,
-				resolve: deleteSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "delete",
-					single: true,
-					targetArg: "where",
-					...softDeleteInfo?.hardDelete ? { hardDelete: true } : {}
-				}) }
-			});
-			if (restoreGenerated) defineRootField(mutations, "mutation", restoreGenerated.name, {
-				type: arrTableItemOutput,
-				args: restoreGenerated.args,
-				resolve: restoreGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "restore",
-					single: false,
-					targetArg: "where"
-				}) }
-			});
-			if (restoreSingleGenerated) defineRootField(mutations, "mutation", restoreSingleGenerated.name, {
-				type: singleTableItemOutput,
-				args: restoreSingleGenerated.args,
-				resolve: restoreSingleGenerated.resolver,
-				extensions: { drizzle: drizzleMeta({
-					kind: "mutation",
-					operation: "restore",
-					single: true,
-					targetArg: "where"
-				}) }
-			});
-			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) 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] : [],
-				...tableFeatures.update ? [updateInput] : [],
-				...updateManyInput ? [updateManyInput] : [],
-				tableFilters,
-				tableOrder
-			].forEach((e) => {
-				inputs[e.name] = e;
-			});
-			outputs[selectSingleOutput.name] = selectSingleOutput;
-			outputs[singleTableItemOutput.name] = singleTableItemOutput;
-			if (aggregateType) outputs[aggregateType.name] = aggregateType;
-			if (groupByType && havingInput) {
-				outputs[groupByType.name] = groupByType;
-				inputs[havingInput.name] = havingInput;
-			}
-		}
+			const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
+			return {
+				mutations: [
+					{
+						generated: insertArrGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "insert",
+							single: false,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: insertSingleGenerated,
+						type: conflictDoNothing ? singleTableItemOutput : new graphql.GraphQLNonNull(singleTableItemOutput),
+						meta: {
+							operation: "insert",
+							single: true,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: upsertArrGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "upsert",
+							single: false,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: upsertSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "upsert",
+							single: true,
+							targetArg: "values"
+						}
+					},
+					{
+						generated: updateGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "update",
+							single: false,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: updateManyGenerated,
+						type: new graphql.GraphQLNonNull(new graphql.GraphQLList(singleTableItemOutput)),
+						meta: {
+							operation: "updateMany",
+							single: false,
+							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."
+					},
+					{
+						generated: updateSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "update",
+							single: true,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: deleteGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "delete",
+							single: false,
+							targetArg: "where",
+							...hardDeleteMeta
+						}
+					},
+					{
+						generated: deleteSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "delete",
+							single: true,
+							targetArg: "where",
+							...hardDeleteMeta
+						}
+					},
+					{
+						generated: restoreGenerated,
+						type: arrTableItemOutput,
+						meta: {
+							operation: "restore",
+							single: false,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: restoreSingleGenerated,
+						type: singleTableItemOutput,
+						meta: {
+							operation: "restore",
+							single: true,
+							targetArg: "where"
+						}
+					},
+					{
+						generated: updateCountGenerated,
+						type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
+						description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
+					},
+					{
+						generated: deleteCountGenerated,
+						type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
+						description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+					}
+				],
+				onConflictInput,
+				updateManyInput
+			};
+		});
 		return finalizeBuild(ctx);
 	};
 };
@@ -7584,7 +7658,9 @@ const runUpdateManyBatch = ({ executor, entries, table, returning, nested, table
 * @param runBatch how the entries execute; defaults to {@link runUpdateManyBatch}
 */
 const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateManyBatch) => {
-	return (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName) => {
+	return (build, opts) => {
+		const { db, tables, relationMap, typeNameMapper, filterCtx, txCtx, nested, limits, policies, resolveName } = build;
+		const { tableName, table, updateManyInput, fieldName, typeName } = opts;
 		const queryArgs = { updates: { type: new graphql.GraphQLNonNull(new graphql.GraphQLList(new graphql.GraphQLNonNull(updateManyInput))) } };
 		const pkNames = primaryKeyPropNames(table);
 		return writeResolver({
@@ -7627,11 +7703,12 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					};
 				});
 				const anyNested = entries.some((entry) => entry.ops);
+				const returning = anyNested ? nested.withJoinColumns(tableName, mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))), { ...columns }, table) : columns;
 				const perEntry = await runBatch({
 					executor,
 					entries,
 					table,
-					returning: anyNested ? nested.withJoinColumns(tableName, mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))), { ...columns }, table) : columns,
+					returning,
 					anyNested,
 					nested,
 					tableName,