GraphQL-Patterns für Fortgeschrittene: Der allmächtige Root Resolver

Was ist ein allmächtiger Root Resolver und wann brauchst du einen? Wenn du es wissen willst, komm mit: Wir verlassen die heile Welt der lokalen Resolver.
Dieser Artikel setzt etwas Praxiserfahrung mit serverseitigem GraphQL voraus, insbesondere mit Apollo Server. Er ist Teil einer Serie von smartive über GraphQL auf Enterprise-Niveau.
- Teil 1: Enterprise-taugliche APIs mit GraphQL, MySQL und Node.js bauen
- Teil 2: GraphQL-Patterns für Fortgeschrittene: Der allmächtige Root Resolver
- Teil 3: GraphQL-Patterns für Fortgeschrittene: Lerne den AST lieben!
- Teil 4: GraphQL und MySQL: Das Join-Problem lösen
- Teil 5: GraphQL und Elasticsearch: Ein Liebesbrief 💌
- Teil 6: Die beliebtesten GraphQL-Server und -Clients für Node.js
Die heile Welt der lokalen Resolver
Du kennst das Versprechen: Um einen GraphQL-Server zu bauen, musst du nur (1) dein Schema definieren und (2) die Resolver implementieren, die sich um die einzelnen Teile des Schemas kümmern.
const { ApolloServer, gql } = require('apollo-server');
const typeDefs = gql`
type Book {
title: String
author: String
}
type Query {
books: [Book]
}
`;
const resolvers = {
Query: {
books: () => { /* get them books */ },
},
};
const server = new ApolloServer({ typeDefs, resolvers });
server.listen().then(({ url }) => {
console.log(`🚀 Server ready at ${url}`);
});Du brauchst verknüpfte Daten? Kein Problem, definier einfach die nötigen Subresolver. Um den Rest kümmert sich Apollo Server.
const typeDefs = gql`
type User {
name: String
}
type Book {
title: String
author: User
}
# ...
`;
const resolvers = {
Book: {
author: (book) => { /* find user by book.authorId */ }
}
/* ... */
};Ist der Autor schon im Buch-Objekt gespeichert, etwa in einer MongoDB-Datenbank? Umso besser. Dann brauchst du gar keinen zusätzlichen Resolver.
Raus aus der heilen Welt
Baust du an einer komplexen GraphQL-API mit, stösst du aber irgendwann an die Grenzen dieses Ansatzes. Vielleicht brauchst du im Parent-Resolver Informationen über verknüpfte Daten. Vielleicht brauchst du in einem Leaf-Resolver Daten aus der «Grosseltern»-Ebene. Vielleicht wird deine API ineffizient und du willst in einem übergeordneten Resolver mehr Daten auf einmal holen (das nenne ich das Join-Problem, mehr dazu in einem späteren Artikel). Der Happy Path mit lokalen Resolvern reicht dann nicht mehr.
const resolvers = {
Query: {
books: () => { /* get the books and if needed each book's author (whew!) */ },
},
};Plötzlich starrst du auf das furchteinflössende info-Argument. Irgendwie hackst du einen Join zusammen, aber es fühlt sich an, als würdest du an den Innereien herumschrauben. Und du hoffst, dass du das nie wieder anfassen musst. Du hast dich tief im Wald verirrt.
Der allmächtige Root Resolver
Wenn du dich tief genug ins Dickicht wagst, stösst du irgendwann auf folgendes Pattern:
«Pattern: Der oberste Resolver löst (rekursiv) die ganze GraphQL-Query auf (ausser vielleicht Aufrufe an externe APIs).»
Sind deine API-Anforderungen auf diesem Level angekommen? Willkommen im Club. Du implementierst gerade einen allmächtigen Root Resolver.
const resolvers = {
Query: {
books: () => { /* get them books plus any related data needed, recursively! */ },
},
};Um so einen Resolver zu bauen, musst du die Innereien von Apollo und die Auflösung von GraphQL-Queries viel genauer verstehen. Genau das schauen wir uns in dieser Artikelserie im Detail an (mit besonderem Fokus auf die Generierung von MySQL-Queries). Merk dir fürs Erste: Du bist damit nicht allein, und dieses Pattern hat jetzt einen Namen.
GraphQL-Applikationen auf Enterprise-Niveau bauen
Du brauchst ein Expert*innen-Team für deine anspruchsvolle Webapplikation? Wirf einen Blick in unser Portfolio. Bei smartive bauen wir komplexe Webapplikationen. Zu Hause sind wir in Zürich, Schweiz.

Geschrieben von
Nicola Marcacci Rossi
Ähnliche Challenge auf dem Tisch? Lass uns drüber reden.





