@vantreeseba/drizzle-graphql 9.1.1 → 10.0.0

package/README.md

@@ -1831,6 +1831,19 @@ image, a stored value the scalar transporting it cannot represent, is
 `DRIZZLE_UNREPRESENTABLE_VALUE`; it says the data is out of range, not that the request was
 wrong.
 
+An `update`'s `set` giving a `NOT NULL` column an explicit `null` is `DRIZZLE_NOT_NULL`, and the
+error names the column. Every field of an update input is nullable — that is what makes a partial
+`set` possible — so the nullability says nothing about the column, and an update has no default to
+fall back on: `null` there can only mean "write null". Nothing is written, including the rest of
+the `set`. To leave a column alone, omit it.
+
+An **insert** reads the same `null` the other way, and is unchanged. A `NOT NULL` column's field
+on a create input is non-null unless the database, drizzle, or a nested `create` can fill it in,
+so the only nulls that reach a resolver are ones the schema offered as "I am not supplying this" —
+and they let the default apply, which is what makes `id: $id` with a null variable insert a new
+row. A `NOT NULL` column with nothing to fill it is rejected while GraphQL coerces the request.
+Upserts take the create input, so they follow the insert rule.
+
 The `drizzle` block is only on errors raised from inside a field. An argument rejected while
 GraphQL coerces the request — a `BigInt` variable that is not an integer, say — is rejected
 before any resolver runs, so it carries its `code` but no `drizzle` and no `path`.

package/dist/index.cjs

@@ -29,7 +29,6 @@ let graphql = require("graphql");
 let pluralize = require("pluralize");
 pluralize = __toESM(pluralize, 1);
 let graphql_scalars = require("graphql-scalars");
-let graphql_parse_resolve_info = require("graphql-parse-resolve-info");
 //#region src/util/builders/common/errors.ts
 /**
 * A `GraphQLError` carrying its context as data. The message says what went wrong, in prose
@@ -588,12 +587,13 @@ const remapFromGraphQLCore = (value, column, columnName) => {
 			return value;
 	}
 };
-const remapFromGraphQLSingleInput = (queryInput, table) => {
+const remapFromGraphQLSingleInput = (queryInput, table, operation = "insert") => {
 	for (const [key, value] of Object.entries(queryInput)) if (value === void 0) delete queryInput[key];
 	else {
 		const column = (0, drizzle_orm.getTableColumns)(table)[key];
 		if (!column) throw drizzleError(`Unknown column: ${key}`, { code: "DRIZZLE_UNKNOWN_COLUMN" });
 		if (value === null && column.notNull) {
+			if (operation === "update") throw drizzleError(`Column '${key}' cannot be set to null.`, { code: "DRIZZLE_NOT_NULL" });
 			delete queryInput[key];
 			continue;
 		}
@@ -601,8 +601,8 @@ const remapFromGraphQLSingleInput = (queryInput, table) => {
 	}
 	return queryInput;
 };
-const remapFromGraphQLArrayInput = (queryInput, table) => {
-	for (const entry of queryInput) remapFromGraphQLSingleInput(entry, table);
+const remapFromGraphQLArrayInput = (queryInput, table, operation = "insert") => {
+	for (const entry of queryInput) remapFromGraphQLSingleInput(entry, table, operation);
 	return queryInput;
 };
 //#endregion
@@ -3004,10 +3004,14 @@ const splitFieldUpdateOperations = (values, table, tableName) => {
 *
 * Safe to call on every update path regardless of `features.fieldUpdateOperations` — see the
 * shape check in {@link splitFieldUpdateOperations}.
+*
+* This is the single funnel every update goes through — the plural and `Single` mutations,
+* `updateMany`, the `Count` mutations and the MySQL builder's own — which is why it is the
+* one place that has to tell the remapper it is serving an update rather than an insert.
 */
 const remapUpdateInput = (values, table, tableName) => {
 	const { columns, expressions } = splitFieldUpdateOperations(values, table, tableName);
-	const remapped = remapFromGraphQLSingleInput(columns, table);
+	const remapped = remapFromGraphQLSingleInput(columns, table, "update");
 	return Object.keys(expressions).length ? {
 		...remapped,
 		...expressions
@@ -4764,6 +4768,150 @@ const resolveBuildConfig = (config, schema) => {
 	};
 };
 //#endregion
+//#region src/util/parse-resolve-info.ts
+/** Unwraps `[T]!`-style wrappers down to the named type. `getNamedType` without the realm tie. */
+const namedTypeOf = (type) => {
+	let current = type;
+	while (current?.ofType) current = current.ofType;
+	return current;
+};
+/**
+* Whether a field's named output type has sub-selections. Object types and interfaces expose
+* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
+* also expose `getFields`, but an input type can never be a field's output type, so there is
+* nothing here for that to collide with.
+*/
+const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
+/**
+* The fields declared on a type, or `undefined` when it has none to declare. A union is the
+* case that matters: it has no fields of its own, so a selection directly against one resolves
+* to nothing and is dropped — only the inline fragments underneath contribute.
+*/
+const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
+/**
+* The runtime variable values, in the plain-map form the directive check wants. graphql 17
+* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
+*/
+const coercedVariables = (info) => {
+	const values = info.variableValues;
+	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
+	return values ?? {};
+};
+/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
+const directiveIfValue = (info, value) => {
+	if (value.kind === graphql.Kind.VARIABLE) return coercedVariables(info)[value.name.value];
+	if (value.kind === graphql.Kind.BOOLEAN) return value.value;
+};
+/**
+* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
+* spreads and inline fragments alike, which is where graphql puts them.
+*/
+const isExcluded = (info, node) => {
+	for (const directive of node.directives ?? []) {
+		const directiveName = directive.name.value;
+		if (directiveName !== "skip" && directiveName !== "include") continue;
+		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
+		if (!ifArgument) continue;
+		const value = directiveIfValue(info, ifArgument.value);
+		if (directiveName === "skip" ? !!value : !value) return true;
+	}
+	return false;
+};
+/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
+const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
+/**
+* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
+* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
+* to declare a field by that name.
+*/
+const isMetaField = (name) => name.startsWith("__") && name !== "__id";
+/**
+* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
+* level, this owns the entries under `parentType`'s name.
+*
+* `activeFragments` is the set of fragment names on the current spread path. A document that
+* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
+* caller assembled by hand, and an unbounded walk would hang rather than fail.
+*/
+const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
+	const parentTypeName = parentType?.name;
+	if (!parentTypeName) return tree;
+	let fields = tree[parentTypeName];
+	if (!fields) {
+		fields = {};
+		tree[parentTypeName] = fields;
+	}
+	for (const selection of selections) {
+		if (isExcluded(info, selection)) continue;
+		if (selection.kind === graphql.Kind.FIELD) {
+			const name = selection.name.value;
+			if (isMetaField(name)) continue;
+			const fieldDef = fieldsOf(parentType)?.[name];
+			if (!fieldDef) continue;
+			const fieldType = namedTypeOf(fieldDef.type);
+			if (!fieldType) continue;
+			const composite = isCompositeLike(fieldType);
+			const alias = selection.alias?.value || name;
+			let node = fields[alias];
+			if (!node) {
+				node = {
+					name,
+					alias,
+					args: { ...(0, graphql.getArgumentValues)(fieldDef, selection, info.variableValues) },
+					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
+				};
+				fields[alias] = node;
+			}
+			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
+			continue;
+		}
+		if (!deep) continue;
+		if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
+			const fragmentName = selection.name.value;
+			const fragment = info.fragments?.[fragmentName];
+			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
+			if (activeFragments.has(fragmentName)) continue;
+			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			activeFragments.add(fragmentName);
+			try {
+				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+			} finally {
+				activeFragments.delete(fragmentName);
+			}
+			continue;
+		}
+		if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+		}
+	}
+	return tree;
+};
+const firstKey = (object) => Object.keys(object)[0];
+/**
+* Reads the selection under a resolver's own field out of its `info`, as a tree of
+* {@link ResolveTree} nodes.
+*
+* ```ts
+* const parsed = parseResolveInfo(info, { deep: true })!;
+* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+* ```
+*
+* Returns `undefined` when the resolver's field produced no node at all, which in practice
+* means `info` carried no field nodes.
+*/
+const parseResolveInfo = (info, options = {}) => {
+	const fieldNodes = info.fieldNodes;
+	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
+	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
+	const typeKey = firstKey(tree);
+	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
+	const fieldKey = fields && firstKey(fields);
+	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
+};
+//#endregion
 //#region src/util/builders/aggregates.ts
 /** Operations that aggregate over a set of column values. `count` is handled separately (whole rows). */
 const AGGREGATE_OPS = [
@@ -4905,7 +5053,7 @@ const aggregateTarget = (table, tableName, typeName, resolveName) => {
 * client asked for nothing runnable (`__typename` only, or empty sub-selections).
 */
 const parseAggregateRequest = (info, target, rootTypeName = target.aggregateTypeName) => {
-	const selectionTree = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true }).fieldsByTypeName[rootTypeName] ?? {};
+	const selectionTree = parseResolveInfo(info, { deep: true }).fieldsByTypeName[rootTypeName] ?? {};
 	const request = {
 		count: false,
 		ops: {
@@ -5833,7 +5981,7 @@ const createSelectGenerators = (primaryKeyPropNames, nullOrdering) => {
 			resolver: async (_source, rawArgs, context, info) => {
 				const args = withDefaultOrderBy(rawArgs, tableName, policies?.defaultOrderBy);
 				try {
-					const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+					const parsedInfo = parseResolveInfo(info, { deep: true });
 					const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
 					return await runRelationalSelect({
 						queryBase: requestQueryBase,
@@ -5879,7 +6027,7 @@ const createSelectGenerators = (primaryKeyPropNames, nullOrdering) => {
 			resolver: async (_source, rawArgs, context, info) => {
 				const args = withDefaultOrderBy(rawArgs, tableName, policies?.defaultOrderBy);
 				try {
-					const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+					const parsedInfo = parseResolveInfo(info, { deep: true });
 					const { executor, queryBase: requestQueryBase } = resolveQueryExecutor(db, context, tableName, queryBase);
 					return await runRelationalSelect({
 						queryBase: requestQueryBase,
@@ -6543,7 +6691,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				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 parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
 					relationMap,
 					tables,
@@ -6598,7 +6746,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntry ? {} : applyContextValues(remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table), contextColumns, context);
-				const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
 					relationMap,
 					tables,
@@ -6671,7 +6819,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const contextColumns = policies?.contextValues?.(tableName);
 				const scope = policies?.scope?.(context);
 				const input = nestedEntries ? [] : applyContextValuesAll(remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table), contextColumns, context);
-				const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
 					relationMap,
 					tables,
@@ -6742,7 +6890,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const { where, set } = args;
 				const scope = policies?.scope?.(context);
 				await before();
-				const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
 					relationMap,
 					tables,
@@ -6823,7 +6971,7 @@ const buildWriteResolvers = (primaryKeyPropNames) => {
 				const hard = canHardDelete && args.hard === true;
 				const scope = policies?.scope?.(context);
 				await before();
-				const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const columns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[applyObjectTypeName(typeName, tableName, resolveName)], table, selectionCtx);
 				const relationCtx = relationFilterCtx(filterCtx, tableName);
 				const filters = withScope(scope, tableName, table, single || requireWhere ? extractRequiredFilters(table, tableName, where, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0, restore ? "ONLY" : hard ? "INCLUDE" : void 0);
@@ -7155,7 +7303,7 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 				await before();
 				const scope = policies?.scope?.(context);
 				const contextColumns = policies?.contextValues?.(tableName);
-				const parsedInfo = (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+				const parsedInfo = parseResolveInfo(info, { deep: true });
 				const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
 					relationMap,
 					tables,
@@ -7341,7 +7489,7 @@ const namingRuleOf = (options) => resolveGeneratedTypeNames({
 */
 const parseInfo = (info) => {
 	if ("fieldsByTypeName" in info) return info;
-	return (0, graphql_parse_resolve_info.parseResolveInfo)(info, { deep: true });
+	return parseResolveInfo(info, { deep: true });
 };
 /**
 * Translates a GraphQL selection set into the relational query builder's `with` tree — the
@@ -7469,6 +7617,7 @@ exports.extractOrderBy = extractOrderBy;
 exports.extractRelationJoinColumns = extractRelationJoinColumns;
 exports.identifyRows = identifyRows;
 exports.isDrizzleFieldExtension = isDrizzleFieldExtension;
+exports.parseResolveInfo = parseResolveInfo;
 exports.resolveSelection = resolveSelection;
 exports.selectionToWith = selectionToWith;
 exports.singularizeMapper = singularizeMapper;