Zum Inhalt springen

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

Verschwommener Tunnel mit dynamischen Linien und dem in Blau und Weiß darübergelegten Text „GraphQL Teil 2“.

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.

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.

Ein Mann mit Brille, Bart und kurzen Haaren in einem marineblauen Button-Down-Hemd und khakifarbenen Hosen steht lächelnd vor einem blauen Hintergrund.

Geschrieben von
Nicola Marcacci Rossi

Technology|April 2019

Ähnliche Challenge auf dem Tisch? Lass uns drüber reden.

Weitere Artikel

© 2026 smartive AG