# Plan: Implementera automatiserad datarensning för AiTrace

## Mål
Implementera en automatiserad rensning av gamla `AiTrace`-poster för att säkerställa att känsliga data inte lagras längre än nödvändigt och för att följa GDPR-krav.

## Bakgrund
- `AiTrace`-tabellen lagrar känsliga data (t.ex. maskerade promptar och AI-svar) utan någon retention-policy.
- Risk för att data ackumuleras obehindrat, vilket kan leda till lagringsproblem och GDPR-brott.
- Enligt GDPR bör känsliga data rensas efter en viss tid om de inte längre behövs för felsökning eller analys.

## Krav
1. Rensa `AiTrace`-poster äldre än 30 dagar.
2. Schemalägg rensningen att köra dagligen vid midnatt.
3. Logga antalet rensade poster för övervakning.
4. Säkerställa att rensningen inte påverkar systemets prestanda.

## Implementeringsplan

### Steg 1: Installera beroenden
Installera `NestJS Schedule`-modulen för att möjliggöra schemalagda jobb.

**Kommando:**
```bash
npm install @nestjs/schedule
```

### Steg 2: Konfigurera ScheduleModule
Lägg till `ScheduleModule` i `AppModule` för att aktivera schemalagda jobb.

**Fil:** `backend/src/app.module.ts`
**Ändring:**
```typescript
import { ScheduleModule } from '@nestjs/schedule';

@Module({
  imports: [ScheduleModule.forRoot()],
})
export class AppModule {}
```

### Steg 3: Skapa AiTraceCleanupService
Skapa en ny tjänst för att hantera rensningen av `AiTrace`-poster.

**Fil:** `backend/src/ai/ai-trace-cleanup.service.ts`
**Innehåll:**
```typescript
import { Injectable, Logger } from '@nestjs/common';
import { Cron, CronExpression } from '@nestjs/schedule';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class AiTraceCleanupService {
  private readonly logger = new Logger(AiTraceCleanupService.name);

  constructor(private readonly prisma: PrismaService) {}

  @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
  async cleanupOldTraces() {
    this.logger.log('Starting cleanup of old AiTrace records...');
    const thirtyDaysAgo = new Date();
    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);

    const result = await this.prisma.aiTrace.deleteMany({
      where: {
        createdAt: {
          lt: thirtyDaysAgo,
        },
      },
    });

    this.logger.log(`Cleaned up ${result.count} old AiTrace records.`);
  }
}
```

### Steg 4: Registrera AiTraceCleanupService
Lägg till `AiTraceCleanupService` i `AiTraceModule` för att aktivera tjänsten.

**Fil:** `backend/src/ai/ai-trace.module.ts`
**Ändring:**
```typescript
import { AiTraceCleanupService } from './ai-trace-cleanup.service';

@Module({
  providers: [AiTraceService, AiTraceCleanupService],
})
export class AiTraceModule {}
```

### Steg 5: Testa rensningen manuellt
Skapa en testmetod för att manuellt köra rensningen och verifiera att den fungerar som förväntat.

**Fil:** `backend/src/ai/ai-trace.controller.ts`
**Ändring:**
```typescript
import { AiTraceCleanupService } from './ai-trace-cleanup.service';

@Controller('ai/traces')
export class AiTraceController {
  constructor(
    private readonly aiTraceService: AiTraceService,
    private readonly aiTraceCleanupService: AiTraceCleanupService,
  ) {}

  @Post('cleanup')
  @Roles('admin')
  async manualCleanup() {
    await this.aiTraceCleanupService.cleanupOldTraces();
    return { success: true, message: 'Manual cleanup completed.' };
  }
}
```

### Steg 6: Verifiera implementationen
1. Skapa några testposter i `AiTrace`-tabellen med olika `createdAt`-datum.
2. Kör den manuella rensningen via `POST /api/ai/traces/cleanup`.
3. Verifiera att endast poster äldre än 30 dagar har rensats.
4. Kontrollera loggarna för att säkerställa att antalet rensade poster loggas korrekt.

### Steg 7: Dokumentera ändringarna
Uppdatera `TEKNISK_BESKRIVNING.md` med information om den automatiserade rensningen.

**Fil:** `TEKNISK_BESKRIVNING.md`
**Ändring:**
```markdown
## Automatiserad datarensning för AiTrace

För att säkerställa att känsliga data inte lagras längre än nödvändigt, har en automatiserad rensning implementerats:

- **Rensningsintervall**: Dagligen vid midnatt.
- **Retention-period**: 30 dagar.
- **Loggning**: Antalet rensade poster loggas för övervakning.

### Implementation
- **Tjänst**: `AiTraceCleanupService` i `backend/src/ai/ai-trace-cleanup.service.ts`.
- **Schemaläggning**: Använder `@nestjs/schedule` för att köra rensningen dagligen.
- **Manuell rensning**: Tillgänglig via `POST /api/ai/traces/cleanup` (kräver admin-behörighet).

### GDPR-efterlevnad
- Rensningen säkerställer att känsliga data raderas efter 30 dagar, vilket uppfyller GDPR-krav på dataminimering.
- Användare kan begära att deras data raderas tidigare via admin-panelen.
```

## Frågor och överväganden
1. **Retention-period**: Är 30 dagar en lämplig period, eller bör den justeras baserat påelsökningsbehov?
2. **Loggning**: Bör loggarna för rensningen sparas längre för revisionsändamål?
3. **Prestanda**: Bör rensningen köra under lågtrafikperioder för att minimera påverkan på systemet?

## Nästa steg
1. Implementera planen enligt ovan.
2. Testa rensningen i en testmiljö.
3. Verifiera att loggarna är korrekta och att rensningen fungerar som förväntat.
4. Dokumentera ändringarna i `TEKNISK_BESKRIVNING.md`.
5. Informera teamet om den nya funktionaliteten och dess påverkan på GDPR-efterlevnaden.