@vantreeseba/drizzle-graphql 12.0.1 → 13.1.0

package/README.md

@@ -104,8 +104,10 @@ as a preset:
 const { schema } = buildSchema(db, { typeNameMapper: 'singularize' })
 ```
 
-`tasks` then gives type `Task`, queries `tasks` (list) and `task` (single), mutations
-`createTasks` (array) and `createTask` (single), `updateTask`, `deleteTask`. Irregular
+`tasks` then gives type `Task`, queries `tasks` (list) and `task` (single), and each write
+as a pair named the same way: `createTasks` / `createTask`, `updateTasks` / `updateTask`,
+`deleteTasks` / `deleteTask` — plural for the form that operates on a set of rows, singular
+for the one that operates on exactly one. Irregular
 plurals go through `pluralize`, so `people` gives `Person` / `people` / `person` and
 `addresses` gives `Address` rather than the `addresss` a naive suffix would produce. A table
 key that is already singular is pluralized for the list side, and a capitalized key is
@@ -362,9 +364,9 @@ variants that carry their own disambiguator — `usersAggregate`, `usersGroupBy`
 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. 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.
+plural and singular nouns keep every pair apart on their own, so both suffixes may be empty
+and no operation carries a `Single` at all. A table the mapper returns `undefined` for is
+back on the default naming and still needs the suffixes to differ.
 
 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
@@ -381,7 +383,8 @@ import pluralize from 'pluralize'
 const { schema } = buildSchema(db, {
     typeNameMapper: (table) => ({ singular: pluralize.singular(table), plural: table }),
 })
-// type User; queries `users` / `user`; mutations `createUsers` / `createUser`
+// type User; queries `users` / `user`; mutations `createUsers` / `createUser`,
+// `updateUsers` / `updateUser`, `deleteUsers` / `deleteUser`
 ```
 
 Return `undefined` for any table that should keep its default naming.
@@ -708,6 +711,51 @@ lists is the build-time error above.
 >     `${tableName}${columnName[0]!.toUpperCase()}${columnName.slice(1)}Enum`
 > ```
 
+### Enum value names
+
+A value's GraphQL name is the stored value itself, or `Option<index>` when the stored value
+is not a usable GraphQL name. `enumValueNameMapper` renames the values — most often to follow
+GraphQL's SCREAMING_CASE convention while the database keeps its lowercase values:
+
+```Typescript
+export const Runs = pgTable('runs', {
+    status: text('status', { enum: ['running', 'ok', 'error', 'stopped'] }),
+})
+
+const { schema } = buildSchema(db, {
+    // The built-in preset: `inProgress` / `in-progress` → `IN_PROGRESS`
+    enumValueNameMapper: 'constant',
+})
+```
+
+```graphql
+enum RunsStatusEnum {
+    RUNNING   # stored as 'running'
+    OK
+    ERROR
+    STOPPED
+}
+```
+
+-   Only the GraphQL name changes. Each value's internal `value` is still the stored string,
+    so filters (`eq`, `inArray`, …), create/update inputs, outputs and your own resolvers keep
+    sending and receiving exactly what the database stores. The generated TypeScript types
+    keep the stored values too
+-   The function form receives the stored `value`, its `index`, the enum's GraphQL `typeName`
+    (after `enumNameMapper`) and everything `enumNameMapper` receives. Returning `undefined`
+    keeps the default name for that value:
+
+    ```Typescript
+    enumValueNameMapper: ({ value, typeName }) =>
+        typeName === 'RunsStatusEnum' ? value.toUpperCase() : undefined,
+    ```
+
+-   The build fails, rather than producing an invalid or lossy schema, when a returned name is
+    not a valid GraphQL enum value name, when two values of one enum map to the same name, or
+    when columns that share one enum type (the columns of one `pgEnum`) would name its values
+    differently — give those columns separate types with `enumNameMapper` if they really
+    should differ
+
 ## Documenting the schema
 
 Four hooks put descriptions and deprecations on the generated types. Each is called per
@@ -1590,7 +1638,9 @@ mutation {
 ## Single-row update & delete
 
 Alongside the plural `update<Table>` / `delete<Table>` mutations, every table gets an
-`update<Table>Single` / `delete<Table>Single` variant that targets exactly one row:
+`update<Table>Single` / `delete<Table>Single` variant that targets exactly one row. (Under a
+[`typeNameMapper`](#naming) the pair is separated by the noun instead — `updateUsers` /
+`updateUser` — and there is no `Single`.)
 
 ```graphql
 mutation {
@@ -1874,7 +1924,7 @@ to match on prose:
 ```json
 {
     "message": "'where' matched more than one row — nothing was written!",
-    "path": ["updateUser"],
+    "path": ["updateUsersSingle"],
     "extensions": {
         "code": "DRIZZLE_MULTI_ROW_MATCH",
         "drizzle": { "table": "Users", "operation": "update", "field": "updateUsersSingle" }
@@ -2014,8 +2064,12 @@ outside the resolver, so its after-position is after the commit.
 ```Typescript
 const { schema } = buildSchema(db, {
     onWrite: {
-        posts: async ({ table, operation, rows, tx }) => {
-            await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })))
+        posts: {
+            after: async ({ table, operation, rows, tx }) => {
+                await tx.insert(auditLog).values(rows.map((row) => ({ table, operation, rowId: row.id })))
+            },
+            // Every row carries `id`, even when the client's mutation did not select it.
+            columns: ['id'],
         },
     },
 })
@@ -2041,6 +2095,39 @@ Registering a bare function (or a positions object) at the top level applies it
 anything else is read as a table map keyed by the **Drizzle schema key**, and a name that
 matches nothing throws at build time.
 
+### Which columns `rows` holds
+
+The statement's `RETURNING` list is built from the client's selection, so by default a row
+holds only the columns the mutation's document asked for (plus any key a selected relation or a
+nested write needed). A hook that reads a column the client may not select — `row.id` above, or
+the `personId` an `addresses` hook needs to bump its person's revision — names it in `columns`:
+
+```Typescript
+onWrite: {
+    addresses: {
+        after: async ({ rows, tx }) => { /* every row has `id` and `personId` */ },
+        columns: ['id', 'personId'],
+    },
+    contactInfos: {
+        after: async ({ rows, tx }) => { /* every row has every column */ },
+        columns: 'all',
+    },
+}
+```
+
+-   The names are **column keys** — the property names on the Drizzle table object, which is
+    what `rows` is keyed by. An unknown name throws at build time, and so does `columns` on a
+    registration with no `after` hook (only `after` is handed rows).
+-   On a top-level registration, a named column must exist on **every** table; `'all'` always
+    works.
+-   The columns are added to `RETURNING` for every write the hook is attached to: insert, upsert,
+    update, `updateMany`, delete and restore. A delete's rows are the rows it removed.
+-   **The client's response is unchanged.** Columns the hook asked for but the client did not
+    select are taken back off before the rows are mapped, so they reach neither the response nor
+    a custom resolver calling the generated one. The hook gets its own copy of the rows.
+-   **MySQL** has no `RETURNING`, so its mutations return no rows and `columns` has nothing to
+    add to: `rows` stays empty there. The names are still checked at build time.
+
 The payload:
 
 | Field | |
@@ -2050,7 +2137,7 @@ The payload:
 | `position` | `'before'` or `'after'` |
 | `single` | whether the field writes one row or a list |
 | `args` | the field's GraphQL arguments, as the resolver received them |
-| `rows` | the post-write rows **as the database returned them**, before the output mapper |
+| `rows` | the post-write rows **as the database returned them**, before the output mapper — the selected columns plus the hook's [`columns`](#which-columns-rows-holds) |
 | `context`, `info` | the GraphQL context value and resolve info |
 | `tx` | the executor the mutation ran on |
 
@@ -2280,6 +2367,7 @@ that explains it, where there is one.
 | `typeNamePrefix` / `typeNameSuffix` / `derivedTypeNameMapper` | none | [names of the derived types](#renaming-the-derived-types) — filters, inputs, aggregates, shared inputs |
 | `scalars` / `mapColumnType` | built-in detection | [override a column's GraphQL type](#overriding-a-columns-scalar), by name or by rule |
 | `enumNameMapper` | shared `<EnumName>Enum` per database enum | [names the enum a column maps to](#enum-types) |
+| `enumValueNameMapper` | the stored value | [names the enum's values](#enum-value-names); `'constant'` for CONSTANT_CASE |
 | `describeColumn` / `describeTable` / `describeRelation` | none | [GraphQL descriptions](#documenting-the-schema) |
 | `deprecateColumn` | none | `@deprecated` on a column's output and optional input fields |
 | `conflictDoNothing` | `false` | PostgreSQL only — `ON CONFLICT DO NOTHING` on inserts, which makes `create<Table>Single` nullable |

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;
@@ -4320,17 +4374,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,
@@ -4830,16 +4882,70 @@ const generateTableTypes = (tableName, tables, relationMap, withReturning, relat
 * that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
 * names them explicitly.
 */
-const normalizeWriteHooks = (hooks) => {
+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.
 */
@@ -4882,6 +4988,7 @@ const writeResolver = ({ db, tableName, operation, single, fieldName, args: quer
 						info,
 						tx: executor
 					};
+					let added;
 					return run({
 						executor,
 						args,
@@ -4891,7 +4998,13 @@ const writeResolver = ({ db, tableName, operation, single, fieldName, args: quer
 						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) {
@@ -5065,19 +5178,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,
@@ -5143,6 +5255,7 @@ const resolveBuildConfig = (config, schema) => {
 		scalars: config?.scalars,
 		mapColumnType: config?.mapColumnType,
 		enumNameMapper: config?.enumNameMapper,
+		enumValueNameMapper: config?.enumValueNameMapper,
 		transactions,
 		limits,
 		policies,
@@ -7026,7 +7139,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();
@@ -7048,13 +7161,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,
@@ -7063,7 +7176,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;
@@ -7099,7 +7213,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();
@@ -7121,7 +7235,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,
@@ -7142,7 +7256,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					});
 					return await query;
 				};
-				const result = nestedEntries ? await writeWithNestedOps({
+				const written = nestedEntries ? await writeWithNestedOps({
 					executor,
 					runtime: nested,
 					tableName,
@@ -7151,7 +7265,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);
@@ -7175,7 +7290,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();
@@ -7206,14 +7321,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,
@@ -7223,7 +7338,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);
@@ -7263,7 +7379,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);
@@ -7283,9 +7399,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);
@@ -7674,7 +7791,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();
@@ -7705,7 +7822,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,
@@ -7716,8 +7833,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;