claudient 0.1.0

package/skills/backend/go/nl/go.md

@@ -0,0 +1,307 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../go.md).
+
+# Go Skill
+
+## Wanneer te activeren
+- Een Go HTTP-service of CLI-tool bouwen
+- Een Go-project structureren met `cmd/`, `internal/`, `pkg/`
+- HTTP-handlers schrijven met `net/http`, chi of gin
+- Interfaces, embedding en compositiepatronen implementeren
+- Gelijktijdige code schrijven met goroutines, kanalen en `sync`-primitieven
+- Foutafhandeling, inpakking en sentinaelfouten
+- Tabelgestuurde tests schrijven
+
+## Wanneer NIET te gebruiken
+- Node.js-, Python- of andere taalservices — andere ecosystemen
+- Protobuf/gRPC-services zonder voorafgaande gRPC-context
+- Pure scripttaken — shell of Python passen beter
+
+## Instructies
+
+### Projectindeling
+```
+myapp/
+├── cmd/
+│   └── server/
+│       └── main.go         # Ingangspunt — slank, bedraadt en start alleen
+├── internal/               # Private packages — niet van buitenaf importeerbaar
+│   ├── config/
+│   ├── handler/
+│   ├── service/
+│   └── store/
+├── pkg/                    # Publieke packages — importeerbaar door andere modules
+│   └── apierr/
+├── go.mod
+└── go.sum
+```
+
+### main.go — alleen bedrading
+```go
+// cmd/server/main.go
+package main
+
+import (
+    "context"
+    "log/slog"
+    "net/http"
+    "os"
+    "os/signal"
+    "syscall"
+    "time"
+
+    "myapp/internal/config"
+    "myapp/internal/handler"
+    "myapp/internal/store"
+)
+
+func main() {
+    cfg := config.MustLoad()
+    db := store.MustConnect(cfg.DatabaseURL)
+    defer db.Close()
+
+    mux := handler.NewMux(db, cfg)
+
+    srv := &http.Server{
+        Addr:         ":" + cfg.Port,
+        Handler:      mux,
+        ReadTimeout:  10 * time.Second,
+        WriteTimeout: 30 * time.Second,
+        IdleTimeout:  60 * time.Second,
+    }
+
+    go func() {
+        slog.Info("server starting", "addr", srv.Addr)
+        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
+            slog.Error("server error", "err", err)
+            os.Exit(1)
+        }
+    }()
+
+    quit := make(chan os.Signal, 1)
+    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+    <-quit
+
+    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+    defer cancel()
+    srv.Shutdown(ctx)
+}
+```
+
+### Foutafhandeling
+```go
+// Definieer sentinaelfouten voor verwachte omstandigheden
+var (
+    ErrNotFound   = errors.New("not found")
+    ErrDuplicate  = errors.New("duplicate entry")
+    ErrForbidden  = errors.New("forbidden")
+)
+
+// Wikkel fouten in met context — gebruik %w om uitpakken te behouden
+func (s *UserStore) GetByID(ctx context.Context, id string) (*User, error) {
+    var u User
+    err := s.db.QueryRowContext(ctx, `SELECT id, email FROM users WHERE id = $1`, id).
+        Scan(&u.ID, &u.Email)
+    if errors.Is(err, sql.ErrNoRows) {
+        return nil, fmt.Errorf("user %s: %w", id, ErrNotFound)
+    }
+    if err != nil {
+        return nil, fmt.Errorf("user store get: %w", err)
+    }
+    return &u, nil
+}
+
+// Aanroeper controleert gedrag, niet berichtstrings
+user, err := store.GetByID(ctx, id)
+if errors.Is(err, ErrNotFound) {
+    http.Error(w, "not found", http.StatusNotFound)
+    return
+}
+```
+
+### HTTP-handlers met chi
+```go
+// internal/handler/users.go
+type UserHandler struct {
+    svc UserService
+}
+
+func (h *UserHandler) Register(r chi.Router) {
+    r.Get("/users/{id}", h.GetUser)
+    r.Post("/users", h.CreateUser)
+}
+
+func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
+    id := chi.URLParam(r, "id")
+    user, err := h.svc.GetUser(r.Context(), id)
+    if err != nil {
+        renderError(w, err)
+        return
+    }
+    renderJSON(w, http.StatusOK, user)
+}
+
+func renderJSON(w http.ResponseWriter, code int, v any) {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(code)
+    json.NewEncoder(w).Encode(v)
+}
+
+func renderError(w http.ResponseWriter, err error) {
+    switch {
+    case errors.Is(err, ErrNotFound):
+        http.Error(w, "not found", http.StatusNotFound)
+    case errors.Is(err, ErrForbidden):
+        http.Error(w, "forbidden", http.StatusForbidden)
+    default:
+        slog.Error("internal error", "err", err)
+        http.Error(w, "internal server error", http.StatusInternalServerError)
+    }
+}
+```
+
+### Interfaces
+```go
+// Definieer interfaces waar ze worden gebruikt (consumerkant), niet waar geïmplementeerd
+// internal/handler/users.go
+type UserService interface {
+    GetUser(ctx context.Context, id string) (*User, error)
+    CreateUser(ctx context.Context, req CreateUserRequest) (*User, error)
+}
+
+// Houd interfaces klein — 1-3 methoden voorkeur
+// io.Reader, io.Writer zijn de canonieke voorbeelden
+
+// Embedding voor compositie
+type ReadWriter interface {
+    io.Reader
+    io.Writer
+}
+```
+
+### Gelijktijdigheidspatronen
+```go
+// Fan-out met errgroup
+import "golang.org/x/sync/errgroup"
+
+func fetchAll(ctx context.Context, ids []string) ([]*User, error) {
+    g, ctx := errgroup.WithContext(ctx)
+    results := make([]*User, len(ids))
+
+    for i, id := range ids {
+        i, id := i, id // vang loopvariabelen
+        g.Go(func() error {
+            u, err := store.GetByID(ctx, id)
+            if err != nil {
+                return err
+            }
+            results[i] = u
+            return nil
+        })
+    }
+
+    if err := g.Wait(); err != nil {
+        return nil, err
+    }
+    return results, nil
+}
+
+// Worker-pool
+func processJobs(ctx context.Context, jobs <-chan Job) {
+    const workers = 10
+    var wg sync.WaitGroup
+    for range workers {
+        wg.Add(1)
+        go func() {
+            defer wg.Done()
+            for job := range jobs {
+                if err := process(ctx, job); err != nil {
+                    slog.Error("job failed", "id", job.ID, "err", err)
+                }
+            }
+        }()
+    }
+    wg.Wait()
+}
+```
+
+### Contextpropagatie
+```go
+// Geef context altijd door als eerste argument
+func (s *Service) DoWork(ctx context.Context, id string) error {
+    // Geef ctx door aan alle downstream-aanroepen
+    user, err := s.store.GetByID(ctx, id)
+    if err != nil {
+        return err
+    }
+    return s.notifier.Send(ctx, user.Email)
+}
+
+// Sla aanvraag-scoped waarden op in context alleen voor cross-cutting concerns
+// (trace-ID's, auth-info) — nooit voor optionele functieparameters
+type contextKey string
+const requestIDKey contextKey = "request_id"
+
+func WithRequestID(ctx context.Context, id string) context.Context {
+    return context.WithValue(ctx, requestIDKey, id)
+}
+func GetRequestID(ctx context.Context) string {
+    id, _ := ctx.Value(requestIDKey).(string)
+    return id
+}
+```
+
+### Tabelgestuurde tests
+```go
+func TestGetUser(t *testing.T) {
+    tests := []struct {
+        name    string
+        id      string
+        want    *User
+        wantErr error
+    }{
+        {"found", "123", &User{ID: "123", Email: "a@b.com"}, nil},
+        {"not found", "999", nil, ErrNotFound},
+        {"empty id", "", nil, ErrNotFound},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            svc := newTestService(t)
+            got, err := svc.GetUser(context.Background(), tt.id)
+            if !errors.Is(err, tt.wantErr) {
+                t.Fatalf("err = %v, want %v", err, tt.wantErr)
+            }
+            if diff := cmp.Diff(tt.want, got); diff != "" {
+                t.Errorf("mismatch (-want +got):\n%s", diff)
+            }
+        })
+    }
+}
+```
+
+### Loggen met slog
+```go
+// Gestructureerde logging — nooit fmt.Println in productiecode
+slog.Info("request completed", "method", r.Method, "path", r.URL.Path, "status", 200, "duration_ms", elapsed.Milliseconds())
+slog.Error("db query failed", "query", "getUserByID", "err", err)
+
+// JSON-logger instellen in main
+logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+    Level: slog.LevelInfo,
+}))
+slog.SetDefault(logger)
+```
+
+## Voorbeeld
+
+**Gebruiker:** Bouw een Go HTTP API voor een takenlijst: aanmaken, ophalen en voltooien van taken. PostgreSQL-backend, chi-router, gestructureerde logging, gracieuze afsluiting.
+
+**Verwachte output:**
+- `cmd/server/main.go` — bedraadt store, handler, start server met gracieuze afsluiting
+- `internal/store/task.go` — `TaskStore` met `Create`-, `List`-, `Complete`-methoden via `database/sql`
+- `internal/handler/tasks.go` — `TaskHandler` met `Register(r chi.Router)`, JSON-antwoorden
+- `internal/handler/tasks_test.go` — tabelgestuurde tests met een mock-store
+
+---
+
+> **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/nodejs/de/nestjs.md

@@ -0,0 +1,274 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../nestjs.md).
+
+# NestJS Skill
+
+## Wann aktivieren
+- Eine NestJS-Anwendung bauen (Module, Controller, Services)
+- Guards, Interceptors, Pipes und Exception Filter einrichten
+- TypeORM oder Prisma mit NestJS integrieren
+- CQRS mit Commands, Queries und Events implementieren
+- Microservices einrichten (TCP-, Redis-, RabbitMQ-Transport)
+- Unit- und E2E-Tests mit Jest und Supertest schreiben
+- OpenAPI-Docs mit `@nestjs/swagger` generieren
+
+## Wann NICHT verwenden
+- Next.js API-Routes oder eigenständiges Fastify — anderes Framework
+- Einfache Express-Skripte — NestJS-Overhead nicht gerechtfertigt
+- Lambda-Funktionen, bei denen die Kaltstart-Zeit kritisch ist
+
+## Anweisungen
+
+### Modulstruktur
+```
+src/
+├── app.module.ts           # Root-Modul
+├── main.ts                 # Bootstrap
+├── common/
+│   ├── decorators/
+│   ├── filters/
+│   ├── guards/
+│   ├── interceptors/
+│   └── pipes/
+├── config/
+│   └── configuration.ts   # ConfigService-Setup
+└── modules/
+    └── users/
+        ├── users.module.ts
+        ├── users.controller.ts
+        ├── users.service.ts
+        ├── dto/
+        │   ├── create-user.dto.ts
+        │   └── update-user.dto.ts
+        ├── entities/
+        │   └── user.entity.ts
+        └── users.service.spec.ts
+```
+
+### Bootstrap
+```ts
+// main.ts
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module'
+import { ValidationPipe } from '@nestjs/common'
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger'
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule)
+
+  app.useGlobalPipes(new ValidationPipe({
+    whitelist: true,       // unbekannte Felder entfernen
+    forbidNonWhitelisted: true,
+    transform: true,       // Payloads automatisch in DTO-Klassen umwandeln
+  }))
+
+  const config = new DocumentBuilder()
+    .setTitle('API')
+    .setVersion('1.0')
+    .addBearerAuth()
+    .build()
+  SwaggerModule.setup('docs', app, SwaggerModule.createDocument(app, config))
+
+  await app.listen(3000)
+}
+bootstrap()
+```
+
+### Modul, Controller, Service
+```ts
+// users.module.ts
+@Module({
+  imports: [TypeOrmModule.forFeature([User]), JwtModule.register({})],
+  controllers: [UsersController],
+  providers: [UsersService],
+  exports: [UsersService],
+})
+export class UsersModule {}
+
+// users.controller.ts
+@ApiTags('users')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('users')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  create(@Body() dto: CreateUserDto): Promise<UserResponseDto> {
+    return this.usersService.create(dto)
+  }
+
+  @Get(':id')
+  findOne(@Param('id', ParseUUIDPipe) id: string): Promise<UserResponseDto> {
+    return this.usersService.findOneOrFail(id)
+  }
+}
+
+// users.service.ts
+@Injectable()
+export class UsersService {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepo: Repository<User>,
+  ) {}
+
+  async create(dto: CreateUserDto): Promise<User> {
+    const exists = await this.userRepo.findOneBy({ email: dto.email })
+    if (exists) throw new ConflictException('Email already in use')
+    const user = this.userRepo.create({
+      ...dto,
+      password: await bcrypt.hash(dto.password, 10),
+    })
+    return this.userRepo.save(user)
+  }
+
+  async findOneOrFail(id: string): Promise<User> {
+    const user = await this.userRepo.findOneBy({ id })
+    if (!user) throw new NotFoundException(`User ${id} not found`)
+    return user
+  }
+}
+```
+
+### DTOs mit class-validator
+```ts
+// dto/create-user.dto.ts
+import { IsEmail, IsString, MinLength, IsOptional } from 'class-validator'
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger'
+
+export class CreateUserDto {
+  @ApiProperty({ example: 'user@example.com' })
+  @IsEmail()
+  email: string
+
+  @ApiProperty({ minLength: 8 })
+  @IsString()
+  @MinLength(8)
+  password: string
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  name?: string
+}
+```
+
+### Guards
+```ts
+// common/guards/jwt-auth.guard.ts
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+  handleRequest<T>(err: Error, user: T, info: Error): T {
+    if (err || !user) {
+      throw err || new UnauthorizedException(info?.message)
+    }
+    return user
+  }
+}
+
+// common/guards/roles.guard.ts
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(private reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const roles = this.reflector.getAllAndOverride<Role[]>('roles', [
+      context.getHandler(),
+      context.getClass(),
+    ])
+    if (!roles) return true
+    const { user } = context.switchToHttp().getRequest()
+    return roles.some(role => user.roles?.includes(role))
+  }
+}
+```
+
+### Interceptors
+```ts
+// common/interceptors/transform.interceptor.ts
+@Injectable()
+export class TransformInterceptor<T>
+  implements NestInterceptor<T, { data: T; timestamp: string }>
+{
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(
+      map(data => ({ data, timestamp: new Date().toISOString() }))
+    )
+  }
+}
+```
+
+### CQRS
+```ts
+// Installation: @nestjs/cqrs
+
+// commands/create-user.command.ts
+export class CreateUserCommand {
+  constructor(public readonly dto: CreateUserDto) {}
+}
+
+// commands/create-user.handler.ts
+@CommandHandler(CreateUserCommand)
+export class CreateUserHandler implements ICommandHandler<CreateUserCommand> {
+  constructor(private readonly userRepo: UserRepository) {}
+
+  async execute(command: CreateUserCommand): Promise<User> {
+    const user = User.create(command.dto)
+    await this.userRepo.save(user)
+    return user
+  }
+}
+
+// Im Service/Controller:
+const user = await this.commandBus.execute(new CreateUserCommand(dto))
+```
+
+### Tests
+```ts
+// Unit-Test
+describe('UsersService', () => {
+  let service: UsersService
+  let repo: jest.Mocked<Repository<User>>
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      providers: [
+        UsersService,
+        { provide: getRepositoryToken(User), useValue: createMockRepository() },
+      ],
+    }).compile()
+    service = module.get(UsersService)
+    repo = module.get(getRepositoryToken(User))
+  })
+
+  it('throws ConflictException for duplicate email', async () => {
+    repo.findOneBy.mockResolvedValue(existingUser)
+    await expect(service.create(dto)).rejects.toThrow(ConflictException)
+  })
+})
+
+// E2E-Test
+describe('POST /users', () => {
+  it('creates a user', () => {
+    return request(app.getHttpServer())
+      .post('/users')
+      .send({ email: 'a@b.com', password: 'password123' })
+      .expect(201)
+  })
+})
+```
+
+## Beispiel
+
+**Benutzer:** Ein `Products`-Modul zu einer NestJS-App mit TypeORM hinzufügen, einschließlich CRUD-Endpunkte, nur-Admin-Löschen durch einen `RolesGuard` geschützt, und OpenAPI-Docs.
+
+**Erwartete Ausgabe:**
+- `products.entity.ts` — TypeORM-Entity mit `id` (UUID), `name`, `price` (decimal), `stock`, `createdAt`
+- `dto/create-product.dto.ts` — class-validator DTO mit `@ApiProperty`-Dekoratoren
+- `products.service.ts` — CRUD-Methoden mit `Repository<Product>`, `NotFoundException` bei fehlendem Element
+- `products.controller.ts` — alle CRUD-Endpunkte, `@UseGuards(JwtAuthGuard, RolesGuard)` + `@Roles(Role.Admin)` bei `DELETE`
+- `products.module.ts` — importiert `TypeOrmModule.forFeature([Product])`
+
+---
+
+> **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/)