claudient 0.1.0

package/skills/backend/nodejs/nl/nextjs.md

@@ -0,0 +1,222 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../nextjs.md).
+
+# Next.js Skill
+
+## Wanneer te activeren
+- Een Next.js-applicatie bouwen met de App Router
+- Kiezen tussen Server Components en Client Components
+- Server Actions schrijven voor formulierinzendingen en mutaties
+- Route handlers instellen (API-endpoints in App Router)
+- Authenticatie implementeren met NextAuth of een JWT-patroon
+- Middleware configureren voor redirects en auth-guards
+- Datafetching optimaliseren met React `cache()` en `unstable_cache`
+- Parallelle routes, onderscheppende routes of routegroepen gebruiken
+
+## Wanneer NIET te gebruiken
+- Pages Router-projecten — de patronen verschillen aanzienlijk
+- Pure SPA's zonder server-rendering (gebruik Vite + React)
+- NestJS of Express backends — gebruik de NestJS skill
+- Statische sites zonder dynamische data (gebruik Astro)
+
+## Instructies
+
+### App Router-directorystructuur
+```
+app/
+├── (auth)/              # Routegroep — geen URL-segment
+│   ├── login/
+│   │   └── page.tsx
+│   └── layout.tsx       # Auth-specifieke layout
+├── (dashboard)/
+│   ├── dashboard/
+│   │   ├── page.tsx     # Server Component standaard
+│   │   └── loading.tsx  # Suspense-grens UI
+│   └── layout.tsx
+├── api/
+│   └── webhooks/
+│       └── stripe/
+│           └── route.ts # Route Handler
+├── layout.tsx           # Root layout (vereist)
+└── page.tsx             # Startpagina
+components/
+├── ui/                  # Presentationeel (kan server of client zijn)
+└── forms/               # Altijd client components (useState/events)
+lib/
+├── auth.ts
+├── db.ts
+└── actions/             # Server Actions
+    └── user.ts
+```
+
+### Server vs. Client Components
+```tsx
+// Server Component (standaard) — draait op server, wordt nooit naar client gestuurd
+// Kan: await fetch, DB lezen, omgevingsvariabelen benaderen
+// Kan niet: useState, useEffect, browser API's, event handlers
+export default async function UserProfile({ id }: { id: string }) {
+  const user = await db.user.findUnique({ where: { id } })
+  return <div>{user.name}</div>
+}
+
+// Client Component — voeg 'use client'-directive toe
+'use client'
+import { useState } from 'react'
+
+export function LikeButton({ initialCount }: { initialCount: number }) {
+  const [count, setCount] = useState(initialCount)
+  return <button onClick={() => setCount(c => c + 1)}>{count} likes</button>
+}
+```
+
+Regel: gebruik standaard Server Components. Voeg `'use client'` alleen toe wanneer je interactiviteit, browser API's of React hooks nodig hebt.
+
+### Datafetchingpatronen
+```tsx
+// Server Component — directe async/await, geen useEffect, geen useState
+export default async function PostList() {
+  const posts = await db.post.findMany({ where: { published: true } })
+  return <ul>{posts.map(p => <li key={p.id}>{p.title}</li>)}</ul>
+}
+
+// Deduplicatie — React cache() wikkelt een functie zodat meerdere components
+// die het in één render aanroepen één fetch delen
+import { cache } from 'react'
+export const getUser = cache(async (id: string) => {
+  return db.user.findUnique({ where: { id } })
+})
+
+// Statische generatie met revalidatie
+async function getProducts() {
+  const res = await fetch('https://api.example.com/products', {
+    next: { revalidate: 3600 }, // ISR — elke uur revalideren
+  })
+  return res.json()
+}
+```
+
+### Server Actions
+```tsx
+// lib/actions/user.ts
+'use server'
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+
+const UpdateSchema = z.object({
+  name: z.string().min(1),
+})
+
+export async function updateUser(formData: FormData) {
+  const parsed = UpdateSchema.safeParse({ name: formData.get('name') })
+  if (!parsed.success) return { error: parsed.error.flatten() }
+
+  await db.user.update({ where: { id: getCurrentUserId() }, data: parsed.data })
+  revalidatePath('/dashboard/profile')
+  return { success: true }
+}
+
+// In een Server Component:
+export default function ProfileForm({ user }: { user: User }) {
+  return (
+    <form action={updateUser}>
+      <input name="name" defaultValue={user.name} />
+      <button type="submit">Opslaan</button>
+    </form>
+  )
+}
+```
+
+### Route Handlers
+```ts
+// app/api/webhooks/stripe/route.ts
+import { NextRequest, NextResponse } from 'next/server'
+import Stripe from 'stripe'
+
+export async function POST(req: NextRequest) {
+  const body = await req.text()
+  const sig = req.headers.get('stripe-signature')!
+
+  let event: Stripe.Event
+  try {
+    event = stripe.webhooks.constructEvent(body, sig, process.env.STRIPE_WEBHOOK_SECRET!)
+  } catch {
+    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 })
+  }
+
+  if (event.type === 'checkout.session.completed') {
+    await handleCheckoutCompleted(event.data.object)
+  }
+
+  return NextResponse.json({ received: true })
+}
+```
+
+### Middleware
+```ts
+// middleware.ts (root-niveau)
+import { NextResponse } from 'next/server'
+import type { NextRequest } from 'next/server'
+
+export function middleware(request: NextRequest) {
+  const token = request.cookies.get('auth-token')
+  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
+    return NextResponse.redirect(new URL('/login', request.url))
+  }
+  return NextResponse.next()
+}
+
+export const config = {
+  matcher: ['/dashboard/:path*', '/api/protected/:path*'],
+}
+```
+
+### Parallelle en onderscheppende routes
+```
+app/
+├── @modal/          # Parallelle route — geeft naast hoofdinhoud weer
+│   └── (.)photo/    # Onderscheppende route — onderschept /photo/[id]
+│       └── [id]/
+│           └── page.tsx
+├── photo/
+│   └── [id]/
+│       └── page.tsx
+└── layout.tsx       # Accepteert { children, modal } als props
+```
+
+### Fout- en laadgrenzen
+```tsx
+// app/dashboard/loading.tsx — getoond tijdens Suspense
+export default function Loading() {
+  return <DashboardSkeleton />
+}
+
+// app/dashboard/error.tsx — foutgrens voor dit segment
+'use client'
+export default function Error({ error, reset }: { error: Error; reset: () => void }) {
+  return (
+    <div>
+      <p>{error.message}</p>
+      <button onClick={reset}>Opnieuw proberen</button>
+    </div>
+  )
+}
+```
+
+### Omgevingsvariabelen
+- `NEXT_PUBLIC_*` — blootgesteld aan de browser
+- Alle andere — alleen server (nooit toegankelijk in Client Components)
+- Importeer nooit een alleen-server omgevingsvariabele in een Client Component — het retourneert stilletjes `undefined`
+
+## Voorbeeld
+
+**Gebruiker:** Voeg een gepagineerde blogberichtenpagina toe op `/blog` die ophaalt vanuit PostgreSQL, met een "Nieuw bericht"-modal die opent op `/blog/new` maar niet wegnavigeert van de berichtenlijst.
+
+**Verwachte output:**
+- `app/blog/page.tsx` — Server Component, haalt berichten op met `db.post.findMany`, geeft `<PostList>` + `<Link href="/blog/new">` weer
+- `app/@modal/(.)blog/new/page.tsx` — Onderscheppende route die een `<NewPostModal>` Client Component toont
+- `app/blog/new/page.tsx` — Volledige paginafallback voor directe navigatie
+- `app/layout.tsx` — Bijgewerkt om `modal`-parallelle routesleuf te accepteren en naast `children` weer te geven
+- `lib/actions/post.ts` — `createPost` Server Action met Zod-validatie + `revalidatePath('/blog')`
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)

package/skills/backend/python/de/django.md

@@ -0,0 +1,285 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../django.md).
+
+# Django Skill
+
+## Wann aktivieren
+- Ein Django-Projekt mit ORM-Modellen, Migrationen und Views aufbauen
+- Django REST Framework (DRF) Serializer, Viewsets und Router einrichten
+- Benutzerdefinierte Modell-Manager oder QuerySet-Methoden schreiben
+- Django-Signale für entkoppelte Nebeneffekte verwenden
+- Celery für asynchrone Aufgaben in einem Django-Projekt einrichten
+- Das Django-Admin anpassen
+- Tests mit `django.test.TestCase` oder `pytest-django` schreiben
+
+## Wann NICHT verwenden
+- Async-first APIs — stattdessen FastAPI Skill verwenden
+- Microservices, die Django's ORM oder Admin nicht benötigen
+- Einfache Skripte oder CLIs — einfaches Python oder Typer
+- Wenn das Projekt bereits FastAPI oder Flask verwendet
+
+## Anweisungen
+
+### Projekt-Layout
+```
+project_name/
+├── manage.py
+├── config/
+│   ├── settings/
+│   │   ├── base.py
+│   │   ├── development.py
+│   │   └── production.py
+│   ├── urls.py
+│   └── wsgi.py
+├── apps/
+│   └── users/
+│       ├── models.py
+│       ├── serializers.py
+│       ├── views.py
+│       ├── urls.py
+│       ├── admin.py
+│       ├── managers.py
+│       └── tests/
+└── requirements/
+    ├── base.txt
+    ├── development.txt
+    └── production.txt
+```
+
+### Einstellungen aufteilen
+```python
+# config/settings/base.py
+from pathlib import Path
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "rest_framework",
+    "apps.users",
+]
+
+AUTH_USER_MODEL = "users.User"  # Immer von Anfang an ein benutzerdefiniertes User-Modell setzen
+
+# config/settings/production.py
+from .base import *
+DEBUG = False
+ALLOWED_HOSTS = env.list("ALLOWED_HOSTS")
+DATABASES = {"default": env.db("DATABASE_URL")}
+```
+
+### Benutzerdefiniertes User-Modell
+```python
+# apps/users/models.py — vor der ersten Migration einrichten, danach nie mehr ändern
+from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
+from django.db import models
+from .managers import UserManager
+
+class User(AbstractBaseUser, PermissionsMixin):
+    email = models.EmailField(unique=True)
+    is_staff = models.BooleanField(default=False)
+    is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = []
+    objects = UserManager()
+```
+
+### Benutzerdefinierter Manager
+```python
+# apps/users/managers.py
+from django.contrib.auth.base_user import BaseUserManager
+
+class UserManager(BaseUserManager):
+    def create_user(self, email: str, password: str, **extra_fields):
+        if not email:
+            raise ValueError("Email is required")
+        email = self.normalize_email(email)
+        user = self.model(email=email, **extra_fields)
+        user.set_password(password)
+        user.save()
+        return user
+
+    def create_superuser(self, email: str, password: str, **extra_fields):
+        extra_fields.setdefault("is_staff", True)
+        extra_fields.setdefault("is_superuser", True)
+        return self.create_user(email, password, **extra_fields)
+
+    def active(self):
+        return self.get_queryset().filter(is_active=True)
+```
+
+### DRF-Serializer
+```python
+# apps/users/serializers.py
+from rest_framework import serializers
+from .models import User
+
+class UserCreateSerializer(serializers.ModelSerializer):
+    password = serializers.CharField(write_only=True, min_length=8)
+
+    class Meta:
+        model = User
+        fields = ["id", "email", "password"]
+
+    def create(self, validated_data: dict) -> User:
+        return User.objects.create_user(**validated_data)
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ["id", "email", "created_at"]
+        read_only_fields = ["id", "created_at"]
+```
+
+### DRF-ViewSets
+```python
+# apps/users/views.py
+from rest_framework import viewsets, permissions, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from .models import User
+from .serializers import UserSerializer, UserCreateSerializer
+
+class UserViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.active()
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_serializer_class(self):
+        if self.action == "create":
+            return UserCreateSerializer
+        return UserSerializer
+
+    def get_permissions(self):
+        if self.action == "create":
+            return [permissions.AllowAny()]
+        return super().get_permissions()
+
+    @action(detail=False, methods=["get"])
+    def me(self, request):
+        return Response(UserSerializer(request.user).data)
+```
+
+### Router-Setup
+```python
+# apps/users/urls.py
+from rest_framework.routers import DefaultRouter
+from .views import UserViewSet
+
+router = DefaultRouter()
+router.register("users", UserViewSet, basename="user")
+urlpatterns = router.urls
+```
+
+### Signale
+```python
+# apps/users/signals.py — Signale nur für wirklich entkoppelte Nebeneffekte verwenden
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from .models import User
+
+@receiver(post_save, sender=User)
+def send_welcome_email(sender, instance: User, created: bool, **kwargs):
+    if created:
+        send_email_task.delay(instance.email, "welcome")
+
+# apps/users/apps.py
+class UsersConfig(AppConfig):
+    name = "apps.users"
+    def ready(self):
+        import apps.users.signals  # noqa: F401
+```
+
+### Celery
+```python
+# config/celery.py
+from celery import Celery
+import os
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings.production")
+app = Celery("project_name")
+app.config_from_object("django.conf:settings", namespace="CELERY")
+app.autodiscover_tasks()
+
+# apps/users/tasks.py
+from config.celery import app
+
+@app.task(bind=True, max_retries=3)
+def send_email_task(self, to_email: str, template: str):
+    try:
+        # E-Mail senden
+        pass
+    except Exception as exc:
+        raise self.retry(exc=exc, countdown=60)
+```
+
+### Admin-Anpassung
+```python
+# apps/users/admin.py
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from .models import User
+
+@admin.register(User)
+class UserAdmin(BaseUserAdmin):
+    list_display = ["email", "is_active", "is_staff", "created_at"]
+    list_filter = ["is_active", "is_staff"]
+    search_fields = ["email"]
+    ordering = ["-created_at"]
+    fieldsets = (
+        (None, {"fields": ("email", "password")}),
+        ("Permissions", {"fields": ("is_active", "is_staff", "is_superuser", "groups")}),
+    )
+    add_fieldsets = (
+        (None, {"fields": ("email", "password1", "password2")}),
+    )
+```
+
+### QuerySet-Optimierung
+```python
+# Immer select_related für FK-Felder, prefetch_related für M2M/Reverse FK
+posts = Post.objects.select_related("author").prefetch_related("tags").filter(published=True)
+
+# only() oder defer() für große Modelle verwenden, wenn nur bestimmte Felder benötigt werden
+emails = User.objects.filter(is_active=True).only("email")
+
+# values() für schreibgeschützte Aggregationen verwenden — überspringt ORM-Objektkonstruktion
+counts = Order.objects.values("status").annotate(count=Count("id"))
+```
+
+### Tests
+```python
+# pytest-django-Stil
+import pytest
+from rest_framework.test import APIClient
+
+@pytest.fixture
+def api_client():
+    return APIClient()
+
+@pytest.fixture
+def authenticated_client(api_client, user):
+    api_client.force_authenticate(user=user)
+    return api_client
+
+@pytest.mark.django_db
+def test_create_user(api_client):
+    resp = api_client.post("/api/users/", {"email": "a@b.com", "password": "strongpass"})
+    assert resp.status_code == 201
+    assert resp.data["email"] == "a@b.com"
+```
+
+## Beispiel
+
+**Benutzer:** Ein `Post`-Modell zu einem Django-Projekt mit DRF hinzufügen, einschließlich Listen-/Erstell-/Abruf-Endpunkte, paginierte Ergebnisse und Filter nach `published=True`.
+
+**Erwartete Ausgabe:**
+- `models.py` — `Post` mit `title`, `body`, `author` (FK zu User), `published`, `created_at`
+- `serializers.py` — `PostSerializer` mit schreibgeschütztem `author` (verschachtelt), beschreibbarem `title`/`body`/`published`
+- `views.py` — `PostViewSet` mit `queryset` gefiltert auf `published=True` für nicht authentifizierte Benutzer, `IsAuthenticatedOrReadOnly`-Berechtigung, `PageNumberPagination`
+- `urls.py` — Router registriert bei `/api/posts/`
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)