Ontwerp een Basis GraphQL Schema met Authenticatie en Autorisatie
description
Met deze prompt kun je een veilig en overzichtelijk GraphQL schema maken dat gebruikersauthenticatie en rolgebaseerde toegangscontrole ondersteunt. Dit voorkomt onbevoegde toegang en maakt je API betrouwbaarder en professioneler in gebruik. Het is een praktische oplossing voor ontwikkelaars die basisbeveiliging willen integreren zonder complexe frameworks.
prompt
Help me een basis GraphQL schema te ontwerpen dat authenticatie- en autorisatiefuncties ondersteunt.
Authenticatie Methode: <voer de authenticatie methode in, bijvoorbeeld JWT, OAuth>
Gebruikersrollen: <beschrijf de gebruikersrollen die je wilt definiëren>
Toegangsregels per Ro ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een basis GraphQL-schema dat authenticatie via JWT en autorisatie op basis van rollen ondersteunt. Het schema bevat de benodigde types, query's en mutaties, en geeft een overzicht van toegangsregels per rol.
```graphql
# Types
enum Role {
ADMIN
USER
GUEST
}
type User {
id: ID!
username: String!
role: Role!
}
type AuthPayload {
token: String!
user: User!
}
# Input types
input CredentialsInput {
username: String!
password: String!
}
# Query's
type Query {
# Alleen toegankelijk voor ingelogde gebruikers
getUser(id: ID!): User @auth(role: ["ADMIN", "USER", "GUEST"])
listUsers: [User!] @auth(role: ["ADMIN", "USER", "GUEST"])
}
# Mutaties
type Mutation {
# Inloggen, retourneert een JWT token
login(credentials: CredentialsInput!): AuthPayload!
# Gebruiker kan eigen data bewerken
updateUser(id: ID!, username: String): User @auth(role: ["ADMIN", "USER"])
# Extra mutaties kunnen hier worden toegevoegd
}
# Directieven voor authenticatie en autorisatie
directive @auth(role: [Role!]!) on FIELD_DEFINITION
```
### Toelichting:
- **Authenticatie**: De `login` mutation geeft een JWT-token dat identificeert wie de gebruiker is. Dit token wordt meegegeven in de Authorization-header bij volgende API-aanroepen.
- **Autorisatie**: De `@auth` directive controleert of de gebruiker de juiste rol heeft voor een veld. Dit helpt bij het afdwingen van toegangsregels.
- **Rolgebaseerde toegang**:
- **ADMIN**: Kan alles doen.
- **USER**: Kan eigen data lezen en bewerken (bijvoorbeeld via `updateUser` voor hun eigen gegevens).
- **GUEST**: Kan alleen lezen, geen mutaties uitvoeren.
### Implementatietip:
- Voeg een middleware of resolver-logica toe die het JWT-token valideert en de gebruiker identificeert.
- Controleer op de `@auth` directive of de gebruiker de juiste rol heeft voordat je de operatie uitvoert.
Dit schema biedt een goede basis voor een veilige en gebruiksvriendelijke API met ingebouwde authenticatie en autorisatie.
provider: deepseek
model: deepseek-chat
Hier is een basis GraphQL schema met JWT-authenticatie en rolgebaseerde autorisatie:
```graphql
# Schema Definitie
type Query {
# Alleen ADMIN kan alle gebruikers opvragen
listUsers: [User!]! @auth(requires: ADMIN)
# USER kan alleen eigen data, ADMIN kan alles
getUser(id: ID!): User @auth(requires: USER)
# GUEST en hoger kunnen hun eigen profiel zien
getMyProfile: User @auth
}
type Mutation {
# Authenticatie zonder JWT vereist
login(username: String!, password: String!): AuthPayload!
# USER kan eigen data updaten, ADMIN kan alles
updateUser(id: ID!, username: String): User! @auth(requires: USER)
# Alleen ADMIN kan gebruikers aanmaken
createUser(username: String!, password: String!, role: UserRole!): User! @auth(requires: ADMIN)
# Vernieuw JWT token
refreshToken: AuthPayload! @auth
}
# Gebruikers Type
type User {
id: ID!
username: String!
role: UserRole!
createdAt: String!
}
# Authenticatie Response
type AuthPayload {
token: String!
refreshToken: String!
user: User!
}
# Gebruikersrollen Enum
enum UserRole {
ADMIN
USER
GUEST
}
# Directives voor Autorizatie
directive @auth(
requires: UserRole = GUEST
) on FIELD_DEFINITION
```
**Implementatie Richtlijnen:**
1. **JWT Authenticatie:**
- Token bevat `userId` en `role` in payload
- `login` mutation valideert credentials en retourneert JWT
- `refreshToken` mutation voor token vernieuwing
2. **Autorisatie Logica:**
```javascript
// Voorbeeld autorisatie middleware
const authMiddleware = (requiredRole) => (resolve, parent, args, context, info) => {
const user = context.user;
if (!user) throw new Error('Niet geauthenticeerd');
// Role hierarchy: ADMIN > USER > GUEST
const roleHierarchy = { GUEST: 0, USER: 1, ADMIN: 2 };
if (roleHierarchy[user.role] < roleHierarchy[requiredRole]) {
throw new Error('Onvoldoende rechten');
}
// USER mag alleen eigen data benaderen (behalve ADMIN)
if (user.role === 'USER' && args.id && args.id !== user.id) {
throw new Error('Geen toegang tot deze resource');
}
return resolve(parent, args, context, info);
};
```
3. **Context Setup:**
```javascript
const context = ({ req }) => {
const token = req.headers.authorization?.replace('Bearer ', '');
let user = null;
if (token) {
try {
user = jwt.verify(token, process.env.JWT_SECRET);
} catch (error) {
throw new Error('Ongeldig token');
}
}
return { user };
};
```
**Gebruiksvoorbeelden:**
```graphql
# Login
mutation {
login(username: "gebruiker", password: "wachtwoord") {
token
user {
id
username
role
}
}
}
# Eigen profiel ophalen (werkt voor alle rollen)
query {
getMyProfile {
id
username
role
}
}
# Gebruiker updaten (USER kan alleen eigen data)
mutation {
updateUser(id: "123", username: "nieuwe_naam") {
id
username
}
}
```
Dit schema biedt een solide basis met duidelijke toegangscontrole en eenvoudige integratie in je GraphQL API.