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à. # Guida introduttiva: creazione della prima API GraphQL in AWS AppSync È possibile utilizzare la AWS AppSync console per configurare e avviare un'API GraphQL. GraphQL richiede APIs generalmente tre componenti: 1. Schema **GraphQL - Lo schema** GraphQL è il modello dell'API. Definisce i tipi e i campi che è possibile richiedere quando viene eseguita un'operazione. Per popolare lo schema con dati, devi connettere le fonti di dati all'API GraphQL. In questa guida rapida, creeremo uno schema utilizzando un modello predefinito. 1. **Fonti di dati**: queste sono le risorse che contengono i dati per popolare l'API GraphQL. Può trattarsi di una tabella DynamoDB, di una funzione Lambda, ecc. Supporta una moltitudine di fonti di dati per creare GraphQL robusto e scalabile AWS AppSync . APIs Le fonti di dati sono collegate ai campi dello schema. Ogni volta che viene eseguita una richiesta su un campo, i dati della fonte popolano il campo. Questo meccanismo è controllato dal resolver. In questa guida rapida, creeremo una fonte di dati utilizzando un modello predefinito insieme allo schema. 1. **Risolutori: i** resolver sono responsabili del collegamento del campo dello schema all'origine dati. Recuperano i dati dall'origine, quindi restituiscono il risultato in base a ciò che è stato definito dal campo. AWS AppSync supporta entrambi JavaScript e VTL per la scrittura di resolver per GraphQL. APIs In questa guida rapida, i resolver verranno generati automaticamente in base allo schema e alla fonte di dati. Non approfondiremo questo aspetto in questa sezione. AWS AppSync supporta la creazione e la configurazione di tutti i componenti GraphQL. Quando apri la console, puoi utilizzare i seguenti metodi per creare la tua API: 1. Progettazione di un'API GraphQL personalizzata generandola tramite un modello predefinito e configurando una nuova tabella DynamoDB (origine dati) per supportarla. 1. Progettazione di un'API GraphQL con uno schema vuoto e senza fonti di dati o resolver. 1. Utilizzo di una tabella DynamoDB per importare dati e generare i tipi e i campi dello schema. 1. Utilizzo WebSocket delle funzionalità e AWS AppSync dell' Pub/Sub architettura di Microsoft per lo sviluppo in tempo reale. APIs 1. Utilizzo di GraphQL esistente APIs (source APIs) per il collegamento a un'API unita. **Nota** Consigliamo di rivedere la sezione [Progettazione di uno schema](designing-your-schema.md#aws-appsync-designing-your-schema) prima di utilizzare strumenti più avanzati. Queste guide spiegheranno esempi più semplici che è possibile utilizzare concettualmente per creare applicazioni più complesse. AWS AppSync AWS AppSync supporta anche diverse opzioni non da console per creare GraphQL APIs. Ciò include: 1. AWS Amplify 1. AWS SAM 1. CloudFormation 1. Il CDK L'esempio seguente mostrerà come creare i componenti di base di un'API GraphQL utilizzando modelli predefiniti e DynamoDB. **Topics** + [Avvio di uno schema](schema-launch-start.md) + [Facciamo un giro della console AWS AppSync](console-tour.md) + [Utilizzo delle mutazioni GraphQL per aggiungere dati a una tabella DynamoDB](add-data-with-graphql-mutation.md) + [Utilizzo delle query GraphQL per recuperare dati da una tabella DynamoDB](retrieve-data-with-graphql-query.md) + [Sezioni supplementari](next-steps.md) # Avvio di uno schema nella console AWS AppSync In questo esempio, creerai un'`Todo`API che consente agli utenti di creare `Todo` articoli per promemoria delle faccende quotidiane come o. *Finish task* *Pick up groceries* Questa API dimostrerà come utilizzare le operazioni GraphQL in cui lo stato persiste in una tabella DynamoDB. Concettualmente, ci sono tre passaggi principali per creare la tua prima API GraphQL. È necessario definire lo schema (tipi e campi), collegare le fonti di dati ai campi, quindi scrivere il resolver che gestisca la logica aziendale. Tuttavia, l'esperienza della console cambia l'ordine. Inizieremo definendo come vogliamo che la nostra fonte di dati interagisca con il nostro schema, quindi definiremo lo schema e il resolver in un secondo momento. **Per creare la tua API GraphQL** 1. Accedi a Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/). 1. Nel **pannello di controllo**, scegliere **Create API (Crea API)**. 1. Mentre **GraphQL APIs** è selezionato, scegli **Design da zero**. Quindi, seleziona **Successivo**. 1. **Per **il nome dell'API**, modifica il nome precompilato in**Todo API**, quindi scegli Avanti.** **Nota** Qui sono presenti anche altre opzioni, ma non le useremo per questo esempio. 1. Nella sezione **Specificare le risorse GraphQL**, procedi come segue: 1. Scegli **ora Crea tipo supportato da una tabella DynamoDB**. **Nota** Ciò significa che creeremo una nuova tabella DynamoDB da allegare come origine dati. 1. Nel campo **Nome modello**, immettere. **Todo** **Nota** Il nostro primo requisito è definire il nostro schema. Questo **nome del modello** sarà il nome del tipo, quindi quello che stai realmente facendo è creare una `type` chiamata `Todo` che esisterà nello schema: ``` type Todo {} ``` 1. In **Campi**, procedi come segue: 1. Create un campo denominato**id**, con il tipo `ID` e il campo obbligatorio impostato su`Yes`. **Nota** Questi sono i campi che esisteranno nell'ambito del tuo `Todo` tipo. Il nome del tuo campo qui verrà chiamato `id` con un tipo di`ID!`: ``` type Todo { id: ID! } ``` AWS AppSync supporta più valori scalari per diversi casi d'uso. 1. Utilizzando **Aggiungi nuovo campo**, crea quattro campi aggiuntivi con i `Name` valori impostati su**name**, **when****where**, e**description**. `Type`I loro valori saranno`String`, e i `Required` valori `Array` and saranno entrambi impostati su`No`. Corrisponderà a quanto segue: ![\[Model information form showing fields for a Todo model with ID, name, when, where, and description.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/model-information-tutorial.png) **Nota** Il tipo completo e i relativi campi avranno il seguente aspetto: ``` type Todo { id: ID! name: String when: String where: String description: String } ``` Poiché stiamo creando uno schema utilizzando questo modello predefinito, verrà inoltre popolato con diverse mutazioni standard basate sul tipo, ad esempio `create``delete`, e `update` per aiutarti a popolare facilmente la tua fonte di dati. 1. In **configura la tabella del modello, inserisci un nome di tabella**, ad esempio. **TodoAPITable** Imposta la **chiave primaria** su`id`. **Nota** Stiamo essenzialmente creando una nuova tabella DynamoDB *TodoAPITable* chiamata che verrà allegata all'API come fonte di dati principale. La nostra chiave primaria è impostata sul `id` campo richiesto che abbiamo definito in precedenza. Nota che questa nuova tabella è vuota e non contiene nulla tranne la chiave di partizione. 1. Scegli **Next (Successivo)**. 1. Controlla le modifiche e scegli **Crea API**. Attendi un momento per consentire al AWS AppSync servizio di completare la creazione della tua API. Hai creato con successo un'API GraphQL con il relativo schema e l'origine dati DynamoDB. Per riassumere i passaggi precedenti, abbiamo scelto di creare un'API GraphQL completamente nuova. Abbiamo definito il nome dell'API, quindi aggiunto la definizione dello schema aggiungendo il nostro primo tipo. Abbiamo definito il tipo e i relativi campi, quindi abbiamo scelto di allegare un'origine dati a uno dei campi creando una nuova tabella DynamoDB senza dati. # Facciamo un giro della console AWS AppSync Prima di aggiungere dati alla nostra tabella DynamoDB, dobbiamo esaminare le funzionalità di base dell'esperienza della AWS AppSync console. La scheda della AWS AppSync console sul lato sinistro della pagina consente agli utenti di navigare facilmente tra i principali componenti o opzioni di configurazione che forniscono: AWS AppSync ![\[AWS AppSync console navigation menu showing APIs, Todo API options, and Documentation link.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/explorer-example-5.jpg) ## Progettista dello schema Scegli **Schema** per visualizzare lo schema appena creato. Se esamini il contenuto dello schema, noterai che è già stato caricato con una serie di operazioni di supporto per semplificare il processo di sviluppo. Nell'editor dello **schema**, se scorrete il codice, alla fine raggiungerete il modello definito nella sezione precedente: ``` type Todo { id: ID! name: String when: String where: String description: String } ``` Il modello è diventato il tipo di base utilizzato in tutto lo schema. Inizieremo ad aggiungere dati alla nostra fonte di dati utilizzando mutazioni generate automaticamente da questo tipo. Ecco alcuni suggerimenti e informazioni aggiuntivi sull'editor dello **schema**: 1. L'editor di codice dispone di funzionalità di linting e controllo degli errori che puoi usare quando scrivi le tue app. 1. Sul lato destro della console vengono mostrati i tipi GraphQL che sono stati creati, nonché i resolver nei diversi tipi di primo livello, ad esempio le query. 1. Quando aggiungi nuovi tipi a uno schema (ad esempio,`type User {...}`), puoi fare in modo che le risorse AWS AppSync DynamoDB vengano fornite automaticamente. Tali risorse includono la chiave primaria, la chiave di ordinamento e la progettazione dell'indice appropriate che corrispondono al meglio al modello di accesso ai dati GraphQL. Se scegli **Create Resources (Crea risorse)** nella parte superiore e selezioni uno di questi tipi definiti dall'utente nel menu a discesa, puoi scegliere diverse opzioni di campo nella progettazione di uno schema. Tratteremo questo aspetto nella sezione relativa alla [progettazione di uno schema](designing-your-schema.md#aws-appsync-designing-your-schema). ### Configurazione del resolver Nella finestra di progettazione dello schema, la sezione **Resolver** contiene tutti i tipi e i campi dello schema. **Se scorri l'elenco dei campi, noterai che puoi allegare i resolver a determinati campi scegliendo Allega.** Si aprirà un editor di codice in cui potrai scrivere il codice del resolver. AWS AppSync **supporta sia VTL che i JavaScript runtime, che possono essere modificati nella parte superiore della pagina scegliendo **Azioni**, quindi Update Runtime.** Nella parte inferiore della pagina, puoi anche creare funzioni che eseguiranno diverse operazioni in sequenza. Tuttavia, i resolver sono un argomento avanzato e non lo tratteremo in questa sezione. ## Origini dati Scegli **Origini dati** per visualizzare la tabella DynamoDB. Scegliendo l'`Resource`opzione (se disponibile), puoi visualizzare la configurazione della tua fonte di dati. Nel nostro esempio, questo porta alla console DynamoDB. Da lì, puoi modificare i tuoi dati. Puoi anche modificare direttamente alcuni dati scegliendo la fonte dei dati, quindi scegliendo **Modifica**. Se hai bisogno di eliminare la tua fonte di dati, puoi scegliere la tua fonte di dati, quindi selezionare **Elimina**. Infine, puoi creare nuove fonti di dati scegliendo **Crea origine dati**, quindi configurando il nome e il tipo. Nota che questa opzione serve per collegare il AWS AppSync servizio a una risorsa esistente. Devi comunque creare la risorsa nel tuo account utilizzando il servizio pertinente prima di AWS AppSync riconoscerla. ## Query Scegli **Query per visualizzare le tue domande** e le tue mutazioni. Quando abbiamo creato la nostra API GraphQL utilizzando il nostro modello, abbiamo generato AWS AppSync automaticamente alcune mutazioni e query di supporto a scopo di test. **Nell'editor di query, il lato sinistro contiene Explorer.** Questo è un elenco che mostra tutte le tue mutazioni e le tue domande. Puoi abilitare facilmente le operazioni e i campi che desideri utilizzare qui facendo clic sui valori dei relativi nomi. Ciò farà sì che il codice appaia automaticamente nella parte centrale dell'editor. Qui puoi modificare le tue mutazioni e le tue query modificando i valori. Nella parte inferiore dell'editor, hai l'editor **Query Variable** che ti permette di inserire i valori dei campi per le variabili di input delle tue operazioni. Scegliendo **Esegui** nella parte superiore dell'editor verrà visualizzato un elenco a discesa per selezionare il file da query/mutation eseguire. L'output di questa esecuzione verrà visualizzato sul lato destro della pagina. Tornando alla sezione **Explorer** in alto, puoi scegliere un'operazione (Query, Mutation, Subscription), quindi scegliere il simbolo **\$1** per aggiungere una nuova istanza di quella particolare operazione. Nella parte superiore della pagina, ci sarà un altro elenco a discesa che contiene la modalità di autorizzazione per le esecuzioni delle query. Tuttavia, non tratteremo questa funzionalità in questa sezione (per ulteriori informazioni, consulta [Sicurezza](security-authz.md#aws-appsync-security)). ## Settings Scegli **Impostazioni** per visualizzare alcune opzioni di configurazione per l'API GraphQL. Qui puoi abilitare alcune opzioni come la registrazione, il tracciamento e la funzionalità firewall delle applicazioni web. Puoi anche aggiungere nuove modalità di autorizzazione per proteggere i tuoi dati da fughe indesiderate verso il pubblico. Tuttavia, queste opzioni sono più avanzate e non verranno trattate in questa sezione. **Nota** La modalità di autorizzazione predefinita utilizza una chiave API per testare l'applicazione. `API_KEY` Questa è l'autorizzazione di base fornita a tutti i APIs GraphQL appena creati. Ti consigliamo di utilizzare un metodo di produzione diverso. A titolo di esempio in questa sezione, utilizzeremo solo la chiave API. Per ulteriori informazioni sui metodi di autorizzazione supportati, consulta [Sicurezza](security-authz.md#aws-appsync-security). # Utilizzo delle mutazioni GraphQL per aggiungere dati a una tabella DynamoDB nella console AWS AppSync Il passaggio successivo consiste nell'aggiungere dati alla tabella DynamoDB vuota utilizzando una mutazione GraphQL. Le mutazioni sono uno dei tipi di operazioni fondamentali in GraphQL. Sono definite nello schema e consentono di manipolare i dati nella fonte dei dati. In termini di REST APIs, sono molto simili a operazioni come `PUT` o`POST`. **Per aggiungere dati alla tua fonte di dati** 1. Se non l'hai già fatto, accedi Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/). 1. Scegli la tua API dalla tabella. 1. Nella scheda a sinistra, scegli **Query**. 1. Nella scheda **Explorer** a sinistra della tabella, potresti vedere diverse mutazioni e query già definite nell'editor di query: ![\[Explorer tab showing a dropdown menu with mutation and query options like createTodo and deleteTodo.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/explorer-example-1.png) **Nota** Questa mutazione è effettivamente presente nel tuo schema come tipo. `Mutation` Ha il codice: ``` type Mutation { createTodo(input: CreateTodoInput!): Todo updateTodo(input: UpdateTodoInput!): Todo deleteTodo(input: DeleteTodoInput!): Todo } ``` Come puoi vedere, le operazioni qui sono simili a quelle presenti nell'editor di query. AWS AppSync li ha generati automaticamente dal modello che abbiamo definito in precedenza. Questo esempio utilizzerà la `createTodo` mutazione per aggiungere voci alla nostra *TodoAPITable* tabella. 1. Scegli l'`createTodo`operazione espandendola sotto la `createTodo` mutazione: ![\[Expanded createTodo mutation showing input fields like description, id, name, when, and where.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/explorer-example-2.png) Abilita le caselle di controllo per tutti i campi, come nell'immagine sopra. **Nota** Gli attributi che vedete qui sono i diversi elementi modificabili della mutazione. Il tuo `input` può essere considerato il parametro di. `createTodo` Le varie opzioni con caselle di controllo sono i campi che verranno restituiti nella risposta una volta eseguita un'operazione. 1. Nell'editor di codice al centro dello schermo, noterai che l'operazione appare sotto la mutazione: `createTodo` ``` mutation createTodo($createtodoinput: CreateTodoInput!) { createTodo(input: $createtodoinput) { where when name id description } } ``` **Nota** Per spiegare correttamente questo frammento, dobbiamo anche guardare il codice dello schema. La dichiarazione `mutation createTodo($createtodoinput: CreateTodoInput!){}` è la mutazione con una delle sue operazioni,. `createTodo` La mutazione completa si trova nello schema: ``` type Mutation { createTodo(input: CreateTodoInput!): Todo updateTodo(input: UpdateTodoInput!): Todo deleteTodo(input: DeleteTodoInput!): Todo } ``` Tornando alla dichiarazione di mutazione dell'editor, il parametro è un oggetto chiamato `$createtodoinput` con un tipo di input richiesto di. `CreateTodoInput` Nota che `CreateTodoInput` (e tutti gli input della mutazione) sono definiti anche nello schema. Ad esempio, ecco il codice boilerplate per: `CreateTodoInput` ``` input CreateTodoInput { name: String when: String where: String description: String } ``` Contiene i campi che abbiamo definito nel nostro modello, vale a dire, `name``when`, `where` e. `description` Tornando al codice dell'editor, in`createTodo(input: $createtodoinput) {}`, dichiariamo l'input come`$createtodoinput`, che è stato utilizzato anche nella dichiarazione di mutazione. Lo facciamo perché ciò consente a GraphQL di convalidare i nostri input rispetto ai tipi forniti e di garantire che vengano utilizzati con gli input corretti. La parte finale del codice dell'editor mostra i campi che verranno restituiti nella risposta dopo l'esecuzione di un'operazione: ``` { where when name id description } ``` Nella scheda **Variabili di interrogazione** sotto questo editor, ci sarà un `createtodoinput` oggetto generico che può contenere i seguenti dati: ``` { "createtodoinput": { "name": "Hello, world!", "when": "Hello, world!", "where": "Hello, world!", "description": "Hello, world!" } } ``` **Nota** Qui è dove assegniamo i valori per l'input menzionato in precedenza: ``` input CreateTodoInput { name: String when: String where: String description: String } ``` Modifica il `createtodoinput` aggiungendo le informazioni che vogliamo inserire nella nostra tabella DynamoDB. In questo caso, volevamo creare alcuni `Todo` elementi come promemoria: ``` { "createtodoinput": { "name": "Shopping List", "when": "Friday", "where": "Home", "description": "I need to buy eggs" } } ``` 1. Scegli **Esegui** nella parte superiore dell'editor. Scegli **CreateToDo** nell'elenco a discesa. Sul lato destro dell'editor, dovresti vedere la risposta. Potrebbe essere simile a quanto segue: ``` { "data": { "createTodo": { "where": "Home", "when": "Friday", "name": "Shopping List", "id": "abcdefgh-1234-1234-1234-abcdefghijkl", "description": "I need to buy eggs" } } } ``` Se accedi al servizio DynamoDB, ora vedrai una voce nella tua origine dati con queste informazioni: ![\[TodoAPITable interface showing a completed scan with 1 item returned in a table format.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/explorer-example-3.png) Per riassumere l'operazione, il motore GraphQL ha analizzato il record e un resolver lo ha inserito nella tabella Amazon DynamoDB. Ancora una volta, puoi verificarlo nella console DynamoDB. Nota che non è necessario inserire un `id` valore. An `id` viene generato e restituito nei risultati. Questo perché l'esempio ha utilizzato una `autoId()` funzione in un resolver GraphQL per la chiave di partizione impostata sulle risorse DynamoDB. Tratteremo come creare resolver in una sezione diversa. Prendi nota del `id` valore restituito; lo utilizzerai nella sezione successiva per recuperare i dati con una query GraphQL. # Utilizzo delle query GraphQL per recuperare dati da una tabella DynamoDB nella console AWS AppSync Ora che esiste un record nel database, otterrete risultati quando eseguite una query. Una query è una delle altre operazioni fondamentali di GraphQL. Viene utilizzato per analizzare e recuperare informazioni dalla fonte di dati. In termini di REST APIs, questa è simile all'`GET`operazione. Il vantaggio principale delle query GraphQL è la possibilità di specificare i requisiti esatti dei dati dell'applicazione in modo da recuperare i dati pertinenti al momento giusto. **Per interrogare la fonte dei dati** 1. Se non l'hai già fatto, accedi Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/). 1. Scegli la tua API dalla tabella. 1. Nella scheda a sinistra, scegli **Query**. 1. Nella scheda **Explorer** a sinistra della tabella, sotto `query``listTodos`, espandi l'`getTodo`operazione: ![\[Expanded getTodo operation showing fields id, description, name, when, and where.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/explorer-example-4.png) 1. Nell'editor di codice, dovresti vedere il codice dell'operazione: ``` query listTodos { getTodo(id: "") { description id name when where } ``` Inserisci `(id:"")` il valore che hai salvato nel risultato dell'operazione di mutazione. Nel nostro esempio, questo sarebbe: ``` query listTodos { getTodo(id: "abcdefgh-1234-1234-1234-abcdefghijkl") { description id name when where } ``` 1. Scegli **Esegui**, quindi **ListToDos**. Il risultato verrà visualizzato a destra dell'editor. Il nostro esempio si presentava così: ``` { "data": { "getTodo": { "description": "I need to buy eggs", "id": "abcdefgh-1234-1234-1234-abcdefghijkl", "name": "Shopping List", "when": "Friday", "where": "Home" } } } ``` **Nota** Le query restituiscono solo i campi specificati. Puoi deselezionare i campi che non ti servono eliminandoli dal campo di ritorno: ``` { description id name when where } ``` Puoi anche deselezionare la casella nella scheda **Explorer** accanto al campo che desideri eliminare. 1. Puoi anche provare l'`listTodos`operazione ripetendo i passaggi per creare una voce nell'origine dati, quindi ripetendo i passaggi di interrogazione con l'operazione. `listTodos` Ecco un esempio in cui abbiamo aggiunto una seconda attività: ``` { "createtodoinput": { "name": "Second Task", "when": "Monday", "where": "Home", "description": "I need to mow the lawn" } } ``` Richiamando l'`listTodos`operazione, ha restituito sia le voci vecchie che quelle nuove: ``` { "data": { "listTodos": { "items": [ { "id": "abcdefgh-1234-1234-1234-abcdefghijkl", "name": "Shopping List", "when": "Friday", "where": "Home", "description": "I need to buy eggs" }, { "id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", "name": "Second Task", "when": "Monday", "where": "Home", "description": "I need to mow the lawn" } ] } } } ``` # Sezioni supplementari per la console AWS AppSync Queste sezioni sono un riferimento per AWS AppSync argomenti più avanzati. Ti consigliamo di seguire la sezione *Lettura supplementare* prima di fare qualsiasi altra cosa. ## Integrazione Nella scheda della console, se scegli il nome della tua API, viene visualizzata la pagina **Integrazione**: ![\[AWS AppSync sidebar menu with APIs, Todo API highlighted, and other options listed.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/explorer-example-6.png) Riassume i passaggi per configurare l'API e delinea i passaggi successivi per la creazione di un'applicazione client. La sezione **Integra con la tua app** fornisce dettagli sull'utilizzo della AWS toolchain [Amplify](https://aws-amplify.github.io/) per automatizzare il processo di connessione dell'API con iOS, Android JavaScript e applicazioni tramite la configurazione e la generazione di codice. La toolchain Amplify fornisce supporto completo per la creazione di progetti dalla workstation locale, incluso il provisioning GraphQL e i flussi di lavoro per CI/CD. La sezione **Client Samples** elenca anche esempi di applicazioni client (ad esempio JavaScript, iOS, Android) per testare un' end-to-endesperienza. Puoi clonare e scaricare questi esempi e il file di configurazione contiene le informazioni necessarie (come l'URL dell'endpoint) necessarie per iniziare. Segui le istruzioni sulla pagina della [AWS Amplify toolchain](https://aws-amplify.github.io/) per eseguire l'app. ## Lettura supplementare + [Progettazione di GraphQL APIs con AWS AppSync](designing-a-graphql-api.md)- Questa è una guida completa per creare GraphQL utilizzando uno schema vuoto senza fonti di dati o resolver.