09 - Server Database e Testing

Introduzione: Server per Database e Testing

In un workflow di sviluppo gestito tramite Model Context Protocol, la comprensione della struttura dati e la qualità del codice sono due pilastri fondamentali. Quando si lavora con un database esistente, serve capire rapidamente quali tabelle esistono, come sono collegate e quali indici mancano. Quando si scrive codice, serve generare test automatici, identificare edge case e misurare le performance.

In questo nono articolo della serie MCP analizziamo quattro server del progetto Tech-MCP che coprono queste due aree critiche: due server dedicati al database (db-schema-explorer e data-mock-generator) e due server dedicati al testing (test-generator e performance-profiler).

Server 1: db-schema-explorer

Il server db-schema-explorer consente l'esplorazione interattiva degli schemi di database SQLite. Risolve il problema della comprensione della struttura dati: quando si lavora con un database esistente, e necessario capire rapidamente quali tabelle esistono, come sono collegate, quali indici mancano e come visualizzare le relazioni.

Il server fornisce accesso in sola lettura al database, garantendo che nessuna operazione possa modificare i dati o lo schema. Utilizza la libreria better-sqlite3 con il flag readonly: true per un accesso diretto, sincrono e performante.

Architettura del Server

+------------------------------------------------------------+
|              db-schema-explorer server                      |
|                                                             |
|  +--------------------------------------------------------+ |
|  |                       Tool Layer                       | |
|  |                                                        | |
|  |   explore-schema    describe-table                     | |
|  |   suggest-indexes   generate-erd                       | |
|  +--------------------------------------------------------+ |
|                         |                                   |
|                         v                                   |
|  +--------------------------------------------------------+ |
|  |           better-sqlite3 (readonly: true)              | |
|  |                                                        | |
|  |   PRAGMA table_info    PRAGMA index_list               | |
|  |   PRAGMA index_info    PRAGMA foreign_key_list         | |
|  |   sqlite_master        SELECT COUNT(*)                 | |
|  +--------------------------------------------------------+ |
|                         |                                   |
|                         v                                   |
|  +--------------------------------------------------------+ |
|  |          Event Bus: db:index-suggestion                | |
|  +--------------------------------------------------------+ |
+------------------------------------------------------------+
    

Tool Disponibili

Tipi di Dato Fondamentali

Il server definisce quattro interfacce TypeScript che strutturano le informazioni restituite dall'introspezione del database:

// TableInfo: informazioni su una tabella
interface TableInfo {
  name: string;
  columns: ColumnInfo[];
}

// ColumnInfo: dettaglio di una colonna
interface ColumnInfo {
  name: string;
  type: string;        // INTEGER, TEXT, REAL, BLOB, BOOLEAN, DATETIME
  nullable: boolean;
  primaryKey: boolean;
  defaultValue: string | null;
}

// IndexInfo: informazioni su un indice
interface IndexInfo {
  name: string;
  unique: boolean;
  columns: string[];
}

// ForeignKeyInfo: informazioni su una foreign key
interface ForeignKeyInfo {
  id: number;
  table: string;       // tabella referenziata
  from: string;        // colonna locale
  to: string;          // colonna referenziata
  onUpdate: string;
  onDelete: string;
}
    

Query PRAGMA Utilizzate

Tutta l'analisi si basa su comandi PRAGMA standard di SQLite, che forniscono metadati sulla struttura del database senza modificare alcun dato:

Esempio: Esplorazione Schema

// Richiesta
{
  "tool": "explore-schema",
  "arguments": {
    "dbPath": "/home/user/data/app.sqlite"
  }
}

// Risposta
{
  "dbPath": "/home/user/data/app.sqlite",
  "tableCount": 3,
  "tables": [
    {
      "name": "users",
      "columns": [
        { "name": "id", "type": "INTEGER", "nullable": false, "primaryKey": true },
        { "name": "email", "type": "TEXT", "nullable": false, "primaryKey": false },
        { "name": "name", "type": "TEXT", "nullable": true, "primaryKey": false }
      ]
    },
    {
      "name": "posts",
      "columns": [
        { "name": "id", "type": "INTEGER", "nullable": false, "primaryKey": true },
        { "name": "user_id", "type": "INTEGER", "nullable": false, "primaryKey": false },
        { "name": "title", "type": "TEXT", "nullable": false, "primaryKey": false }
      ]
    }
  ]
}
    

Esempio: Descrizione Tabella Dettagliata

// Richiesta
{
  "tool": "describe-table",
  "arguments": {
    "dbPath": "/home/user/data/app.sqlite",
    "tableName": "posts"
  }
}

// Risposta
{
  "tableName": "posts",
  "rowCount": 1523,
  "columns": [
    { "name": "id", "type": "INTEGER", "nullable": false,
      "primaryKey": true, "defaultValue": null },
    { "name": "user_id", "type": "INTEGER", "nullable": false,
      "primaryKey": false, "defaultValue": null },
    { "name": "title", "type": "TEXT", "nullable": false,
      "primaryKey": false, "defaultValue": null }
  ],
  "indexes": [
    { "name": "idx_posts_user_id", "unique": false, "columns": ["user_id"] }
  ],
  "foreignKeys": [
    { "id": 0, "table": "users", "from": "user_id", "to": "id",
      "onUpdate": "NO ACTION", "onDelete": "CASCADE" }
  ]
}
    

Suggerimento Indici Automatico

Il tool suggest-indexes analizza tutte le tabelle del database e identifica due tipi di problemi di performance: foreign key senza indice dedicato e tabelle con molte righe prive di indici user-defined. Per ogni foreign key il cui campo from non e indicizzato, il server genera automaticamente il comando SQL CREATE INDEX corrispondente.

// Risposta suggest-indexes
{
  "tablesAnalyzed": 5,
  "suggestionsCount": 2,
  "suggestions": [
    {
      "table": "comments",
      "column": "post_id",
      "reason": "Foreign key column referencing \"posts\"(\"id\") is not indexed.",
      "suggestedSql": "CREATE INDEX idx_comments_post_id ON \"comments\"(\"post_id\");"
    }
  ]
}
    

Generazione Diagrammi ERD

Il tool generate-erd produce diagrammi entità-relazione in sintassi Mermaid erDiagram, convertendo automaticamente i tipi SQLite nei tipi Mermaid corrispondenti: INTEGER diventa int, TEXT/CHAR diventa string, REAL/FLOAT diventa float, BLOB diventa blob e DATE/TIME diventa datetime.

erDiagram
    users {
        int id PK
        string email
        string name
        datetime created_at
    }
    posts {
        int id PK
        int user_id
        string title
        string body
    }
    users ||--o{ posts : "id -> user_id"
    

{
  database: string,   // percorso al file SQLite
  table: string,      // nome della tabella
  columns: string[],  // colonne da indicizzare
  reason: string      // motivazione del suggerimento
}
      

Server 2: data-mock-generator

Il server data-mock-generator genera dati fittizi realistici per testing, sviluppo e prototipazione. Per testare un'applicazione servono dati che assomiglino a quelli reali, ma crearli manualmente non scala. Questo server offre 16 tipi di generatore, supporta output in JSON e CSV, e non ha dipendenze esterne per la generazione dei dati: utilizza esclusivamente Math.random() e crypto.randomUUID().

Tool Disponibili

I 16 Generatori Built-in

Il service layer generators.ts contiene dataset di base (nomi, cognomi, strade, citta, aziende, parole lorem, domini) e 16 funzioni generatore, ciascuna registrata in un registry Record<string, GeneratorInfo>:

Esempio: Generazione Dati da Schema

// Richiesta
{
  "tool": "generate-mock-data",
  "arguments": {
    "schema": [
      { "field": "id", "type": "uuid" },
      { "field": "name", "type": "firstName" },
      { "field": "surname", "type": "lastName" },
      { "field": "email", "type": "email" },
      { "field": "active", "type": "boolean" }
    ],
    "count": 3
  }
}

// Risposta
[
  {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "name": "Jennifer",
    "surname": "Martinez",
    "email": "jennifer.martinez@example.com",
    "active": true
  },
  {
    "id": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
    "name": "Robert",
    "surname": "Smith",
    "email": "robert_smith42@test.org",
    "active": false
  }
]
    

Esempio: Generazione da JSON Schema

Il tool generate-json accetta un JSON Schema con properties e risolve automaticamente il generatore corretto: prima controlla il campo format (email, uri, uuid, ipv4, date), poi fa fallback sul type (string diventa sentence, number diventa float, integer diventa integer, boolean diventa boolean).

// Richiesta
{
  "tool": "generate-json",
  "arguments": {
    "jsonSchema": {
      "properties": {
        "userId": { "type": "string", "format": "uuid" },
        "email": { "type": "string", "format": "email" },
        "registeredAt": { "type": "string", "format": "date" },
        "score": { "type": "integer" }
      }
    },
    "count": 2
  }
}

// Risposta
[
  { "userId": "abc-123-...", "email": "james.lee@mock.dev",
    "registeredAt": "2019-03-15", "score": 7842 },
  { "userId": "def-456-...", "email": "mary_white@demo.net",
    "registeredAt": "2022-11-08", "score": 1256 }
]
    

Esempio: Generazione CSV

Il tool generate-csv gestisce correttamente l'escaping del delimitatore, delle virgolette e dei caratteri newline. Se un valore contiene il delimitatore, virgolette o \n, viene racchiuso tra virgolette doppie con raddoppio delle virgolette interne.

// Richiesta con delimiter: ";"
Nome;Cognome;IP
James;Smith;192.168.1.42
Linda;Johnson;10.0.0.15
Robert;Williams;172.16.5.200
    

Integrazione con db-schema-explorer

I due server database sono complementari: lo schema esplorato con db-schema-explorer guida la definizione dello schema per i mock data. L'AI può esplorare la struttura di un database, estrarre i tipi delle colonne e passarli direttamente a generate-mock-data per popolare le tabelle con dati di test realistici.

Server 3: test-generator

Il server test-generator e dedicato alla generazione automatica di test unitari, all'identificazione di edge case e all'analisi della copertura del codice. E il punto di partenza per qualsiasi workflow di testing all'interno della MCP Suite, permettendo di passare da codice sorgente a skeleton di test in pochi secondi.

Il server e completamente stateless: non possiede alcun database ne store interno. Riceve codice sorgente in input, lo analizza tramite parsing delle firme di funzione e restituisce output strutturato senza mantenere stato tra le invocazioni.

Tool Disponibili

Generazione Automatica di Test

Il tool generate-unit-tests esegue il parsing del codice sorgente cercando due pattern di dichiarazione: funzioni classiche (export function name(params)) e arrow function (export const name = (params) =>). Per ogni funzione trovata genera un blocco describe/it con tre test predefiniti.

// Input: codice sorgente
export function calculateTotal(items: Item[], tax: number): number {
  return items.reduce((sum, item) => sum + item.price, 0) * (1 + tax);
}

export const formatCurrency = (amount: number): string => {
  return new Intl.NumberFormat('it-IT',
    { style: 'currency', currency: 'EUR' }
  ).format(amount);
};
    

// Output generato (framework: vitest)
import { describe, it, expect } from 'vitest';

// import { calculateTotal, formatCurrency } from './source';

describe('calculateTotal', () => {
  it('should exist and be callable', () => {
    expect(calculateTotal).toBeDefined();
    expect(typeof calculateTotal).toBe('function');
  });

  it('should return expected result with valid input', () => {
    const result = calculateTotal(/* items */, /* tax */);
    expect(result).toBeDefined();
    // TODO: Add specific assertions
  });

  it('should handle edge cases', () => {
    // TODO: Test with null/undefined inputs
    // TODO: Test with empty values
    // TODO: Test with boundary values
  });
});
    

Identificazione Edge Case

Il tool find-edge-cases esegue un'analisi statica del codice per identificare potenziali edge case. I controlli sono classificati per severita (high, medium, low) e coprono numerose categorie:

Analisi della Copertura

Il tool analyze-coverage confronta il codice sorgente con il codice dei test per determinare quali funzioni hanno copertura. Il processo prevede tre fasi: estrazione dei nomi funzione dal sorgente, ricerca dei riferimenti nei test (blocchi describe(), blocchi it()/test(), chiamate dirette) e calcolo della percentuale.

  Sorgente                          Test
  +------------------+              +------------------+
  | function add()   |  ------>     | describe('add')  |  COPERTA
  | function sub()   |  ------>     | test('sub ...')   |  COPERTA
  | function mul()   |  --X         |                  |  SCOPERTA
  | function div()   |  --X         |                  |  SCOPERTA
  +------------------+              +------------------+

  Coverage: 2/4 = 50%
    

Server 4: performance-profiler

Il server performance-profiler fornisce strumenti di analisi statica delle prestazioni per codice JavaScript e TypeScript. A differenza di un profiler runtime, questo server analizza il codice sorgente senza eseguirlo, identificando anti-pattern di performance noti, dipendenze pesanti e generando template di benchmark eseguibili.

Un principio fondamentale di questo server e la sicurezza by design: non viene mai eseguito eval() ne codice arbitrario. Il tool benchmark-compare genera un template Node.js che l'utente può eseguire separatamente nel proprio ambiente.

Tool Disponibili

Analisi del Bundle

Il tool analyze-bundle legge file JavaScript e TypeScript (singoli o intere directory, escludendo node_modules e dist) e analizza gli import cercando dipendenze pesanti note. Per ogni pacchetto pesante individuato, il server fornisce la dimensione stimata e un'alternativa più leggera.

Identificazione Bottleneck

Il tool find-bottlenecks esegue analisi statica riga per riga del codice, rilevando anti-pattern di performance con severita classificata come critical, warning o info:

Per ogni bottleneck trovato, l'output include il tipo, la severita, la riga, una descrizione del problema e un suggerimento di fix:

{
  "type": "nested-loop",
  "severity": "critical",
  "line": 42,
  "description": "Nested loop detected - potential O(n^2)...",
  "suggestion": "Consider using a Map/Set for lookups...",
  "pattern": "for (const item of items) {"
}
    

Generazione Benchmark

Il tool benchmark-compare genera un file Node.js completo per confrontare le performance di due snippet di codice. Il template include quattro fasi: warmup (10% delle iterazioni), misurazione con performance.now(), calcolo statistiche (mean, median, min, max, p95, p99, stdDev, ops/sec) e confronto finale che indica quale snippet e più veloce e di quanto.

// Richiesta
{
  "tool": "benchmark-compare",
  "arguments": {
    "codeA": "const result = arr.filter(x => x > 0).map(x => x * 2);",
    "codeB": "const result = []; for (const x of arr) { if (x > 0) result.push(x * 2); }",
    "iterations": 5000
  }
}
    

L'output e un template Node.js completo pronto per l'esecuzione con node benchmark.js. Il server non esegue mai il codice generato: la sicurezza e garantita by design.

Interazioni tra i Quattro Server

I quattro server analizzati in questo articolo non operano in isolamento ma si completano a vicenda attraverso flussi di lavoro complementari e attraverso l'Event Bus:

+---------------------+    db:index-suggestion    +-------------------+
| db-schema-explorer  | ------------------------> | agile-metrics     |
|                     |                           | standup-notes     |
+---------------------+                           +-------------------+
         ^
         |  (dbPath come input)
         |
+---------------------+
| data-mock-generator |  genera dati che possono
|                     |  popolare il database
+---------------------+

+-------------------+       test:generated        +-------------------+
| test-generator    | --------------------------> | standup-notes     |
|                   |       test:coverage-report  +-------------------+
|                   | --------------------------> | agile-metrics     |
+-------------------+                             +-------------------+

+----------------------+    perf:bottleneck-found  +-------------------+
| performance-profiler | ----------------------->  | standup-notes     |
|                      |    perf:profile-completed +-------------------+
|                      | ----------------------->  | agile-metrics     |
+----------------------+                           +-------------------+
    

Workflow Combinato Tipico

Un flusso di lavoro tipico che combina tutti e quattro i server potrebbe essere:

1. Esplorazione schema: l'AI usa explore-schema per capire la struttura del database
2. Suggerimento indici: suggest-indexes identifica ottimizzazioni mancanti e pubblica db:index-suggestion
3. Generazione dati: generate-mock-data crea fixture di test basate sullo schema esplorato
4. Generazione test: generate-unit-tests crea skeleton di test per il codice applicativo e pubblica test:generated
5. Analisi edge case: find-edge-cases identifica i casi limite da coprire nei test
6. Profiling: find-bottlenecks analizza il codice per anti-pattern e pubblica perf:bottleneck-found
7. Benchmark: benchmark-compare genera template per confrontare implementazioni alternative

Conclusioni

I quattro server analizzati in questo articolo dimostrano come MCP possa coprire due fasi critiche del ciclo di sviluppo: la comprensione della struttura dati e la garanzia di qualità del codice. Il server db-schema-explorer offre introspezione completa con PRAGMA, suggerimento indici e generazione di diagrammi ERD. Il server data-mock-generator fornisce 16 generatori per creare dati realistici in JSON e CSV. Il server test-generator automatizza la creazione di test unitari con identificazione di edge case. Il server performance-profiler esegue analisi statica per individuare bottleneck e generare benchmark.

Nel prossimo articolo analizzeremo i Server di Project Management: scrum-board, agile-metrics, time-tracking, project-economics e retrospective-manager, cinque server che portano la gestione agile del progetto direttamente nell'interfaccia AI.

Il codice completo di tutti i server e disponibile nel repository Tech-MCP su GitHub.