View a markdown version of this page

Schemi GraphQL - AWS AppSync GraphQL

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Schemi GraphQL

Lo schema GraphQL è il fondamento di un'API GraphQL. Serve come modello che definisce la forma dei tuoi dati. È anche un contratto tra client e server che definisce il modo in cui i dati verranno recuperati e and/or modificati.

Gli schemi GraphQL sono scritti nello Schema Definition Language (SDL). SDL è composto da tipi e campi con una struttura consolidata:

  • Tipi: i tipi sono il modo in cui GraphQL definisce la forma e il comportamento dei dati. GraphQL supporta una moltitudine di tipi che verranno spiegati più avanti in questa sezione. Ogni tipo definito nello schema conterrà il proprio ambito. All'interno dell'ambito ci saranno uno o più campi che possono contenere un valore o una logica che verrà utilizzata nel servizio GraphQL. I tipi ricoprono molti ruoli diversi, i più comuni sono oggetti o scalari (tipi di valori primitivi).

  • Campi: i campi rientrano nell'ambito di un tipo e contengono il valore richiesto dal servizio GraphQL. Sono molto simili alle variabili di altri linguaggi di programmazione. La forma dei dati definiti nei campi determinerà la struttura dei dati in un' request/response operazione. Ciò consente agli sviluppatori di prevedere cosa verrà restituito senza sapere come viene implementato il backend del servizio.

Per visualizzare l'aspetto di uno schema, esaminiamo il contenuto di un semplice schema GraphQL. Nel codice di produzione, lo schema si trova in genere in un file chiamato schema.graphql o. schema.json Supponiamo di stare esaminando un progetto che implementa un servizio GraphQL. Questo progetto memorizza i dati del personale dell'azienda e il schema.graphql file viene utilizzato per recuperare i dati del personale e aggiungere nuovo personale a un database. Il codice può essere simile al seguente:

schema.graphql
type Person {                                  
   id: ID!
   name: String                                  
   age: Int
}
type Query {                                   
  people: [Person]
}
type Mutation {
  addPerson(id: ID!, name: String, age: Int): Person
}

Possiamo vedere che ci sono tre tipi definiti nello schema:Person,Query, eMutation. GuardandoPerson, possiamo immaginare che questo sia il modello per un'istanza di un dipendente dell'azienda, che renderebbe questo tipo un oggetto. Nel suo ambito, vediamo idname, eage. Questi sono i campi che definiscono le proprietà di aPerson. Ciò significa che la nostra fonte di dati memorizza ciascuno Person di essi name come tipo String scalare (primitivo) e age come tipo Int scalare (primitivo). idAgisce come un identificatore speciale e univoco per ciascuno. Person È anche un valore obbligatorio indicato dal ! simbolo.

I due tipi di oggetto successivi si comportano diversamente. GraphQL riserva alcune parole chiave per tipi di oggetti speciali che definiscono come i dati verranno popolati nello schema. Un Query tipo recupererà i dati dall'origine. Nel nostro esempio, la nostra query potrebbe recuperare Person oggetti da un database. Questo potrebbe ricordarti GET le operazioni nella terminologia RESTful. A Mutation modificherà i dati. Nel nostro esempio, la nostra mutazione può aggiungere altri Person oggetti al database. Questo potrebbe ricordarti operazioni di modifica dello stato come PUT o. POST I comportamenti di tutti i tipi di oggetti speciali verranno spiegati più avanti in questa sezione.

Supponiamo che Query nel nostro esempio recuperi qualcosa dal database. Se esaminiamo i campi diQuery, vediamo un campo chiamatopeople. Il valore del suo campo è[Person]. Ciò significa che vogliamo recuperare qualche istanza di Person nel database. Tuttavia, l'aggiunta di parentesi significa che vogliamo restituire un elenco di tutte le Person istanze e non solo una specifica.

Il Mutation tipo è responsabile dell'esecuzione di operazioni di modifica dello stato come la modifica dei dati. Una mutazione è responsabile dell'esecuzione di alcune operazioni di modifica dello stato sull'origine dati. Nel nostro esempio, la nostra mutazione contiene un'operazione chiamata addPerson che aggiunge un nuovo Person oggetto al database. La mutazione utilizza a Person e prevede un input per i campiid,name, e. age

A questo punto, vi starete chiedendo come addPerson funzionano le operazioni senza un'implementazione di codice, dato che presumibilmente esegue alcuni comportamenti e assomiglia molto a una funzione con un nome e parametri di funzione. Attualmente, non funzionerà perché uno schema funge solo da dichiarazione. Per implementare il comportamento diaddPerson, dovremmo aggiungervi un resolver. Un resolver è un'unità di codice che viene eseguita ogni volta che viene chiamato il campo associato (in questo caso, l'addPersonoperazione). Se desideri utilizzare un'operazione, dovrai aggiungere l'implementazione del resolver a un certo punto. In un certo senso, puoi pensare all'operazione dello schema come alla dichiarazione di funzione e al resolver come alla definizione. I resolver verranno spiegati in una sezione diversa.

Questo esempio mostra solo i modi più semplici in cui uno schema può manipolare i dati. È possibile creare applicazioni complesse, robuste e scalabili sfruttando le funzionalità di GraphQL e. AWS AppSync Nella prossima sezione, definiremo tutti i diversi tipi e comportamenti dei campi che puoi utilizzare nel tuo schema.

Come puoi vedere, ci sono molti componenti mobili in GraphQL. In questa sezione, abbiamo mostrato la struttura di uno schema semplice e i diversi tipi e campi supportati da uno schema. Nella sezione seguente, scoprirai gli altri componenti di un'API GraphQL e come funzionano con lo schema.