Export
L'export trasforma il Tuo modello Mockomat in file che Ti appartengono. Ci sono due formati:
| Formato | Cosa ottieni | Disponibile su |
|---|---|---|
| Specifica OpenAPI | Un file YAML OpenAPI 3.0.3 con uno schema per tabella | Ogni piano con account |
| Pacchetto di codice | Uno ZIP con un backend NestJS generato per le Tue tabelle | Professional e superiori |
I pacchetti di codice richiedono almeno il ruolo Editore e l'accesso in modifica al progetto. L'export non modifica mai il Tuo progetto, e il codice generato non ha alcuna dipendenza di runtime da Mockomat.
Procedura guidata di export con i passaggi di formato e opzioni.
Avviare un export
Apri Export nell'app. La procedura guidata di export Ti accompagna in quattro passaggi:
- Progetto — scegli il progetto da esportare.
- Formato di esportazione — specifica OpenAPI o pacchetto di codice.
- Configura esportazione — per un pacchetto di codice, questo passaggio mostra il pacchetto incluso nel Tuo piano.
- Rivedi ed esporta — conferma. Un file OpenAPI viene scaricato subito; un pacchetto di codice viene generato in background e compare con un link di download quando è pronto.
Se la Tua app non offre ancora i pacchetti di codice, nel frattempo esporta la specifica OpenAPI.
Scelta del formato di esportazione: specifica OpenAPI o pacchetto di codice.
Specifica OpenAPI
L'export OpenAPI scrive il Tuo modello come components.schemas: uno schema per tabella, con i suoi attributi come proprietà, gli attributi obbligatori, i valori enum e le relazioni. Non contiene percorsi (paths). Usalo per condividere il modello dati con altri strumenti, o come punto di partenza di un contratto che il Tuo team backend implementa.
Pacchetto di codice
Il pacchetto di codice è un progetto generato che puoi eseguire, modificare e distribuire autonomamente.
| Pacchetto | Piani | Contenuto |
|---|---|---|
| Pro | Professional, Business | Backend NestJS |
| Enterprise | Enterprise | Backend NestJS + frontend Angular |
Cosa contiene il backend
- Un'applicazione NestJS con un'API GraphQL (code-first), un modulo per tabella: entità, resolver, service e tipi di input e output.
- Per tabella: una query di lista paginata con ricerca, una query per ID e mutation per creare, aggiornare, eliminare e ripristinare record.
- Entità TypeORM per MySQL / MariaDB.
- Autenticazione: accesso con JWT e un modulo utenti. Al primo avvio il backend crea un utente admin e stampa la sua password una sola volta nella console.
- Un file Docker Compose che avvia MySQL e Redis, e un README con i passaggi di configurazione.
Il generatore attuale ha dei limiti da conoscere prima di pianificare con il codice:
- Punta a MySQL / MariaDB e include sempre l'autenticazione e il file Docker Compose. Le scelte di database e le altre opzioni della procedura guidata non modificano ancora il pacchetto.
- Le relazioni tra le Tue tabelle non vengono generate. Aggiungile Tu stesso alle entità e ai service generati.
- Le colonne generate accettano valori vuoti: il flag Required di un attributo non viene ancora applicato.
Eseguirlo in locale
Il README del pacchetto elenca i passaggi. In breve, nella cartella del backend:
npm install
cp .env.example .env # poi inserisci le credenziali del database
npm run migration:run
npm run start:devIl backend richiede un database MySQL o MariaDB e Redis.
Panoramica della struttura del progetto backend generato.
Prima dell'export
Esegui prima la checklist di validazione runtime. Un modello pulito produce codice più pulito:
- I nomi seguono le Tue convenzioni — i nomi di tabelle e attributi diventano nomi di classi, tipi e campi.
- I tipi degli attributi sono corretti — diventano tipi di colonne e di campi GraphQL.
- Gli attributi Searchable diventano i campi di ricerca della query di lista generata, e gli attributi Sortable vengono segnati come colonne di lista ordinabili.
Le operazioni e i parametri che hai progettato in API Design (in inglese) definiscono la Tua mock API; il backend generato include le proprie query e mutation standard per tabella.
Cosa verificare dopo l'export
Confini dei moduli e denominazione
- Ogni modulo corrisponde a una tabella del Tuo modello?
- I nomi di moduli, service e resolver sono coerenti e significativi?
Input e validazione
- Gli input di creazione e aggiornamento contengono i campi che Ti aspetti?
- Aggiungi la validazione per i campi richiesti dalla Tua applicazione — i campi generati sono opzionali.
Relazioni
- Aggiungi le relazioni del Tuo modello alle entità generate, con la direzione e la cardinalità che hai progettato.
- Carica i record collegati nei service come richiede la Tua applicazione.
Checklist di revisione del codice dopo l'export.
Checklist di passaggio di consegne dopo l'export
- Assegna la responsabilità per modulo — ogni modulo ha bisogno di un responsabile che lo estenda.
- Segnala cosa è generato — indica quali file sono impalcatura generata e quali richiedono logica di business propria.
- Registra le lacune note — regole di business, integrazioni esterne e job in background non vengono generati.
- Fai commit di una base — salva il codice generato come versione iniziale e crea i branch da lì.
- Configura gli ambienti — connessioni ai database, variabili d'ambiente e pipeline di deployment.
- Testa presto — il codice generato compila, ma verifica presto il comportamento con test di integrazione.
Primo avvio locale e checklist di verifica.
Proprietà del codice
Il codice generato è Tuo: nessuna dipendenza di runtime da Mockomat, nessuna licenza da pagare sull'output, nessuna restrizione all'uso commerciale. Modificalo, eseguilo sui Tuoi server o presso qualsiasi provider di hosting e condividilo con clienti o partner.