Begrijp en Implementeer Basis GraphQL Foutafhandeling
description
Met deze prompt leer je hoe je fouten in je GraphQL API effectief afhandelt, waardoor je API betrouwbaarder en gebruiksvriendelijker wordt. Je krijgt praktische voorbeelden die je helpen fouten duidelijk te communiceren naar gebruikers en ontwikkelaars. Dit voorkomt onduidelijke fouten en verbetert de stabiliteit van je applicatie.
prompt
Leg uit hoe ik basis GraphQL foutafhandeling kan implementeren in mijn API met de volgende details:
- Schema Overzicht: <beschrijf de hoofdtypen en velden in mijn GraphQL schema>
- Veelvoorkomende Fouten: <beschrijf de fouten die ik wil afh ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een uitleg over hoe je basis GraphQL-foutafhandeling kunt implementeren voor jouw API met het gegeven schema en de veelvoorkomende fouten.
**Stap 1: Gebruik van Error-Objecten in Resolvers**
In GraphQL kun je fouten teruggeven door een fout te gooien met behulp van JavaScript’s `throw new Error()`. Deze fouten worden automatisch door GraphQL opgevangen en weergegeven in de `errors`-array van de respons.
**Voorbeeld: Resolving met foutafhandeling**
```javascript
const resolvers = {
Query: {
getUser: (parent, args, context, info) => {
// Controleer of de gebruiker geauthenticeerd is
if (!context.user) {
throw new Error('Toegang geweigerd');
}
const user = getUserFromDatabase(args.id);
if (!user) {
throw new Error('Gebruiker niet gevonden');
}
return user;
}
},
Mutation: {
createUser: (parent, args, context, info) => {
const { name, email } = args;
// Controle op verplichte velden
if (!name || !email) {
throw new Error('Velden ontbreken');
}
// Validatie email
if (!validateEmail(email)) {
throw new Error('Ongeldige waarde voor email');
}
// Maak gebruiker aan
return createUserInDatabase({ name, email });
}
}
};
```
**Stap 2: Verbeter de foutmeldingen met `extensions`**
Om meer gestructureerde foutmeldingen te geven, kun je gebruik maken van de `extensions`-eigenschap in de fout. Dit is vooral handig voor het onderscheiden van verschillende fouttypes.
```javascript
const { GraphQLError } = require('graphql');
throw new GraphQLError('Velden ontbreken', {
extensions: {
code: 'BAD_USER_INPUT',
details: ['name', 'email']
}
});
```
**Stap 3: Implementatie in schema met `@deprecated` en validatie**
Je schema zelf bevat geen speciale foutafhandeling, maar je kunt in resolvers controlepunten toevoegen.
**Volledig voorbeeld schema:**
```graphql
type User {
id: ID!
name: String!
email: String!
}
type Query {
getUser(id: ID!): User
}
type Mutation {
createUser(name: String!, email: String!): User
}
```
**Stap 4: Globale foutafhandeling**
Je kunt ook middleware of een error handler instellen via je GraphQL-server (bijvoorbeeld Apollo Server) om alle fouten te loggen of te formatteren.
**Voorbeeld met Apollo Server:**
```javascript
const { ApolloServer } = require('apollo-server');
const server = new ApolloServer({
typeDefs,
resolvers,
formatError: (err) => {
// Hier kun je fouten formatteren of loggen
return {
message: err.message,
code: err.extensions?.code || 'INTERNAL_SERVER_ERROR',
details: err.extensions?.details || null
};
},
});
```
**Samenvatting:**
- Gebruik `throw new Error('foutmelding')` in resolvers voor eenvoudige foutafhandeling.
- Voor meer gestructureerde foutmeldingen, gebruik `GraphQLError` met `extensions`.
- Controleer op verplichte velden en geldigheid in je resolvers.
- Overweeg globale error handlers om consistentie en logging te verbeteren.
Met deze aanpak krijg je duidelijke en gestructureerde foutmeldingen, waardoor je API gebruiksvriendelijker wordt.
provider: deepseek
model: deepseek-chat
Zeker, ik leg uit hoe je basis GraphQL-foutafhandeling kunt implementeren in je API. Hier is een stapsgewijze handleiding met voorbeelden in het Nederlands.
---
### 1. Schema-definitie met foutafhandeling
Je kunt custom fouttypes toevoegen aan je schema voor betere structuur:
```graphql
type User {
id: ID!
name: String
email: String
}
type Error {
message: String!
code: String
}
type UserResult {
user: User
errors: [Error!]
}
type Query {
getUser(id: ID!): UserResult
}
type Mutation {
createUser(name: String!, email: String!): UserResult
updateUser(id: ID!, name: String, email: String): UserResult
}
```
---
### 2. Basis foutafhandeling in resolvers
**Voorbeeld met JavaScript/Node.js:**
```javascript
const resolvers = {
Query: {
getUser: async (_, { id }) => {
try {
// Simuleer database call
const user = await UserModel.findById(id);
if (!user) {
return {
user: null,
errors: [{ message: 'Gebruiker niet gevonden', code: 'NOT_FOUND' }]
};
}
return { user, errors: [] };
} catch (error) {
return {
user: null,
errors: [{ message: 'Serverfout', code: 'INTERNAL_ERROR' }]
};
}
}
},
Mutation: {
createUser: async (_, { name, email }) => {
const errors = [];
// Validatie: ontbrekende velden
if (!name || !email) {
errors.push({
message: 'Velden ontbreken: naam en email zijn verplicht',
code: 'MISSING_FIELDS'
});
}
// Validatie: ongeldige email
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (email && !emailRegex.test(email)) {
errors.push({
message: 'Ongeldig emailformaat',
code: 'INVALID_EMAIL'
});
}
if (errors.length > 0) {
return { user: null, errors };
}
try {
const user = await UserModel.create({ name, email });
return { user, errors: [] };
} catch (error) {
return {
user: null,
errors: [{ message: 'Kon gebruiker niet aanmaken', code: 'CREATION_FAILED' }]
};
}
}
}
};
```
---
### 3. Geavanceerde foutafhandeling met custom errors
```javascript
class ValidationError extends Error {
constructor(message, code) {
super(message);
this.code = code;
this.name = 'ValidationError';
}
}
class AuthenticationError extends Error {
constructor(message) {
super(message);
this.code = 'ACCESS_DENIED';
this.name = 'AuthenticationError';
}
}
// Gebruik in resolvers
const resolvers = {
Mutation: {
updateUser: async (_, { id, name, email }, context) => {
// Toegangscontrole
if (!context.user || context.user.id !== id) {
throw new AuthenticationError('Toegang geweigerd');
}
// Validatie
if (email && !isValidEmail(email)) {
throw new ValidationError('Ongeldige email', 'INVALID_EMAIL');
}
try {
const user = await UserModel.findByIdAndUpdate(
id,
{ name, email },
{ new: true }
);
return { user, errors: [] };
} catch (error) {
throw new Error('Databasefout bij bijwerken gebruiker');
}
}
}
};
// Error formatter voor GraphQL
const formatError = (error) => {
if (error.originalError instanceof ValidationError) {
return {
message: error.message,
code: error.originalError.code,
locations: error.locations,
path: error.path
};
}
if (error.originalError instanceof AuthenticationError) {
return {
message: error.message,
code: 'ACCESS_DENIED',
locations: error.locations,
path: error.path
};
}
// Generieke fouten
return {
message: 'Er is een fout opgetreden',
code: 'INTERNAL_ERROR',
locations: error.locations,
path: error.path
};
};
```
---
### 4. Client-side afhandeling
**Voorbeeld GraphQL query:**
```graphql
mutation CreateUser($name: String!, $email: String!) {
createUser(name: $name, email: $email) {
user {
id
name
email
}
errors {
message
code
}
}
}
```
---
### 5. Best practices voor foutafhandeling
1. **Consistente error codes**: Gebruik standaard error codes zoals:
- `VALIDATION_ERROR`
- `AUTHENTICATION_ERROR`
- `NOT_FOUND`
- `INTERNAL_ERROR`
2. **Duidelijke foutmeldingen**: Beschrijvende messages voor developers
3. **Field-level validatie**: Valideer individuele velden waar mogelijk
4. **Error logging**: Log errors voor debugging maar expose geen gevoelige data
5. **HTTP status codes**: Combineer met passende HTTP status codes (400, 401, 403, etc.)
---
### 6. Volledig voorbeeld validatie functie
```javascript
const validateUserInput = (input) => {
const errors = [];
if (!input.name?.trim()) {
errors.push({
field: 'name',
message: 'Naam is verplicht',
code: 'REQUIRED_FIELD'
});
}
if (!input.email?.trim()) {
errors.push({
field: 'email',
message: 'Email is verplicht',
code: 'REQUIRED_FIELD'
});
} else if (!isValidEmail(input.email)) {
errors.push({
field: 'email',
message: 'Ongeldig emailformaat',
code: 'INVALID_FORMAT'
});
}
return errors;
};
```
Deze aanpak zorgt voor robuuste foutafhandeling die zowel developer- als user-vriendelijke feedback geeft!