@vantreeseba/drizzle-graphql 12.0.1 → 13.1.0

package/dist/index.js

@@ -165,6 +165,14 @@ const GraphQLDecimalString = new 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`,
@@ -185,6 +193,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: [...] })`,
@@ -205,20 +215,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();
 };
 /**
@@ -247,22 +272,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 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;
 };
@@ -1017,6 +1070,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;
@@ -4296,17 +4350,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,
@@ -4806,16 +4858,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.
 */
@@ -4858,6 +4964,7 @@ const writeResolver = ({ db, tableName, operation, single, fieldName, args: quer
 						info,
 						tx: executor
 					};
+					let added;
 					return run({
 						executor,
 						args,
@@ -4867,7 +4974,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) {
@@ -5041,19 +5154,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, 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, 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,
@@ -5119,6 +5231,7 @@ const resolveBuildConfig = (config, schema) => {
 		scalars: config?.scalars,
 		mapColumnType: config?.mapColumnType,
 		enumNameMapper: config?.enumNameMapper,
+		enumValueNameMapper: config?.enumValueNameMapper,
 		transactions,
 		limits,
 		policies,
@@ -7002,7 +7115,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();
@@ -7024,13 +7137,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,
@@ -7039,7 +7152,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;
@@ -7075,7 +7189,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();
@@ -7097,7 +7211,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,
@@ -7118,7 +7232,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 					});
 					return await query;
 				};
-				const result = nestedEntries ? await writeWithNestedOps({
+				const written = nestedEntries ? await writeWithNestedOps({
 					executor,
 					runtime: nested,
 					tableName,
@@ -7127,7 +7241,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);
@@ -7151,7 +7266,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();
@@ -7182,14 +7297,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,
@@ -7199,7 +7314,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);
@@ -7239,7 +7355,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);
@@ -7259,9 +7375,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);
@@ -7650,7 +7767,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();
@@ -7681,7 +7798,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,
@@ -7692,8 +7809,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;