12 - Copilot Edits e Agent Mode

// File: src/controllers/user.controller.ts (PRIMA)
import {{ '{' }} Request, Response } from 'express';
import {{ '{' }} UserService } from '../services/user.service';

export class UserController {{ '{' }}
  constructor(private userService: UserService) {{ '{' }}}

  async createUser(req: Request, res: Response) {{ '{' }}
    // Validazione inline nel controller
    const {{ '{' }} email, name, password } = req.body;

    if (!email || !email.includes('@')) {{ '{' }}
      return res.status(400).json({{ '{' }} error: 'Invalid email' });
    }
    if (!name || name.length < 2) {{ '{' }}
      return res.status(400).json({{ '{' }} error: 'Name too short' });
    }
    if (!password || password.length < 8) {{ '{' }}
      return res.status(400).json({{ '{' }} error: 'Password too short' });
    }

    const user = await this.userService.create({{ '{' }} email, name, password });
    res.status(201).json(user);
  }

  async updateUser(req: Request, res: Response) {{ '{' }}
    const {{ '{' }} id } = req.params;
    const {{ '{' }} email, name } = req.body;

    if (email && !email.includes('@')) {{ '{' }}
      return res.status(400).json({{ '{' }} error: 'Invalid email' });
    }
    if (name && name.length < 2) {{ '{' }}
      return res.status(400).json({{ '{' }} error: 'Name too short' });
    }

    const user = await this.userService.update(id, {{ '{' }} email, name });
    res.json(user);
  }
}

Estrai tutta la logica di validazione dal UserController in un
middleware dedicato. Crea:
1. Un file src/middleware/validation.middleware.ts con funzioni
   di validazione riutilizzabili usando class-validator
2. Un file src/dto/user.dto.ts con le classi DTO per CreateUser e UpdateUser
3. Aggiorna il controller per rimuovere la validazione inline
4. Aggiorna src/routes/user.routes.ts per usare il middleware di validazione
5. Aggiorna i test in tests/controllers/user.controller.test.ts

// File: src/dto/user.dto.ts (GENERATO da Copilot Edits)
import {{ '{' }} IsEmail, IsString, MinLength, IsOptional } from 'class-validator';

export class CreateUserDto {{ '{' }}
  @IsEmail({{ '{' }}}, {{ '{' }} message: 'Invalid email format' })
  email: string;

  @IsString()
  @MinLength(2, {{ '{' }} message: 'Name must be at least 2 characters' })
  name: string;

  @IsString()
  @MinLength(8, {{ '{' }} message: 'Password must be at least 8 characters' })
  password: string;
}

export class UpdateUserDto {{ '{' }}
  @IsOptional()
  @IsEmail({{ '{' }}}, {{ '{' }} message: 'Invalid email format' })
  email?: string;

  @IsOptional()
  @IsString()
  @MinLength(2, {{ '{' }} message: 'Name must be at least 2 characters' })
  name?: string;
}

// File: src/middleware/validation.middleware.ts (GENERATO)
import {{ '{' }} Request, Response, NextFunction } from 'express';
import {{ '{' }} validate } from 'class-validator';
import {{ '{' }} plainToInstance } from 'class-transformer';

export function validateBody(dtoClass: any) {{ '{' }}
  return async (req: Request, res: Response, next: NextFunction) => {{ '{' }}
    const dtoInstance = plainToInstance(dtoClass, req.body);
    const errors = await validate(dtoInstance, {{ '{' }}
      whitelist: true,
      forbidNonWhitelisted: true
    });

    if (errors.length > 0) {{ '{' }}
      const messages = errors.flatMap(err =>
        Object.values(err.constraints || {{ '{' }}})
      );
      return res.status(400).json({{ '{' }}
        error: 'Validation failed',
        details: messages
      });
    }

    req.body = dtoInstance;
    next();
  };
}

// File: src/controllers/user.controller.ts (DOPO - senza validazione)
import {{ '{' }} Request, Response } from 'express';
import {{ '{' }} UserService } from '../services/user.service';

export class UserController {{ '{' }}
  constructor(private userService: UserService) {{ '{' }}}

  async createUser(req: Request, res: Response) {{ '{' }}
    // La validazione è gestita dal middleware
    const {{ '{' }} email, name, password } = req.body;
    const user = await this.userService.create({{ '{' }} email, name, password });
    res.status(201).json(user);
  }

  async updateUser(req: Request, res: Response) {{ '{' }}
    const {{ '{' }} id } = req.params;
    const {{ '{' }} email, name } = req.body;
    const user = await this.userService.update(id, {{ '{' }} email, name });
    res.json(user);
  }
}

// .vscode/settings.json
{{ '{' }}
  // Abilita Agent Mode (abilitato di default nelle versioni recenti)
  "github.copilot.chat.agent.enabled": true,

  // Configura quali comandi l'agente può eseguire senza conferma
  "github.copilot.chat.agent.autoApprove": {{ '{' }}
    // Comandi che non richiedono conferma
    "allowedCommands": [
      "npm test",
      "npm run lint",
      "npm run build",
      "npx tsc --noEmit"
    ],
    // Comandi che richiedono sempre conferma
    "blockedCommands": [
      "rm",
      "git push",
      "npm publish",
      "docker"
    ]
  },

  // Limite di iterazioni per il self-healing
  "github.copilot.chat.agent.maxIterations": 5,

  // File e cartelle che l'agente non può modificare
  "github.copilot.chat.agent.protectedPaths": [
    ".env",
    ".env.*",
    "secrets/",
    "*.key",
    "*.pem"
  ]
}

Aggiungi un sistema di notifiche in-app al progetto.
Requisiti:
- Modello Notification con titolo, messaggio, tipo, letto/non letto
- Service per CRUD notifiche
- Controller con endpoint REST
- Componente Angular con icona campanella e badge contatore
- WebSocket per aggiornamenti real-time
- Test per service e controller

# Piano di Implementazione: Sistema Notifiche

## Domande Chiarificatrici
1. Vuoi persistere le notifiche su database o solo in memoria?
   -> Risposta: Database (PostgreSQL con Prisma)
2. Le notifiche devono essere per utente specifico o broadcast?
   -> Risposta: Per utente, con possibilità di broadcast
3. Quale libreria WebSocket preferisci?
   -> Risposta: Socket.io (gia presente nelle dipendenze)

## File da Creare (5)
1. src/models/notification.model.ts - Schema Prisma e tipi
2. src/services/notification.service.ts - Business logic
3. src/controllers/notification.controller.ts - Endpoint REST
4. src/gateways/notification.gateway.ts - WebSocket gateway
5. frontend/src/app/components/notification-bell/ - Componente Angular

## File da Modificare (4)
1. prisma/schema.prisma - Aggiungere modello Notification
2. src/routes/index.ts - Registrare route notifiche
3. src/app.ts - Registrare WebSocket gateway
4. frontend/src/app/app.component.ts - Aggiungere notification-bell

## Comandi da Eseguire (3)
1. npx prisma migrate dev --name add-notifications
2. npm test -- --testPathPattern=notification
3. npm run build

## Ordine di Esecuzione
Phase 1: Backend (modello, service, controller)
Phase 2: WebSocket (gateway, eventi)
Phase 3: Frontend (componente, integrazione)
Phase 4: Test e verifica

## Stima: ~45 minuti di esecuzione agent

// Step 1: Rinomini la prima occorrenza
const userProfile = await fetchUserData(userId);
//    ^^^^^^^^^^^  modifica manuale

// Step 2: NES mostra indicatori nel gutter su tutte le altre occorrenze
// Linea 15: [NES] data.name  ->  userProfile.name
// Linea 23: [NES] data.email ->  userProfile.email
// Linea 31: [NES] return data; -> return userProfile;
// Linea 45: [NES] if (data) -> if (userProfile)

// Step 3: Premi Tab per navigare al primo suggerimento
// Step 4: Premi Tab per accettare
// Step 5: Ripeti fino a completare tutte le occorrenze

// Risultato: tutte le 15 occorrenze aggiornate con pochi Tab

// PRIMA: Metodo originale in UserService.cs
public async Task<User> GetUserById(int id)
{{ '{' }}
    return await _repository.FindAsync(id);
}

// MODIFICA: Aggiungi parametro 'includeOrders' alla firma
public async Task<User> GetUserById(int id, bool includeOrders = false)
{{ '{' }}
    var user = await _repository.FindAsync(id);
    if (includeOrders)
    {{ '{' }}
        user.Orders = await _orderRepository.FindByUserIdAsync(id);
    }
    return user;
}

// SYMBOL-AWARE: Copilot identifica TUTTI i 23 chiamanti nel progetto
// e suggerisce aggiornamenti per ciascuno:

// File: UserController.cs (linea 45)
// PRIMA:  var user = await _userService.GetUserById(id);
// DOPO:   var user = await _userService.GetUserById(id, false);

// File: OrderController.cs (linea 78)
// PRIMA:  var user = await _userService.GetUserById(userId);
// DOPO:   var user = await _userService.GetUserById(userId, true);

// File: UserServiceTests.cs (linea 112)
// PRIMA:  var result = await service.GetUserById(1);
// DOPO:   var result = await service.GetUserById(1, false);

// ... e cosi via per tutti i 23 riferimenti

Aggiungi paginazione a tutti gli endpoint che restituiscono liste.

Requisiti:
- Query params: page (default 1), limit (default 20, max 100)
- Risposta: {{ '{' }} data: T[], meta: {{ '{' }} page, limit, total, totalPages } }
- Endpoint coinvolti: GET /users, GET /orders, GET /products
- Aggiorna i test esistenti per verificare la paginazione
- Aggiorna la documentazione OpenAPI

Pattern da seguire: vedi src/utils/pagination.ts (se esiste) o crealo

Migra il progetto da Moment.js a Day.js.

Contesto:
- Moment.js e usato in 15 file
- Usiamo i plugin: timezone, relative-time, duration
- I test usano mock di Moment.js
- Il formato delle date in DB e ISO 8601

Requisiti:
- Sostituire tutti gli import di moment con dayjs
- Configurare i plugin equivalenti
- Aggiornare i format string se necessario
- Aggiornare tutti i test
- Rimuovere moment dalle dipendenze
- Verificare che il build compili senza errori

# Piano di Migrazione: Moment.js -> Day.js

## Analisi Impatto
File impattati: 15
Test impattati: 8
Plugin da sostituire: 3

## Phase 1: Setup (5 min)
1. npm install dayjs
2. Creare src/utils/dayjs-config.ts con plugin

## Phase 2: Migrazione File (20 min)
File da modificare (ordine per dipendenze):
1. src/utils/date-helpers.ts (utility condiviso)
2. src/services/report.service.ts
3. src/services/scheduling.service.ts
4. src/controllers/report.controller.ts
... (altri 11 file)

## Phase 3: Test (10 min)
1. Aggiornare mock in tests/setup.ts
2. Aggiornare assertion nei test
3. Eseguire test suite completa

## Phase 4: Cleanup (5 min)
1. npm uninstall moment @types/moment
2. Verificare build
3. Verificare bundle size (atteso: -200KB)

## Rischi Identificati
- Il plugin timezone di Day.js ha API diversa
- Alcuni format string sono diversi
- I mock nei test potrebbero richiedere refactoring