# Authentication & Authorization

## Übersicht

Der Middlelayer unterstützt JWT-basierte Authentication und Role-Based Access Control (RBAC).

## Features

- ✅ JWT-basierte Authentication
- ✅ Passwort-Hashing mit bcrypt
- ✅ Role-Based Access Control (Admin, Customer, Guest)
- ✅ Protected Resolvers
- ✅ User-Context in GraphQL Requests

## User-Rollen

- **ADMIN**: Vollzugriff auf alle Ressourcen
- **CUSTOMER**: Zugriff auf Kunden-spezifische Ressourcen
- **GUEST**: Nur öffentliche Ressourcen

## GraphQL Mutations

### Register

```graphql
mutation Register {
  register(email: "user@example.com", password: "secure123", name: "Max Mustermann") {
    user {
      id
      email
      name
      role
    }
    token
  }
}
```

### Login

```graphql
mutation Login {
  login(email: "user@example.com", password: "secure123") {
    user {
      id
      email
      name
      role
    }
    token
  }
}
```

## GraphQL Queries

### Aktueller User

```graphql
query Me {
  me {
    id
    email
    name
    role
  }
}
```

## Authorization in Resolvers

### Beispiel: Protected Resolver

```typescript
import { requireAuth, requireAdmin } from "./auth/authorization.js";

export const resolvers = {
  Query: {
    adminOnlyData: async (_: unknown, __: unknown, context: GraphQLContext) => {
      // Prüft ob User Admin ist
      requireAdmin(context.user);
      
      // Resolver-Logik...
    },
  },
};
```

### Verfügbare Authorization-Helper

- `requireAuth(user)` - Prüft ob User authentifiziert ist
- `requireRole(user, roles)` - Prüft ob User eine bestimmte Rolle hat
- `requireAdmin(user)` - Prüft ob User Admin ist
- `requireCustomer(user)` - Prüft ob User Customer oder Admin ist

## Verwendung im Frontend

### Token speichern

```typescript
// Nach Login/Register
const { token } = await login(email, password);
localStorage.setItem('authToken', token);
```

### Token in Requests verwenden

```typescript
const response = await fetch('http://localhost:4000', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${localStorage.getItem('authToken')}`,
  },
  body: JSON.stringify({ query, variables }),
});
```

## Konfiguration

### Environment Variables

```bash
JWT_SECRET=your-secret-key-change-in-production
JWT_EXPIRES_IN=7d  # Token-Gültigkeitsdauer
```

**Wichtig:** In Production muss `JWT_SECRET` sicher gesetzt werden!

## Security Best Practices

1. **JWT Secret**: Verwende einen starken, zufälligen Secret
2. **HTTPS**: Immer HTTPS in Production verwenden
3. **Token Expiration**: Setze angemessene Expiration-Zeiten
4. **Password Hashing**: Passwörter werden automatisch mit bcrypt gehasht
5. **Rate Limiting**: (Noch zu implementieren) Verhindere Brute-Force-Angriffe

## Mock User Store

Aktuell werden User in einem In-Memory Store gespeichert. Für Production sollte dies durch eine Datenbank ersetzt werden.

## Nächste Schritte

- [ ] Database-Integration für User-Speicherung
- [ ] Refresh Tokens
- [ ] Password Reset
- [ ] Email Verification
- [ ] Rate Limiting für Login/Register
- [ ] Session Management