@nestjs/graphql
Version:
GraphQL for NestJS: code-first and schema-first APIs, resolvers as providers, subscriptions, federation and generated SDL, on Apollo or Mercurius.
89 lines (88 loc) • 3.88 kB
JavaScript
import { isInputObjectType, isInterfaceType, isListType, isNonNullType, isObjectType, } from 'graphql';
/**
* graphql-js hands the default value of an argument or input field to the
* resolver as it is, while a value sent by the client is coerced against its
* type: the input fields it leaves out take their own default values, and a
* single item given for a list becomes a list. A declared default such as
* `filter: PostFilter = {}` would then reach the resolver without the field
* defaults the same `{}` gets when a client sends it (or when the schema is
* rebuilt from its SDL, as the federation drivers do).
*
* Completes the declared default values the same way, once the schema is
* built (the input types a default refers to cannot be read while the fields
* of the input types are still being generated).
*/
export function completeDefaultValues(schema) {
for (const type of Object.values(schema.getTypeMap())) {
if (isObjectType(type) || isInterfaceType(type)) {
for (const field of Object.values(type.getFields())) {
field.args.forEach(completeElementDefaultValue);
}
}
else if (isInputObjectType(type)) {
Object.values(type.getFields()).forEach(completeElementDefaultValue);
}
}
return schema;
}
function completeElementDefaultValue(element) {
const completedValue = completeDefaultValue(element.defaultValue, element.type, new Set());
if (completedValue === element.defaultValue) {
return;
}
element.defaultValue = completedValue;
// graphql v17 reads the default from "default" (see "backfillDefaultValues")
const holder = element;
if (holder.default && 'value' in holder.default) {
holder.default = { value: completedValue };
}
}
/**
* Returns the value itself when there is nothing to complete. Enum and scalar
* values stay in their internal form. "expandedFields" holds the input fields
* whose default value is being expanded, so that a default value that refers
* to its own type (e.g., `next: Node = {}`) is expanded only once.
*/
function completeDefaultValue(value, type, expandedFields) {
if (value === undefined || value === null) {
return value;
}
if (isNonNullType(type)) {
return completeDefaultValue(value, type.ofType, expandedFields);
}
if (isListType(type)) {
if (!Array.isArray(value)) {
return [completeDefaultValue(value, type.ofType, expandedFields)];
}
const items = value.map((item) => completeDefaultValue(item, type.ofType, expandedFields));
return items.every((item, index) => item === value[index]) ? value : items;
}
if (!isInputObjectType(type) ||
typeof value !== 'object' ||
Array.isArray(value)) {
return value;
}
const inputObject = value;
let completedValue = inputObject;
for (const field of Object.values(type.getFields())) {
const fieldValue = inputObject[field.name];
let completedFieldValue = fieldValue;
if (fieldValue !== undefined) {
completedFieldValue = completeDefaultValue(fieldValue, field.type, expandedFields);
}
else if (!expandedFields.has(field)) {
expandedFields.add(field);
completedFieldValue = completeDefaultValue(field.defaultValue, field.type, expandedFields);
expandedFields.delete(field);
}
if (completedFieldValue === fieldValue) {
continue;
}
if (completedValue === inputObject) {
// Copy on write, keeping the prototype (e.g., of an @InputType() class)
completedValue = Object.assign(Object.create(Object.getPrototypeOf(inputObject)), inputObject);
}
completedValue[field.name] = completedFieldValue;
}
return completedValue;
}