@nestjs/graphql
Version:
GraphQL for NestJS: code-first and schema-first APIs, resolvers as providers, subscriptions, federation and generated SDL, on Apollo or Mercurius.
286 lines (285 loc) • 12.9 kB
JavaScript
import { GraphQLError, isInterfaceType, isObjectType, } from 'graphql';
import { getUseFieldMiddleware } from '../decorators/use-field-middleware.decorator.js';
import { FIELD_RESOLVER_COMPOSITION_METADATA } from '../graphql.constants.js';
import { TypeMetadataStorage } from '../schema-builder/storages/type-metadata.storage.js';
import { getInterfacesArray } from '../schema-builder/utils/get-interfaces-array.util.js';
import { decorateFieldResolverWithMiddleware } from './decorate-field-resolver.util.js';
/**
* Binds the field resolvers to the fields of the object types of a code-first
* schema. "GraphQLFactory" and "GraphQLFederationFactory" both use it, so that
* a field is bound the same way on every driver.
*/
export function createFieldResolverBinder({ executableSchema, resolvers, getType, globalMiddleware, }) {
const getExecutableResolve = getFieldResolvers(executableSchema);
const metadataByName = getTypeMetadataByName();
const resolverOnlyFields = getResolverOnlyFields();
const isResolverOnlyField = (field) => resolverOnlyFields.typeFns.has(field.typeFn);
/**
* The supertypes of a type are the interfaces it implements and the
* (object or interface) type its class extends
*/
const getSupertypes = (typeName) => {
const type = getType(typeName);
if (!isObjectType(type) && !isInterfaceType(type)) {
return [];
}
const supertypes = type.getInterfaces().map(({ name }) => name);
const parentMetadata = getParentTypeMetadata(metadataByName.get(typeName), ({ name }) => !!getType(name));
if (parentMetadata) {
supertypes.push(parentMetadata.name);
}
return supertypes;
};
const findResolverHost = createResolverHostLookup(getSupertypes, (typeName, fieldName) => hasOwnResolver(resolvers, typeName, fieldName) &&
!!getExecutableResolve(typeName, fieldName));
const unboundFields = [];
return {
/**
* Returns the resolver to bind to a field of an object type (other than
* a root type), or "undefined" to keep the one the field has:
* - the resolver of the type itself or, if it has none, the one of its
* most specific supertype (interfaces and parent classes), along with
* the middleware that the model declares for the field;
* - or else the resolver returned by "fallback";
* - or else, for a field that only a field resolver declares (the model
* has no such field), a resolver that throws: such a field must not
* fall back to the parent's property (fail closed).
*/
getFieldResolver(typeName, fieldName, fallback) {
const metadata = metadataByName.get(typeName);
const hostName = findResolverHost(typeName, fieldName);
if (hostName) {
return withModelFieldMiddleware(getExecutableResolve(hostName, fieldName), getRawResolver(resolvers, hostName, fieldName), metadata
? getModelFieldMiddleware(metadata, fieldName, isResolverOnlyField)
: [], globalMiddleware);
}
const fallbackResolve = fallback?.();
if (fallbackResolve) {
return fallbackResolve;
}
const fieldMetadata = metadata &&
resolverOnlyFields.names.has(fieldName) &&
findFieldMetadata(metadata, fieldName);
if (fieldMetadata && isResolverOnlyField(fieldMetadata)) {
unboundFields.push(`"${typeName}.${fieldName}"`);
return createUnboundFieldResolver(typeName, fieldName);
}
return undefined;
},
/**
* Logs the fields bound to a resolver that throws (see "getFieldResolver()").
*/
warnUnboundFields(logger) {
if (unboundFields.length > 0) {
logger.warn(`No resolver is bound for these fields, which are declared only by a field resolver (@ResolveField()): ${unboundFields.join(', ')}. Selecting them throws an error.`);
}
},
};
}
/**
* "@graphql-tools/schema" lets the interface that a type lists last win, so
* a base interface listed after an interface that implements it replaces the
* resolver of the more specific interface (and the guards wrapped around it).
* Binds the resolver of the most specific interface instead.
*/
export function inheritResolversFromInterfaces(schema, resolvers) {
const hasResolver = (typeName, fieldName) => hasOwnResolver(resolvers, typeName, fieldName) &&
!!getFieldResolve(schema, typeName, fieldName);
const findResolverHost = createResolverHostLookup((typeName) => {
const type = schema.getType(typeName);
return isObjectType(type) || isInterfaceType(type)
? type.getInterfaces().map(({ name }) => name)
: [];
}, hasResolver);
Object.values(schema.getTypeMap())
.filter(isObjectType)
.forEach((type) => {
const interfaces = type.getInterfaces();
Object.entries(type.getFields()).forEach(([fieldName, field]) => {
const hostName = findResolverHost(type.name, fieldName);
const listedLast = [...interfaces]
.reverse()
.find((interfaceRef) => hasResolver(interfaceRef.name, fieldName));
if (hostName !== type.name && hostName !== listedLast?.name) {
field.resolve = getFieldResolve(schema, hostName, fieldName);
}
});
});
}
/**
* Returns a function that finds the type whose resolver of a field is bound
* to a type: the type itself if it has one or else, among its supertypes
* that have one, the most specific. Among unrelated supertypes, the parent
* class wins over interfaces, and the interface listed last wins over the others.
*/
function createResolverHostLookup(getSupertypes, hasResolver) {
const ancestorsByType = new Map();
const getAncestors = (typeName) => {
if (!ancestorsByType.has(typeName)) {
const ancestors = [];
const queue = [typeName];
while (queue.length > 0) {
for (const supertype of getSupertypes(queue.shift())) {
if (supertype !== typeName && !ancestors.includes(supertype)) {
ancestors.push(supertype);
queue.push(supertype);
}
}
}
ancestorsByType.set(typeName, ancestors);
}
return ancestorsByType.get(typeName);
};
return (typeName, fieldName) => {
if (hasResolver(typeName, fieldName)) {
return typeName;
}
const candidates = getAncestors(typeName).filter((ancestor) => hasResolver(ancestor, fieldName));
const mostSpecific = candidates.filter((candidate) => !candidates.some((other) => getAncestors(other).includes(candidate)));
return mostSpecific[mostSpecific.length - 1];
};
}
function hasOwnResolver(resolvers, typeName, fieldName) {
const typeResolvers = resolvers[typeName];
return (typeof typeResolvers === 'object' &&
typeResolvers !== null &&
Object.prototype.hasOwnProperty.call(typeResolvers, fieldName) &&
typeResolvers[fieldName] != null);
}
function getRawResolver(resolvers, typeName, fieldName) {
const resolver = resolvers[typeName]?.[fieldName];
return typeof resolver === 'function' ? resolver : resolver?.resolve;
}
function getFieldResolve(schema, typeName, fieldName) {
const type = schema.getType(typeName);
return isObjectType(type) || isInterfaceType(type)
? type.getFields()[fieldName]?.resolve
: undefined;
}
/**
* Returns a lookup of the resolvers bound to the fields of the object and
* interface types of a schema, as they are now.
*/
function getFieldResolvers(schema) {
const resolveByField = new Map();
for (const type of Object.values(schema.getTypeMap())) {
if (isObjectType(type) || isInterfaceType(type)) {
for (const [fieldName, field] of Object.entries(type.getFields())) {
if (field.resolve) {
resolveByField.set(`${type.name}.${fieldName}`, field.resolve);
}
}
}
}
return (typeName, fieldName) => resolveByField.get(`${typeName}.${fieldName}`);
}
/**
* Wraps the resolver bound to a field with the middleware that the model
* declares for that field (which the resolver generated for the field runs
* too), instead of dropping that middleware.
*/
function withModelFieldMiddleware(resolve, rawResolver, modelMiddleware, globalMiddleware) {
if (modelMiddleware.length === 0) {
return resolve;
}
const composition = typeof rawResolver === 'function'
? Reflect.getMetadata(FIELD_RESOLVER_COMPOSITION_METADATA, rawResolver)
: undefined;
if (!composition) {
return decorateFieldResolverWithMiddleware((...args) => () => resolve(...args), modelMiddleware);
}
// The global middleware first, then the model's and the handler's, each once
return decorateFieldResolverWithMiddleware((...args) => () => composition.resolve(...args), [
...globalMiddleware,
...modelMiddleware.filter((middleware) => !composition.middleware.includes(middleware)),
...composition.middleware,
]);
}
function createUnboundFieldResolver(typeName, fieldName) {
return () => {
throw new GraphQLError(`No resolver is bound for field "${typeName}.${fieldName}".`);
};
}
function getTypeMetadataByName() {
const metadataByName = new Map();
const metadata = [
...TypeMetadataStorage.getObjectTypesMetadata(),
...TypeMetadataStorage.getInterfacesMetadata(),
];
for (const item of metadata) {
if (!item.isAbstract && !metadataByName.has(item.name)) {
metadataByName.set(item.name, item);
}
}
return metadataByName;
}
/**
* Returns the "typeFn" (and the names) of the fields that the field
* resolvers add to a type when the model declares no field of that name.
*/
function getResolverOnlyFields() {
const fieldResolvers = TypeMetadataStorage.getFieldResolversMetadata().filter((item) => item.kind === 'external' && item.typeFn);
return {
typeFns: new Set(fieldResolvers.map((item) => item.typeFn)),
names: new Set(fieldResolvers.map((item) => item.schemaName)),
};
}
/**
* Returns the metadata of the nearest class up the prototype chain that is
* an object or an interface type (and matches the predicate).
*/
function getParentTypeMetadata(metadata, predicate = () => true) {
let parent = metadata && Object.getPrototypeOf(metadata.target);
while (parent && parent !== Function.prototype) {
const parentMetadata = TypeMetadataStorage.getObjectTypeMetadataByTarget(parent) ??
TypeMetadataStorage.getInterfaceMetadataByTarget(parent);
if (parentMetadata && predicate(parentMetadata)) {
return parentMetadata;
}
parent = Object.getPrototypeOf(parent);
}
return undefined;
}
function getInterfacesMetadata(metadata) {
const interfaces = [];
const queue = [metadata];
while (queue.length > 0) {
for (const target of getInterfacesArray(queue.shift().interfaces)) {
const item = TypeMetadataStorage.getInterfaceMetadataByTarget(target);
if (item && !interfaces.includes(item)) {
interfaces.push(item);
queue.push(item);
}
}
}
return interfaces;
}
/**
* Returns the nearest declaration of a field that matches the predicate:
* the type's own, or else an interface's, or else the parent class's.
*/
function findFieldMetadata(metadata, fieldName, predicate = () => true) {
const visited = new Set();
for (let current = metadata; current && !visited.has(current); current = getParentTypeMetadata(current)) {
visited.add(current);
for (const item of [current, ...getInterfacesMetadata(current)]) {
const field = [...(item.properties ?? [])]
.reverse()
.find((property) => property.schemaName === fieldName && predicate(property));
if (field) {
return field;
}
}
}
return undefined;
}
/**
* Returns the middleware that the model declares for a field with
* "@Field({ middleware })" and "@UseFieldMiddleware()" (no global middleware).
*/
function getModelFieldMiddleware(metadata, fieldName, isResolverOnlyField) {
const field = findFieldMetadata(metadata, fieldName, (property) => !isResolverOnlyField(property));
return field
? (field.middleware ?? []).concat(getUseFieldMiddleware(field.target?.prototype, field.name))
: [];
}