Ontwerp Basis GraphQL Resolvers voor Mijn Schema
description
Maakt het mogelijk voor gebruikers om hun GraphQL-schema's praktisch te implementeren door resolvers te schrijven, en overbrugt de kloof tussen schemaontwerp en functionele API. Biedt praktische begeleiding voor beginners om queries en mutaties aan data te koppelen, wat in bestaande prompts ontbreekt.
prompt
Help me bij het ontwerpen van basis GraphQL resolvers voor mijn schema met de volgende details:
Overzicht Schema: <beschrijf de hoofdtypen en velden in mijn GraphQL-schema>
Queries om te Resolveren: <noem de queries waarv ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een eenvoudig voorbeeld van hoe je basis GraphQL resolvers kunt opzetten voor jouw schema met mockdata:
```javascript
// Mock data
const boeken = [
{ id: '1', titel: 'De avonden', auteur: 'Gerard Reve' },
{ id: '2', titel: 'Het gouden ei', auteur: 'Tim Krabbé' },
];
// Resolvers
const resolvers = {
Query: {
haalBoekOp: (_, { id }) => {
return boeken.find(boek => boek.id === id);
},
},
Mutation: {
voegBoekToe: (_, { titel, auteur }) => {
const nieuwBoek = {
id: (boeken.length + 1).toString(),
titel,
auteur,
};
boeken.push(nieuwBoek);
return nieuwBoek;
},
},
Boek: {
// Als je extra velden hebt of resolvers nodig hebt, kun je die hier toevoegen
},
};
module.exports = resolvers;
```
**Uitleg:**
- `haalBoekOp`: zoekt een boek op basis van het gegeven `id` uit de mock data.
- `voegBoekToe`: voegt een nieuw boek toe aan de mock data en geeft het terug.
- Je kunt deze resolvers gebruiken met bijvoorbeeld Apollo Server of een andere GraphQL serverimplementatie.
Wil je nog hulp bij het opzetten van de server of het schema?
provider: deepseek
model: deepseek-chat
Hier zijn duidelijke en eenvoudige GraphQL resolvers voor jouw schema:
**1. Mock Data (tijdelijke testdata)**
```javascript
const mockBoeken = [
{ id: '1', titel: 'De Avond', auteur: 'Anna Janssen' },
{ id: '2', titel: 'Het Geheim', auteur: 'Peter de Vries' }
];
```
**2. Resolver Implementatie**
```javascript
const resolvers = {
Query: {
haalBoekOp: (parent, args, context, info) => {
// Zoek boek op ID in mock data
const boek = mockBoeken.find(boek => boek.id === args.id);
if (!boek) {
throw new Error(`Boek met ID ${args.id} niet gevonden`);
}
return boek;
}
},
Mutation: {
voegBoekToe: (parent, args, context, info) => {
// Genereer een nieuw ID (in productie zou dit door database komen)
const nieuwId = (mockBoeken.length + 1).toString();
// Maak nieuw boek object
const nieuwBoek = {
id: nieuwId,
titel: args.titel,
auteur: args.auteur
};
// Voeg toe aan mock data (in productie: database insert)
mockBoeken.push(nieuwBoek);
return nieuwBoek;
}
},
// Object type resolver (optioneel, maar goed voor consistentie)
Boek: {
id: (parent) => parent.id,
titel: (parent) => parent.titel,
auteur: (parent) => parent.auteur
}
};
```
**3. Database Integratie (voorbeeld voor echte database)**
```javascript
// Voor PostgreSQL met pg-library:
const { Pool } = require('pg');
const pool = new Pool();
const databaseResolvers = {
Query: {
haalBoekOp: async (parent, args) => {
const result = await pool.query(
'SELECT * FROM boeken WHERE id = $1',
[args.id]
);
return result.rows[0];
}
},
Mutation: {
voegBoekToe: async (parent, args) => {
const result = await pool.query(
'INSERT INTO boeken (titel, auteur) VALUES ($1, $2) RETURNING *',
[args.titel, args.auteur]
);
return result.rows[0];
}
}
};
```
**4. Gebruik in Apollo Server**
```javascript
const { ApolloServer } = require('apollo-server');
const typeDefs = require('./schema'); // jouw schema definitie
const server = new ApolloServer({
typeDefs,
resolvers, // gebruik hierboven gedefinieerde resolvers
context: () => {
// Eventuele context voor database connecties
}
});
```
**Belangrijke punten:**
- De resolvers volgen de structuur van je schema
- Error handling voor niet-gevonden boeken
- Eenvoudige mock data voor testdoeleinden
- Duidelijke scheiding tussen query en mutation resolvers
- Makkelijk uit te breiden naar echte database operaties
Voor productie gebruik je uiteraard echte database queries in plaats van mock data.