@vantreeseba/drizzle-graphql 13.0.0 → 13.1.1

package/dist/index.cjs

@@ -189,6 +189,14 @@ const GraphQLDecimalString = new graphql.GraphQLScalarType({
 const uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 const capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 /**
+* `inProgress` / `in-progress` / `in progress` / `InProgress` → `IN_PROGRESS`; `HTTPError` →
+* `HTTP_ERROR`. Words are split at non-alphanumeric runs and at lower→upper and
+* acronym→word boundaries, then upper-cased and joined with `_`.
+*
+* The preset behind `enumValueNameMapper: 'constant'`.
+*/
+const constantCase = (input) => input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.toUpperCase()).join("_");
+/**
 * The `typeNameMapper` preset behind `typeNameMapper: 'singularize'`.
 *
 * Derives the singular and plural forms of a table key with the library's own `pluralize`,
@@ -209,6 +217,8 @@ const singularizeMapper = (tableName) => ({
 //#endregion
 //#region src/util/type-converter/index.ts
 const allowedNameChars = /^[a-zA-Z0-9_]+$/;
+/** A GraphQL `Name` that is also allowed as an enum value — the spec reserves the three literals. */
+const validEnumValueName = (name) => /^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) && name !== "true" && name !== "false" && name !== "null";
 /**
 * The enum type a column was declared with, when it is a *named* one — `pgEnum('status', …)`
 * shared by however many tables reference it. An inline value list (`text({ enum: [...] })`,
@@ -229,20 +239,35 @@ const pascalize = (input) => input.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((p
 */
 const enumValuesKey = (values) => JSON.stringify(values);
 /**
+* Identity of the GraphQL names those values were given. Kept apart from {@link enumValuesKey}
+* because `enumValueNameMapper` sees the column, so two columns reaching one type can name its
+* values differently — and only one set of names can win.
+*/
+const enumValueNamesKey = (names) => JSON.stringify(names);
+/**
 * Every GraphQL enum name this build has handed out. Two columns that resolve to the same
 * name share one type — that is how the columns of one `pgEnum` end up on a single type —
 * so the values are kept alongside it to tell a genuine collision from a re-use.
 */
 let enumNamesInUse = /* @__PURE__ */ new Map();
 let enumNameMapper;
+let enumValueNameMapper;
+/** The value-name presets, by the string a config passes for them. */
+const enumValueNamePresets = { constant: ({ value }) => constantCase(value) };
 /**
 * Resets the enum registry for a fresh schema build and installs that build's
-* `enumNameMapper`. Called once per `generateSchemaData`, alongside
+* `enumNameMapper` and `enumValueNameMapper`. Called once per `generateSchemaData`, alongside
 * {@link registerScalarOverrides} — without the reset a second build would reuse the first
 * build's enum types, and so its naming decisions.
 */
 const registerEnumConfig = (config) => {
 	enumNameMapper = config.enumNameMapper;
+	const valueMapper = config.enumValueNameMapper;
+	if (typeof valueMapper === "string") {
+		const preset = enumValueNamePresets[valueMapper];
+		if (!preset) throw new Error(`Drizzle-GraphQL Error: Unknown enumValueNameMapper preset '${valueMapper}'. The only preset is 'constant'; pass a function for anything else.`);
+		enumValueNameMapper = preset;
+	} else enumValueNameMapper = valueMapper;
 	enumNamesInUse = /* @__PURE__ */ new Map();
 };
 /**
@@ -271,22 +296,50 @@ const generateEnumCached = (column, columnName, tableName) => {
 		columnName,
 		values
 	}) ?? (declared ? `${pascalize(declared.enumName)}Enum` : `${capitalize(tableName)}${capitalize(columnName)}Enum`);
+	const valueNames = values.map((value, index) => {
+		const mapped = enumValueNameMapper?.({
+			enumName: declared?.enumName,
+			schema: declared?.schema,
+			tableName,
+			columnName,
+			values,
+			value,
+			index,
+			typeName: name
+		});
+		if (mapped === void 0) return allowedNameChars.test(value) ? value : `Option${index}`;
+		if (!validEnumValueName(mapped)) throw new Error(`Drizzle-GraphQL Error: config.enumValueNameMapper named value '${value}' of enum '${name}' (on '${tableName}.${columnName}') '${mapped}', which is not a valid GraphQL enum value name. A name must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ and not be true, false or null.`);
+		return mapped;
+	});
+	const seen = /* @__PURE__ */ new Map();
+	values.forEach((value, index) => {
+		const valueName = valueNames[index];
+		const earlier = seen.get(valueName);
+		if (earlier !== void 0) throw new Error(`Drizzle-GraphQL Error: Values '${earlier}' and '${value}' of enum '${name}' (on '${tableName}.${columnName}') both map to the GraphQL value name '${valueName}'. Give one of them a different name via config.enumValueNameMapper.`);
+		seen.set(valueName, value);
+	});
 	const valuesKey = enumValuesKey(values);
+	const namesKey = enumValueNamesKey(valueNames);
 	const claimed = enumNamesInUse.get(name);
 	if (claimed) {
 		if (claimed.valuesKey !== valuesKey) throw new Error(`Drizzle-GraphQL Error: Two different enums both map to the GraphQL type name '${name}' (most recently '${tableName}.${columnName}'). Give one of them a different name via config.enumNameMapper.`);
+		if (claimed.namesKey !== namesKey) {
+			const before = claimed.type.getValues().map((v) => v.name).join(", ");
+			throw new Error(`Drizzle-GraphQL Error: Columns sharing the GraphQL enum '${name}' name its values differently ('${tableName}.${columnName}' gives ${valueNames.join(", ")}; an earlier column gave ${before}). config.enumValueNameMapper must name a shared enum's values the same way for every column, or config.enumNameMapper must give the columns separate types.`);
+		}
 		return claimed.type;
 	}
 	const gqlEnum = new graphql.GraphQLEnumType({
 		name,
-		values: Object.fromEntries(values.map((e, index) => [allowedNameChars.test(e) ? e : `Option${index}`, {
+		values: Object.fromEntries(values.map((e, index) => [valueNames[index], {
 			value: e,
 			description: `Value: ${e}`
 		}]))
 	});
 	enumNamesInUse.set(name, {
 		type: gqlEnum,
-		valuesKey
+		valuesKey,
+		namesKey
 	});
 	return gqlEnum;
 };
@@ -1041,6 +1094,7 @@ const remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) =
 	return queryOutput;
 };
 const remapFromGraphQLCore = (value, column, columnName) => {
+	if (value === null) return null;
 	if (getColumnScalarOverride(column, true)) {
 		if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === null) return Object.assign({}, value);
 		return value;
@@ -3694,6 +3748,145 @@ const runMutation = async (db, context, info, txCtx, body, forceTx) => {
 	return runOnSharedTx(state, body);
 };
 //#endregion
+//#region src/util/builders/common/write-hooks.ts
+/**
+* Normalizes the two registration shapes: a bare function is the `after` hook — the position
+* that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
+* names them explicitly.
+*/
+const normalizeWriteHooks = (hooks, tableColumns, where) => {
+	if (!hooks) return;
+	if (typeof hooks === "function") return { after: hooks };
+	const resolved = {
+		before: hooks.before,
+		after: hooks.after
+	};
+	if (hooks.columns !== void 0) resolved.columns = resolveHookColumns(hooks.columns, !!hooks.after, tableColumns, where);
+	return resolved.before || resolved.after ? resolved : void 0;
+};
+/**
+* Resolves a hook's `columns` against the table it runs on. `where` names the registration
+* (`config.onWrite.posts`) and, for a top-level one, the table, so the error says which.
+*/
+const resolveHookColumns = (spec, hasAfter, tableColumns, where) => {
+	if (!hasAfter) throw new Error(`Drizzle-GraphQL Error: ${where}.columns only applies to an 'after' hook, and none is registered.`);
+	if (spec === "all") return { ...tableColumns };
+	if (!Array.isArray(spec)) throw new Error(`Drizzle-GraphQL Error: ${where}.columns must be an array of column names or 'all'.`);
+	const resolved = {};
+	for (const name of spec) {
+		const column = typeof name === "string" && Object.keys(tableColumns).includes(name) ? tableColumns[name] : void 0;
+		if (!column) throw new Error(`Drizzle-GraphQL Error: ${where}.columns names '${String(name)}', which is not a column of that table.`);
+		resolved[name] = column;
+	}
+	return resolved;
+};
+/**
+* Adds a hook's `columns` to a RETURNING column map, and reports which keys it added — the
+* ones the client never asked for, which have to come back off before the rows are mapped.
+* Returns the map untouched, and no keys, when the hook named none or the selection already
+* covers them.
+*/
+const withHookColumns = (hooks, columns) => {
+	const hookColumns = hooks?.columns;
+	if (!hookColumns) return {
+		returning: columns,
+		added: void 0
+	};
+	const selected = new Set(Object.keys(columns));
+	const added = Object.keys(hookColumns).filter((key) => !selected.has(key));
+	if (!added.length) return {
+		returning: columns,
+		added: void 0
+	};
+	const returning = { ...columns };
+	for (const key of added) returning[key] = hookColumns[key];
+	return {
+		returning,
+		added
+	};
+};
+/**
+* The rows with the hook-only keys taken off, as fresh objects: the hook was handed the
+* originals and may still hold them, so they are not mutated under it.
+*/
+const omitHookColumns = (rows, added) => {
+	if (!added) return rows;
+	return rows.map((row) => {
+		const copy = { ...row };
+		for (const key of added) delete copy[key];
+		return copy;
+	});
+};
+/**
+* Invokes one position of a field's hooks. Returns `undefined` rather than a resolved promise
+* when nothing is registered, so the awaiting call site costs nothing on an unhooked build.
+*/
+const runWriteHook = (hooks, position, payload) => {
+	const hook = position === "before" ? hooks?.before : hooks?.after;
+	if (!hook) return;
+	return Promise.resolve(hook({
+		...payload,
+		position,
+		rows: payload.rows ?? []
+	}));
+};
+//#endregion
+//#region src/util/builders/common/write-scaffold.ts
+/**
+* Wraps one mutation body in the scaffolding above and returns the field it becomes.
+*
+* A field carrying a hook is forced into a transaction even when it would have run straight
+* on `db`: a hook exists to write atomically with the mutation, and one that ran outside the
+* transaction could not roll anything back.
+*/
+const writeResolver = ({ db, tableName, operation, single, fieldName, args: queryArgs, txCtx, policies, run }) => {
+	const hooks = policies?.onWrite?.(tableName, operation);
+	const errorCtx = {
+		table: tableName,
+		operation,
+		field: fieldName
+	};
+	return {
+		name: fieldName,
+		resolver: async (_source, args, context, info) => {
+			try {
+				return await runMutation(db, context, info, txCtx, (executor) => {
+					const payload = {
+						table: tableName,
+						operation,
+						single,
+						args,
+						context,
+						info,
+						tx: executor
+					};
+					let added;
+					return run({
+						executor,
+						args,
+						context,
+						info,
+						before: () => runWriteHook(hooks, "before", payload),
+						after: (rows) => runWriteHook(hooks, "after", {
+							...payload,
+							rows: rows ?? []
+						}),
+						returning: (columns) => {
+							const withHook = withHookColumns(hooks, columns);
+							added = withHook.added;
+							return withHook.returning;
+						},
+						output: (rows) => omitHookColumns(rows, added)
+					});
+				}, !!hooks);
+			} catch (e) {
+				throw withErrorContext(toGraphQLError(e), errorCtx);
+			}
+		},
+		args: queryArgs
+	};
+};
+//#endregion
 //#region src/util/builders/common/mutation-helpers.ts
 /**
 * The `hard` argument on the delete mutations of a soft-deleting table that opted into
@@ -3837,54 +4030,79 @@ const assertSingleMatch = async (executor, table, filters) => {
 * The plural `update` and `delete` always `RETURNING *`, which is the wrong shape for
 * "archive everything older than a year": the caller pays to ship rows it does not want, and
 * on a large match that cost is the whole mutation. These return `Int!` instead — how many
-* rows the write touched, as the driver reported it, with no RETURNING clause at all.
+* rows the write touched.
 *
-* Dialect-independent: drizzle's update/delete builders take the same calls everywhere, and
-* the drivers' disagreement about how to spell the row count is handled by
-* {@link rowsAffected}.
-*/
-const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested }) => {
+* Leaving the payload off changes nothing else: the write obeys every rule of the plural
+* mutation it mirrors, through the same {@link writeResolver} scaffolding.
+*
+* - `scope` (and the soft-delete marker) is ANDed into the `where`, so only rows the plural
+*   write could reach are counted and written.
+* - On a soft-deleting table the delete is the marking `UPDATE`, not a `DELETE`, and rows that
+*   are already marked are not matched; the update skips marked rows too. `hard: true` exists
+*   exactly where the plural delete takes it.
+* - Context-derived columns are stripped from the update's `set`, as the plural update does.
+* - `onWrite` hooks run `before` and `after`, inside a transaction. The `after` hook is handed
+*   rows, so a table with one pays for a `RETURNING` — of the columns the hook names in
+*   `columns`, or of the primary key when it names none (the whole row on a table without a
+*   key) — and the count is the number of rows returned. Every other write, and every write on
+*   MySQL (no `RETURNING`; its hooks see `rows: []` as on every MySQL mutation), skips the
+*   `RETURNING` and reads the count off the driver's result via {@link rowsAffected}.
+*/
+const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested, policies, pkNames = [], returnsRows }) => {
+	const softDelete = kind === "delete" ? policies?.softDelete?.(tableName) : void 0;
+	const canHardDelete = softDelete?.hardDelete === true;
 	const queryArgs = {
 		...setArgs ? { set: { type: new graphql.GraphQLNonNull(setArgs) } } : {},
-		where: { type: requireWhere ? new graphql.GraphQLNonNull(filterArgs) : filterArgs }
+		where: { type: requireWhere ? new graphql.GraphQLNonNull(filterArgs) : filterArgs },
+		...canHardDelete ? { hard: hardDeleteArg } : {}
 	};
-	const errorCtx = {
-		table: tableName,
+	const readsRows = returnsRows && !!policies?.onWrite?.(tableName, kind)?.after;
+	const allColumns = (0, drizzle_orm.getColumns)(table);
+	const keyColumns = pkNames.length ? Object.fromEntries(pkNames.map((name) => [name, allColumns[name]])) : allColumns;
+	return writeResolver({
+		db,
+		tableName,
 		operation: kind,
-		field: fieldName
-	};
-	return {
-		name: fieldName,
-		resolver: async (_source, args, context, info) => {
-			try {
-				return await runMutation(db, context, info, txCtx, async (executor) => {
-					const { where, set } = args;
-					const filters = scopedWhere({
-						scope: void 0,
-						tableName,
-						table,
-						where,
-						relationCtx: relationFilterCtx(filterCtx, tableName),
-						required: requireWhere
-					});
-					let query;
-					if (kind === "delete") query = executor.delete(table);
-					else {
-						const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-						if (entry && nested.hasOps(entry.ops)) throw drizzleError("This mutation does not support nested writes — use the one that returns the rows instead.", { code: "DRIZZLE_NESTED_WRITES_UNSUPPORTED" });
-						const values = remapUpdateInput(entry ? entry.columns : set, table, tableName);
-						if (!Object.keys(values).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-						query = executor.update(table).set(values);
-					}
-					if (filters) query = query.where(filters);
-					return rowsAffected(await query);
-				});
-			} catch (e) {
-				throw withErrorContext(toGraphQLError(e), errorCtx);
+		single: false,
+		fieldName,
+		txCtx,
+		policies,
+		args: queryArgs,
+		run: async ({ executor, args, context, before, after, returning }) => {
+			const { where, set } = args;
+			const hard = canHardDelete && args.hard === true;
+			const scope = policies?.scope?.(context);
+			await before();
+			let query;
+			if (kind === "delete") query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: softDelete.writeDeleted() }) : executor.delete(table);
+			else {
+				const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+				if (entry && nested.hasOps(entry.ops)) throw drizzleError("This mutation does not support nested writes — use the one that returns the rows instead.", { code: "DRIZZLE_NESTED_WRITES_UNSUPPORTED" });
+				const values = stripContextValues(remapUpdateInput(entry ? entry.columns : set, table, tableName), policies?.contextValues?.(tableName));
+				if (!Object.keys(values).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
+				query = executor.update(table).set(values);
 			}
-		},
-		args: queryArgs
-	};
+			const filters = scopedWhere({
+				scope,
+				tableName,
+				table,
+				where,
+				relationCtx: relationFilterCtx(filterCtx, tableName),
+				required: requireWhere,
+				deleted: hard ? "INCLUDE" : void 0
+			});
+			if (filters) query = query.where(filters);
+			if (!readsRows) {
+				const result = await query;
+				await after();
+				return rowsAffected(result);
+			}
+			const named = returning({});
+			const rows = await query.returning(Object.keys(named).length ? named : keyColumns);
+			await after(rows);
+			return rows.length;
+		}
+	});
 };
 //#endregion
 //#region src/util/batch-loader/index.ts
@@ -4822,84 +5040,6 @@ const generateTableTypes = (tableName, tables, relationMap, withReturning, relat
 	};
 };
 //#endregion
-//#region src/util/builders/common/write-hooks.ts
-/**
-* Normalizes the two registration shapes: a bare function is the `after` hook — the position
-* that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
-* names them explicitly.
-*/
-const normalizeWriteHooks = (hooks) => {
-	if (!hooks) return;
-	if (typeof hooks === "function") return { after: hooks };
-	const resolved = {
-		before: hooks.before,
-		after: hooks.after
-	};
-	return resolved.before || resolved.after ? resolved : void 0;
-};
-/**
-* Invokes one position of a field's hooks. Returns `undefined` rather than a resolved promise
-* when nothing is registered, so the awaiting call site costs nothing on an unhooked build.
-*/
-const runWriteHook = (hooks, position, payload) => {
-	const hook = position === "before" ? hooks?.before : hooks?.after;
-	if (!hook) return;
-	return Promise.resolve(hook({
-		...payload,
-		position,
-		rows: payload.rows ?? []
-	}));
-};
-//#endregion
-//#region src/util/builders/common/write-scaffold.ts
-/**
-* Wraps one mutation body in the scaffolding above and returns the field it becomes.
-*
-* A field carrying a hook is forced into a transaction even when it would have run straight
-* on `db`: a hook exists to write atomically with the mutation, and one that ran outside the
-* transaction could not roll anything back.
-*/
-const writeResolver = ({ db, tableName, operation, single, fieldName, args: queryArgs, txCtx, policies, run }) => {
-	const hooks = policies?.onWrite?.(tableName, operation);
-	const errorCtx = {
-		table: tableName,
-		operation,
-		field: fieldName
-	};
-	return {
-		name: fieldName,
-		resolver: async (_source, args, context, info) => {
-			try {
-				return await runMutation(db, context, info, txCtx, (executor) => {
-					const payload = {
-						table: tableName,
-						operation,
-						single,
-						args,
-						context,
-						info,
-						tx: executor
-					};
-					return run({
-						executor,
-						args,
-						context,
-						info,
-						before: () => runWriteHook(hooks, "before", payload),
-						after: (rows) => runWriteHook(hooks, "after", {
-							...payload,
-							rows: rows ?? []
-						})
-					});
-				}, !!hooks);
-			} catch (e) {
-				throw withErrorContext(toGraphQLError(e), errorCtx);
-			}
-		},
-		args: queryArgs
-	};
-};
-//#endregion
 //#region src/util/features.ts
 /**
 * What a table generates when the config says nothing. Everything is on except the opt-in
@@ -5063,19 +5203,18 @@ const resolveBuildConfig = (config, schema) => {
 	}
 	const onWriteConfig = config?.onWrite;
 	const writeHooks = /* @__PURE__ */ new Map();
-	let globalWriteHooks;
 	if (onWriteConfig) {
-		if (typeof onWriteConfig === "function" || typeof onWriteConfig.before === "function" || typeof onWriteConfig.after === "function") globalWriteHooks = normalizeWriteHooks(onWriteConfig);
+		if (typeof onWriteConfig === "function" || typeof onWriteConfig.before === "function" || typeof onWriteConfig.after === "function") for (const tableName of featureTables) writeHooks.set(tableName, normalizeWriteHooks(onWriteConfig, (0, drizzle_orm.getColumns)(schema[tableName]), `config.onWrite (on table '${tableName}')`));
 		else {
 			const tableNames = new Set(tableKeys);
 			for (const [tableName, hooks] of Object.entries(onWriteConfig)) {
 				if (!tableNames.has(tableName)) throw new Error(`Drizzle-GraphQL Error: config.onWrite names '${tableName}', which is not a table in the Drizzle schema.`);
 				if (typeof hooks !== "function" && typeof hooks !== "object") throw new Error(`Drizzle-GraphQL Error: config.onWrite.${tableName} must be a function or an object with 'before' and/or 'after'.`);
-				writeHooks.set(tableName, normalizeWriteHooks(hooks));
+				writeHooks.set(tableName, normalizeWriteHooks(hooks, (0, drizzle_orm.getColumns)(schema[tableName]), `config.onWrite.${tableName}`));
 			}
 		}
 	}
-	const onWrite = globalWriteHooks || writeHooks.size ? (tableName) => globalWriteHooks ?? writeHooks.get(tableName) : void 0;
+	const onWrite = writeHooks.size ? (tableName) => writeHooks.get(tableName) : void 0;
 	const policies = scopeConfig || contextValuesConfig || softDeleteInfos.size || onWrite || defaultOrderBy ? {
 		scope: scopeConfig ? (tableName) => scopeConfig[tableName] : void 0,
 		contextValues: contextValuesConfig ? (tableName) => contextValuesConfig[tableName] : void 0,
@@ -5141,6 +5280,7 @@ const resolveBuildConfig = (config, schema) => {
 		scalars: config?.scalars,
 		mapColumnType: config?.mapColumnType,
 		enumNameMapper: config?.enumNameMapper,
+		enumValueNameMapper: config?.enumValueNameMapper,
 		transactions,
 		limits,
 		policies,
@@ -6901,7 +7041,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			fieldName: updateCountFieldName,
 			requireWhere: tableFeatures.requireWhere,
 			filterCtx,
-			txCtx: mutationTxCtx
+			txCtx: mutationTxCtx,
+			policies,
+			returnsRows: false
 		}) : void 0;
 		const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 			db,
@@ -6912,7 +7054,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			fieldName: deleteCountFieldName,
 			requireWhere: tableFeatures.requireWhere,
 			filterCtx,
-			txCtx: mutationTxCtx
+			txCtx: mutationTxCtx,
+			policies,
+			returnsRows: false
 		}) : void 0;
 		const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 		const withMeta = (generated, meta) => ({
@@ -6982,12 +7126,25 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 				{
 					generated: updateCountGenerated,
 					type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
+					meta: {
+						operation: "update",
+						single: false,
+						targetArg: "where",
+						count: true
+					},
 					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."
+					meta: {
+						operation: "delete",
+						single: false,
+						targetArg: "where",
+						count: true,
+						...hardDeleteMeta
+					},
+					description: "How many rows the delete removed — or, on a soft-deleting table, marked deleted. The rows themselves are not read back, which is the point of this mutation."
 				}
 			],
 			onConflictInput,
@@ -7024,7 +7181,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 			txCtx,
 			policies,
 			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
+			run: async ({ executor, args, context, info, before, after, returning: withHookReturning, output }) => {
 				const supplied = single ? [args.values] : args.values;
 				if (!supplied.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
 				await before();
@@ -7046,13 +7203,13 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
 				});
-				const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+				const returning = withHookReturning(nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...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 = nestedEntries ? await writeWithNestedOps({
+				const written = nestedEntries ? await writeWithNestedOps({
 					executor,
 					runtime: nested,
 					tableName,
@@ -7061,7 +7218,8 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					write: (tx, values) => runInsert(tx, [values]),
 					context
 				}) : await runInsert(executor, input);
-				await after(result);
+				await after(written);
+				const result = output(written);
 				if (single && !result[0]) {
 					if (!conflictDoNothing) throw drizzleError("The insert returned no row.", { code: "DRIZZLE_NO_ROW_RETURNED" });
 					return;
@@ -7097,7 +7255,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 			txCtx,
 			policies,
 			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
+			run: async ({ executor, args, context, info, before, after, returning: withHookReturning, output }) => {
 				const supplied = single ? [args.values] : args.values;
 				if (!supplied.length) throw drizzleError("No values were provided!", { code: "DRIZZLE_NO_VALUES" });
 				await before();
@@ -7119,7 +7277,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					scope,
 					defaultOrderBy: policies?.defaultOrderBy
 				});
-				const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+				const returning = withHookReturning(nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns);
 				const runUpsert = async (target, values) => {
 					const plan = resolveConflictPlan({
 						table,
@@ -7140,7 +7298,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					});
 					return await query;
 				};
-				const result = nestedEntries ? await writeWithNestedOps({
+				const written = nestedEntries ? await writeWithNestedOps({
 					executor,
 					runtime: nested,
 					tableName,
@@ -7149,7 +7307,8 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					write: (tx, values) => runUpsert(tx, [values]),
 					context
 				}) : await runUpsert(executor, input);
-				await after(result);
+				await after(written);
+				const result = output(written);
 				if (single && !result[0]) return;
 				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
 				return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
@@ -7173,7 +7332,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 			txCtx,
 			policies,
 			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
+			run: async ({ executor, args, context, info, before, after, returning: withHookReturning, output }) => {
 				const { where, set } = args;
 				const scope = policies?.scope?.(context);
 				await before();
@@ -7204,14 +7363,14 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					required: single || requireWhere
 				});
 				if (single) await assertSingleMatch(executor, table, filters);
-				const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
+				const returning = withHookReturning(nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns);
 				const runUpdate = async (target, values) => {
 					const writes = Object.keys(values).length > 0;
 					let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
 					if (filters) query = query.where(filters);
 					return await (writes ? query.returning(returning) : query);
 				};
-				const result = nestedOps ? await updateWithNestedOps({
+				const written = nestedOps ? await updateWithNestedOps({
 					executor,
 					runtime: nested,
 					tableName,
@@ -7221,7 +7380,8 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					write: runUpdate,
 					context
 				}) : await runUpdate(executor, input);
-				await after(result);
+				await after(written);
+				const result = output(written);
 				if (single && result.length > 1) throw drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
 				if (single && !result[0]) return;
 				const enriched = await withEagerRelations(executor, tableName, result, pkNames, withParams, hasRelations);
@@ -7261,7 +7421,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 			txCtx,
 			policies,
 			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
+			run: async ({ executor, args, context, info, before, after, returning: withHookReturning, output }) => {
 				const { where } = args;
 				const hard = canHardDelete && args.hard === true;
 				const scope = policies?.scope?.(context);
@@ -7281,9 +7441,10 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				if (single) await assertSingleMatch(executor, table, filters);
 				let query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: restore ? softDelete.writeRestored : softDelete.writeDeleted() }) : executor.delete(table);
 				if (filters) query = query.where(filters);
-				query = query.returning(columns);
-				const result = await query;
-				await after(result);
+				query = query.returning(withHookReturning(columns));
+				const written = await query;
+				await after(written);
+				const result = output(written);
 				if (single && result.length > 1) throw drizzleError("'where' matched more than one row!", { code: "DRIZZLE_MULTI_ROW_MATCH" });
 				if (single) return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
 				return remapToGraphQLArrayOutput(result, tableName, table);
@@ -7484,7 +7645,10 @@ const createSchemaDataGenerator = (adapter) => {
 				requireWhere: tableFeatures.requireWhere,
 				filterCtx,
 				txCtx: mutationTxCtx,
-				nested: nestedRuntime
+				nested: nestedRuntime,
+				policies,
+				pkNames: primaryKeyPropNames(schema[tableName]),
+				returnsRows: true
 			}) : void 0;
 			const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 				db,
@@ -7495,7 +7659,10 @@ const createSchemaDataGenerator = (adapter) => {
 				fieldName: deleteCountFieldName,
 				requireWhere: tableFeatures.requireWhere,
 				filterCtx,
-				txCtx: mutationTxCtx
+				txCtx: mutationTxCtx,
+				policies,
+				pkNames: primaryKeyPropNames(schema[tableName]),
+				returnsRows: true
 			}) : void 0;
 			const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 			return {
@@ -7605,12 +7772,25 @@ const createSchemaDataGenerator = (adapter) => {
 					{
 						generated: updateCountGenerated,
 						type: new graphql.GraphQLNonNull(graphql.GraphQLInt),
+						meta: {
+							operation: "update",
+							single: false,
+							targetArg: "where",
+							count: true
+						},
 						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."
+						meta: {
+							operation: "delete",
+							single: false,
+							targetArg: "where",
+							count: true,
+							...hardDeleteMeta
+						},
+						description: "How many rows the delete removed — or, on a soft-deleting table, marked deleted. The rows themselves are not read back, which is the point of this mutation."
 					}
 				],
 				onConflictInput,
@@ -7672,7 +7852,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 			txCtx,
 			policies,
 			args: queryArgs,
-			run: async ({ executor, args, context, info, before, after }) => {
+			run: async ({ executor, args, context, info, before, after, returning: withHookReturning, output: withoutHookColumns }) => {
 				const { updates } = args;
 				if (!updates.length) throw drizzleError("No updates were provided!", { code: "DRIZZLE_NO_VALUES" });
 				await before();
@@ -7703,7 +7883,7 @@ 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 returning = withHookReturning(anyNested ? nested.withJoinColumns(tableName, mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))), { ...columns }, table) : columns);
 				const perEntry = await runBatch({
 					executor,
 					entries,
@@ -7714,8 +7894,9 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 					tableName,
 					context
 				});
-				const flatRows = perEntry.flat();
-				await after(flatRows);
+				const written = perEntry.flat();
+				await after(written);
+				const flatRows = withoutHookColumns(written);
 				const enriched = await withEagerRelations(executor, tableName, flatRows, pkNames, withParams, hasRelations);
 				const output = [];
 				let offset = 0;