Export
L'export collega l'intento del modello all'implementazione backend di Tua proprietà. Prende il Tuo progetto Mockomat validato e genera un backend NestJS pronto per la produzione che Ti appartiene completamente — nessuna dipendenza runtime da Mockomat, nessun vendor lock-in.
Il codice generato è Tuo. Puoi modificarlo, estenderlo, distribuirlo e commercializzarlo senza restrizioni.
Obiettivi dell'export
L'export dovrebbe produrre un backend di partenza che sia:
- Leggibile — codice pulito e ben strutturato che segue le convenzioni e le best practice di NestJS.
- Strutturato — organizzato per moduli di dominio con una chiara separazione delle responsabilità.
- Tracciabile — ogni modulo, entità e resolver generato corrisponde al Tuo modello Mockomat.
- Pronto per l'ownership del team — qualità del codice su cui un team di sviluppo può immediatamente costruire.
L'obiettivo non è sostituire lo sviluppo backend — è eliminare la fase ripetitiva di scaffolding e permettere al Tuo team di concentrarsi sulla logica di business fin dal primo giorno.
Pannello di configurazione dell'export con opzioni di destinazione.
Fonti di input
L'export può generare un backend da due fonti:
Progetto nativo Mockomat
Utilizza i metadati del Tuo progetto esistente — tutte le entità, attributi, relazioni, mapping e configurazioni API vengono utilizzati come input per la generazione. Questo è il percorso consigliato per la maggior parte degli utenti.
Importazione OpenAPI
Carica una specifica OpenAPI (JSON o YAML) e genera un backend direttamente dalla specifica. Questo è utile quando hai già un contratto API definito al di fuori di Mockomat e vuoi generarne l'implementazione.
Selezione della fonte di export: progetto Mockomat o importazione OpenAPI.
Opzioni di export
Quando avvii un export, configura diverse opzioni che determinano la forma del backend generato:
Stile API
| Opzione | Descrizione |
|---|---|
| GraphQL (code-first) | Genera resolver, object type e input type utilizzando i decorator GraphQL di NestJS. |
| REST (basato su OpenAPI) | Genera controller con decorator di route e annotazioni Swagger. |
| Entrambi | Genera sia resolver GraphQL che controller REST per gli stessi modelli di dominio. |
Livello di persistenza
| Opzione | Descrizione |
|---|---|
| TypeORM (SQL) | Genera entità con decorator TypeORM destinate a database relazionali (PostgreSQL, MySQL, MariaDB). |
| Mongoose (MongoDB) | Genera schema e modelli per MongoDB tramite Mongoose. |
| In-memory | Genera semplici store in-memory per la prototipazione rapida senza configurazione di database. |
Scaffolding dell'autenticazione
Il progetto generato include uno scaffolding opzionale per l'autenticazione JWT:
- Uno stub di base per l'entità
User - Configurazione della JWT guard
- Decorator per endpoint protetti
- Stub per endpoint di login e registrazione
Questo scaffolding fornisce un punto di partenza — sostituirai gli stub con la Tua logica di autenticazione effettiva.
Cosa viene generato
L'export produce un progetto NestJS completo e avviabile:
/nestjs-backend
/src
/modules
/customer
customer.module.ts
customer.controller.ts (REST) or customer.resolver.ts (GraphQL)
customer.service.ts
customer.entity.ts
/dto
create-customer.dto.ts
update-customer.dto.ts
/order
order.module.ts
order.controller.ts
order.service.ts
order.entity.ts
/dto
create-order.dto.ts
update-order.dto.ts
/common
/filters
/interceptors
/pipes
app.module.ts
main.ts
package.json
tsconfig.json
README.mdContenuto di ogni file
| File | Scopo |
|---|---|
| Entity | Definizione dello schema del database con decorator (TypeORM o Mongoose) |
| Service | Livello di logica di business con operazioni CRUD e gestione delle relazioni |
| Controller/Resolver | Livello API che espone gli endpoint con validazione dell'input |
| DTO | Data transfer object con decorator class-validator per la validazione dell'input |
| Module | Modulo NestJS che collega service, controller e entity |
| Common | Filtri, interceptor e pipe condivisi utilizzati tra i moduli |
Flusso di export tipico
1. Validare il modello e la readiness del runtime
Prima dell'export, esegui la checklist di validazione del runtime. Conferma che:
- Tutte le entità hanno mapping degli attributi completi.
- Le relazioni si risolvono correttamente nell'anteprima.
- Le operazioni di filtro e ordinamento funzionano come previsto.
- Non rimangono suggerimenti irrisolti.
Una validazione runtime pulita aumenta drasticamente la qualità del codice generato.
2. Scegliere le opzioni di export
Seleziona lo stile API, il livello di persistenza e le preferenze di autenticazione. Se non sei sicuro, inizia con GraphQL + TypeORM — questa è la configurazione più comune per i backend NestJS.
3. Generare il pacchetto
Clicca su genera e attendi che il progetto backend venga costruito. Il processo di generazione legge la Tua configurazione completa del modello e produce tutti i file in un'unica passata.
4. Scaricare e avviare localmente
Il progetto generato viene consegnato come file .zip. Estrailo e avvia:
npm install
npm run start:devIl backend si avvia su una porta locale con hot reload abilitato. Puoi immediatamente testare l'API utilizzando il Tuo client GraphQL o strumento REST preferito.
5. Consegnare al team di implementazione
Il progetto generato è un punto di partenza, non un prodotto finito. Consegnalo al Tuo team di sviluppo con un contesto chiaro riguardo:
- Cosa è stato generato e perché
- Quali parti sono pronte per la produzione
- Quali parti necessitano di implementazione personalizzata
Panoramica della struttura del progetto backend generato.
Cosa rivedere dopo l'export
Dopo aver generato il Tuo backend, rivedi queste aree prima di costruire su di esso:
Confini e denominazione dei moduli
- Ogni modulo corrisponde a un'entità di dominio dal Tuo modello Mockomat?
- I nomi di modulo, service e controller sono coerenti e significativi?
- L'organizzazione dei file corrisponde alle convenzioni del Tuo team?
Copertura di DTO e validazione
- I DTO includono tutti i campi obbligatori?
- I decorator class-validator sono applicati correttamente (es.
@IsString(),@IsNumber(),@IsOptional())? - I DTO di creazione e aggiornamento differiscono appropriatamente (la creazione richiede tutti i campi, l'aggiornamento permette campi parziali)?
Struttura dei Resolver/Controller
- Tutti gli endpoint previsti sono stati generati?
- I percorsi delle route o i nomi delle query corrispondono al Tuo design API?
- Le guard e i decorator sono applicati correttamente?
Gestione delle relazioni
- Le relazioni tra entità sono definite con i decorator corretti (
@OneToMany,@ManyToOne,@ManyToMany)? - Il livello di service gestisce il caricamento delle relazioni (eager vs lazy)?
- Le opzioni di cascading sono configurate appropriatamente?
Vista della checklist di revisione del codice post-export.
Checklist di consegna post-export
Utilizza questa checklist quando consegni il progetto generato al Tuo team di implementazione:
- Assegnare l'ownership per modulo/dominio — ogni modulo dovrebbe avere un responsabile chiaro incaricato di estenderlo.
- Definire cosa resta generato vs personalizzato — contrassegnare quali file sono scaffolding generato e quali necessitano di logica di business personalizzata.
- Documentare le lacune note — documentare le funzionalità che Mockomat non genera (regole di business complesse, integrazioni esterne, job in background).
- Configurare il controllo di versione — committare il codice generato come baseline iniziale e creare branch da lì.
- Configurare gli ambienti — configurare le connessioni al database, le variabili d'ambiente e le pipeline di deployment.
- Eseguire la suite di test completa — anche se il codice generato compila, verifica il comportamento con test di integrazione il prima possibile.
Prima esecuzione locale e checklist di verifica.
Proprietà del codice
Il codice generato è 100% di Tua proprietà. Non c'è alcuna dipendenza runtime da Mockomat, nessun costo di licenza sull'output generato e nessuna restrizione sull'uso commerciale. Puoi:
- Modificare ogni riga del codice generato
- Distribuire su qualsiasi infrastruttura (AWS, GCP, Azure, on-premise)
- Utilizzare in prodotti commerciali senza attribuzione
- Condividere con clienti, partner o community open-source
Il progetto generato è un'applicazione NestJS standard. Qualsiasi sviluppatore NestJS può estenderla immediatamente.