;
};
export const PromptBlock = ({children, type, agent, intent, playbookId}) => {
var utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=prompt-block';
var tag = 'docs-use-case-gallery';
var agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
var label = type === 'schedule' ? 'Schedule in Devin' : type === 'playbook' ? 'Create Playbook' : type === 'knowledge' ? 'Add to Knowledge' : agent === 'advanced' ? 'Try in Devin' : agent === 'dana' ? 'Try in Dana' : agent === 'ada' ? 'Try in Ask Devin' : 'Try in Devin';
var buildUrl = function (text) {
var encoded = encodeURIComponent(text);
if (type === 'schedule') return 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + '&prompt=' + encoded;
if (type === 'playbook') return 'https://app.devin.ai/settings/playbooks/create?' + utm + '&body=' + encoded;
if (type === 'knowledge') return 'https://app.devin.ai/knowledge?' + utm + '&body=' + encoded;
if (agent === 'ada') return 'https://app.devin.ai/search?' + utm + '&noSubmit=true&prompt=' + encoded;
return 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encoded;
};
const ref = React.useRef(null);
const [href, setHref] = React.useState('#');
React.useEffect(() => {
if (!ref.current) return;
var codeEl = ref.current.querySelector('pre code');
if (codeEl) {
var text = codeEl.textContent.trim();
if (text) setHref(buildUrl(text));
}
var header = ref.current.querySelector('[data-component-part="code-block-header"]');
if (header && !header.querySelector('.prompt-block-devin-link')) {
var link = document.createElement('a');
link.href = href;
link.target = '_blank';
link.rel = 'noopener noreferrer';
link.className = 'prompt-block-devin-link';
link.style.cssText = 'display:inline-flex;align-items:center;gap:6px;text-decoration:none;color:#fff;font-size:11px;font-weight:500;padding:4px 10px;border-radius:6px;white-space:nowrap;background:#317CFF;transition:background 0.2s;margin-left:8px;';
link.innerHTML = ' ' + label;
link.onmouseenter = function () {
link.style.background = '#2968D9';
};
link.onmouseleave = function () {
link.style.background = '#317CFF';
};
header.appendChild(link);
}
var existingLink = ref.current.querySelector('.prompt-block-devin-link');
if (existingLink && href !== '#') existingLink.href = href;
});
return
{children}
;
};
Non vuoi configurarlo manualmente? Incolla un collegamento a questa pagina in una sessione di Devin e chiedigli di configurare tutto per te.
Analizza le collection MongoDB e progetta gli equivalenti relazionali. Se i tuoi dati coinvolgono più collection con relazioni, crea prima un Diagramma Entità‑Relazioni (ERD) per validare le scelte di normalizzazione prima di scrivere qualsiasi SQL.
Pattern di mapping principali:
* **ID dei documenti**: Converti i campi `_id` di MongoDB in chiavi primarie UUID o SERIAL
* **Oggetti annidati**: Appiattisci in tabelle separate con relazioni di chiave esterna
* **Array**: Usa i tipi array di Postgres o tabelle di giunzione separate
* **Documenti incorporati**: Estrai in tabelle correlate con una corretta normalizzazione
```txt Analyze MongoDB schema and design Postgres tables theme={null}
Analizza le nostre collection MongoDB esistenti e gli schemi dei documenti.
Per ogni collection:
1. Progetta una tabella equivalente su PostgreSQL con tipi di colonna appropriati
2. Identifica le relazioni e crea le chiavi esterne
3. Appiattisci gli oggetti annidati in tabelle separate quando opportuno
4. Crea un ERD che mostri tutte le entità e le relazioni
5. Converti gli ObjectId di MongoDB in UUID
6. Scrivi la migrazione SQL per creare lo schema
```
Una volta che lo schema è pronto, configura la sicurezza: crea ruoli Postgres con privilegi appropriati e abilita le politiche di Row Level Security (RLS) sulle tabelle che richiedono il controllo di accesso a livello di riga.
Sostituisci il tuo driver MongoDB (ad es. `mongoose`, `mongodb`) con una libreria client Postgres — Prisma, Drizzle, TypeORM o `node-postgres` a seconda dello stack. Aggiorna la configurazione dell'ambiente con `DATABASE_URL` o credenziali di connessione equivalenti.
Modelli di migrazione delle query:
* **Operazioni di ricerca (find)** → query SQL `SELECT` oppure `.findMany()` / `.select()` dell'ORM
* **Pipeline di aggregazione** → `JOIN`, `GROUP BY`, sottoquery, funzioni di finestra
* **Update** → istruzioni SQL `UPDATE`
* **Insert** → SQL `INSERT` o metodi di inserimento bulk / in blocco
```txt Migra il backend da MongoDB a Postgres theme={null}
Sostituisci il nostro driver MongoDB con [Prisma / Drizzle / node-postgres].
Per ogni modulo backend:
1. Sostituisci gli import MongoDB e la configurazione della connessione
2. Riscrivi tutte le query per usare il nuovo client Postgres
3. Aggiorna la gestione degli errori (ad es. le violazioni di vincoli di unicità corrispondono al codice Postgres 23505)
4. Mantieni invariati tutti i formati di risposta dell'API esistenti
5. Esegui i test dopo ogni modulo per verificare che non si rompa nulla
```
Se la tua app utilizza autenticazione JWT personalizzata con un archivio utenti MongoDB, aggiorna le query di ricerca utente per usare Postgres mantenendo invariata la logica di generazione e validazione dei token.
Aggiorna i servizi frontend per gestire eventuali modifiche allo schema dei dati derivanti dalla migrazione — più comunemente `_id` che diventa `id`. Mantieni le firme dei metodi di servizio esistenti in modo che i componenti non richiedano modifiche.
* Aggiorna i servizi di autenticazione se il flusso di autenticazione è cambiato
* Adatta la gestione delle richieste e delle risposte del client HTTP ai nuovi schemi di dati
* Aggiorna i route guard e i resolver se sono cambiate le modalità di recupero dei dati
Esporta i dati da MongoDB, trasformali per allinearli allo schema Postgres e importali.
```txt Crea uno script di migrazione dei dati theme={null}
Scrivi uno script di migrazione che:
1. Esporti i dati dalle nostre collection MongoDB
2. Trasformi i documenti per allinearli allo schema PostgreSQL
(ObjectId → UUID, appiattisca i documenti incorporati, converta le date)
3. Importi in PostgreSQL preservando le relazioni di chiave esterna
4. Verifichi l'integrità dei dati: conteggio delle righe, relazioni fra chiavi, verifiche a campione
```
Dopo l'import, esegui l'intera suite di test sul backend Postgres. Verifica che tutte le operazioni CRUD, i flussi di autenticazione e il controllo degli accessi basato sui ruoli funzionino correttamente.
Distribuisci usando feature flag per un rilascio graduale. Mantieni l'istanza MongoDB come fallback durante la transizione.
Checklist post-distribuzione:
* Aggiungi indici per le colonne interrogate più frequentemente
* Usa `EXPLAIN ANALYZE` per identificare le query lente
* Configura il connection pooling (ad es. PgBouncer)
* Monitora le prestazioni delle query e l'utilizzo delle connessioni
* Documenta le procedure di rollback per i problemi critici
```txt Post-migration optimization theme={null}
La migrazione da MongoDB a Postgres è stata distribuita. Esegui EXPLAIN ANALYZE
sulle nostre query più frequenti e suggerisci gli indici da creare. Verifica:
1. Scansioni sequenziali su tabelle di grandi dimensioni che dovrebbero usare indici
2. Indici mancanti sulle colonne delle chiavi esterne (foreign key)
3. Query che potrebbero beneficiare di indici parziali o composti
4. Raccomandazioni sul dimensionamento del connection pool in base al nostro carico di lavoro
```
Una volta che tutto è stabile e verificato, dismetti l'istanza MongoDB.
Se hai bisogno di applicare questo schema di migrazione su più servizi o repository, salvalo come [playbook](/it/product-guides/creating-playbooks) in modo che ogni sessione segua lo stesso processo. Di seguito è riportato un esempio di playbook per una migrazione da MongoDB a Postgres:
```txt MongoDB to PostgreSQL Migration theme={null}
## Panoramica
Migrazione di un progetto da MongoDB a PostgreSQL. Questa guida tratta la
progettazione dello schema, la migrazione delle API backend, gli aggiornamenti del livello di servizio frontend,
la migrazione dei dati e il deployment.
## Requisiti dell'Utente
- Accesso al database MongoDB sorgente (stringa di connessione o esportazione)
- Credenziali del database PostgreSQL di destinazione
(host, porta, database, utente, password)
- Descrizione del modello dati dell'applicazione e delle query principali
- Eventuali requisiti di autenticazione/autorizzazione per il nuovo sistema
## Fase 1: Progettazione e Configurazione dello Schema del Database
### Passaggio 1: Configurazione del Progetto
1. Eseguire il provisioning di un database PostgreSQL e annotare le credenziali di connessione
2. Analizzare le collezioni MongoDB esistenti e gli schemi dei documenti
3. Progettare le tabelle PostgreSQL equivalenti con le relazioni appropriate
### Passaggio 2: Creazione dell'ERD
Se lo schema MongoDB sorgente coinvolge più collezioni con
relazioni (documenti incorporati, riferimenti tramite ObjectId o
pattern di giunzione), creare un Diagramma Entità-Relazione prima
di progettare le tabelle PostgreSQL:
1. Identificare tutte le entità e i relativi attributi dalle collezioni
MongoDB
2. Mappare le relazioni tra le entità
(uno-a-uno, uno-a-molti, molti-a-molti)
3. Produrre un ERD utilizzando uno strumento come dbdiagram.io, Mermaid o
draw.io
4. Utilizzare l'ERD per validare le decisioni di normalizzazione e la progettazione
delle chiavi esterne prima di scrivere qualsiasi SQL
Saltare questo passaggio se la migrazione riguarda una sola collezione
o un numero limitato di collezioni indipendenti senza relazioni significative.
### Passaggio 3: Pattern di Conversione dello Schema
- ID documento: Convertire i campi _id di MongoDB in chiavi primarie UUID o
SERIAL di PostgreSQL
- Oggetti annidati: Appiattire in tabelle separate con relazioni
tramite chiave esterna
- Array: Utilizzare i tipi array di PostgreSQL o tabelle di giunzione separate
- Documenti incorporati: Estrarre in tabelle correlate con la corretta
normalizzazione
### Passaggio 4: Configurazione della Sicurezza
1. Creare ruoli e utenti PostgreSQL con i privilegi appropriati
(sola lettura, lettura-scrittura, admin)
2. Utilizzare GRANT/REVOKE per limitare l'accesso a tabelle e colonne per ruolo
3. Se l'applicazione richiede il controllo degli accessi a livello di riga, abilitare le policy
Row Level Security (RLS) sulle tabelle pertinenti
### Passaggio 5: Funzioni e Trigger del Database
1. Creare trigger di gestione utenti per la creazione automatica dei record
(ad es., timestamp di audit, valori predefiniti)
2. Implementare funzioni di logica di business in PL/pgSQL per sostituire
le validazioni a livello applicativo dove opportuno
## Fase 2: Migrazione delle API Backend
### Passaggio 1: Gestione delle Dipendenze
1. Sostituire i driver MongoDB (ad es., mongodb, mongoose) con una
libreria client PostgreSQL (ad es., pg per Node.js, psycopg2
per Python, o un ORM come Prisma/Sequelize/TypeORM)
2. Aggiornare la configurazione dell'ambiente con le credenziali di connessione
PostgreSQL (DATABASE_URL o variabili individuali host/porta/db/utente/
password)
3. Rimuovere o sostituire eventuali middleware o utility specifici di MongoDB
### Passaggio 2: Aggiornamenti del Sistema di Autenticazione
1. Se l'applicazione esistente utilizza autenticazione JWT personalizzata, mantenerla e aggiornare
le query di ricerca utente per utilizzare PostgreSQL
2. Se si migra a un nuovo sistema di autenticazione, sostituire la generazione dei token
e il middleware di validazione di conseguenza
3. Mantenere i formati di risposta API esistenti per la
compatibilità con il frontend
### Passaggio 3: Pattern di Migrazione delle Query
- Operazioni di ricerca: Convertire collection.find() in query SQL SELECT
(o equivalenti ORM come .findMany(), .select())
- Pipeline di aggregazione: Sostituire con JOIN, GROUP BY,
sottoquery e funzioni finestra di PostgreSQL
- Aggiornamenti: Convertire updateOne/updateMany in istruzioni SQL UPDATE
- Inserimenti: Sostituire insertOne/insertMany con istruzioni SQL INSERT
o metodi di inserimento massivo
### Passaggio 4: Aggiornamenti della Gestione degli Errori
1. Sostituire i codici di errore specifici di MongoDB con la gestione degli errori
di PostgreSQL (ad es., le violazioni di vincolo di unicità corrispondono al codice 23505)
2. Mantenere formati di risposta agli errori coerenti per i servizi
frontend
## Fase 3: Aggiornamenti del Livello di Servizio Frontend
### Passaggio 1: Migrazione del Servizio di Autenticazione
1. Aggiornare il servizio di autenticazione utente per funzionare con i nuovi
endpoint di autenticazione backend
2. Se l'approccio di autenticazione è cambiato, aggiornare i flussi di login/logout e la gestione
dei token di conseguenza
3. Modificare la creazione degli oggetti utente per adattarsi al nuovo formato dei dati utente
proveniente da PostgreSQL
### Passaggio 2: Aggiornamenti del Client HTTP
1. Aggiornare gli URL degli endpoint API se la struttura del backend cambia
2. Adeguare la gestione delle richieste/risposte se la struttura dei dati è cambiata
(ad es., _id che diventa id)
3. Mantenere le firme dei metodi di servizio esistenti per la compatibilità
con i componenti
### Passaggio 3: Aggiornamenti dei Guard e Resolver delle Route
1. Aggiornare i guard di autenticazione per funzionare con il nuovo sistema di autenticazione
2. Modificare i resolver delle route se i pattern di recupero dati sono cambiati
3. Verificare che i flussi di dati dei componenti esistenti rimangano intatti
## Fase 4: Migrazione dei Dati e Test
### Passaggio 1: Esportazione e Trasformazione dei Dati
1. Esportare le collezioni MongoDB utilizzando mongoexport o script personalizzati
2. Trasformare i dati per soddisfare i requisiti dello schema PostgreSQL
3. Gestire le conversioni dei tipi di dato (ObjectId in UUID, date,
documenti incorporati in chiavi esterne, ecc.)
### Passaggio 2: Processo di Importazione dei Dati
1. Importare i dati utilizzando psql \copy, pg_restore o script di migrazione
personalizzati
2. Verificare le relazioni tramite chiave esterna e i vincoli dopo l'importazione
3. Eseguire conteggi e verifiche a campione per confermare l'integrità e la
completezza dei dati
### Passaggio 3: Test End-to-End
1. Testare tutte le operazioni CRUD con dati reali
2. Verificare che i flussi di autenticazione funzionino correttamente
3. Testare le funzionalità di amministrazione e l'accesso basato sui ruoli
## Fase 5: Deployment e Monitoraggio
### Passaggio 1: Strategia di Deployment
1. Eseguire il deployment delle modifiche backend con feature flag per un rilascio graduale
2. Aggiornare la configurazione frontend per gli endpoint di produzione
supportati da PostgreSQL
3. Implementare il connection pooling del database (ad es., PgBouncer) e
il monitoraggio
### Passaggio 2: Ottimizzazione delle Prestazioni
1. Aggiungere indici del database per le colonne interrogate frequentemente
2. Utilizzare EXPLAIN ANALYZE per identificare e ottimizzare le query lente
3. Monitorare le prestazioni delle query e l'utilizzo del connection pool
### Passaggio 3: Pianificazione del Rollback
1. Mantenere l'istanza MongoDB come backup durante il periodo di transizione
2. Documentare le procedure di rollback per i problemi critici
3. Creare script di sincronizzazione dei dati se necessario
## Pattern Principali di Migrazione
### Migrazione dell'Autenticazione
- Da: JWT personalizzato con archivio utenti MongoDB
- A: JWT personalizzato (o autenticazione del framework) con archivio utenti PostgreSQL
- Mantenere: Le interfacce degli oggetti utente esistenti e i contratti
dei componenti
### Migrazione delle Query del Database
- Da: Pipeline di aggregazione MongoDB e query sui documenti
- A: Query SQL con JOIN, GROUP BY e funzioni finestra
- Mantenere: Formati di risposta API e strutture dati
### Migrazione della Sicurezza
- Da: Autorizzazione a livello applicativo con MongoDB
- A: Ruoli/privilegi PostgreSQL con policy RLS opzionali
- Mantenere: Logica di ruoli e permessi degli utenti
## Specifiche
- Tutti i contratti API esistenti e i formati di risposta devono essere
mantenuti
- L'integrità dei dati deve essere verificata dopo la migrazione (conteggio delle righe,
relazioni chiave, verifiche a campione)
- L'istanza MongoDB deve rimanere disponibile come fallback
durante il periodo di transizione
- Validazione: eseguire la suite di test dell'applicazione end-to-end sul
backend PostgreSQL e confermare che tutti i test vengano superati
```