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à.

# Inizio da uno schema GraphQL senza direttive
<a name="tools-graphql-start-from-schema"></a>

Puoi iniziare da un database Neptune vuoto e usare uno schema GraphQL senza direttive per creare i dati e interrogarli. Il seguente comando crea automaticamente le risorse AWS per eseguire questo processo:

```
neptune-for-graphql \
  --input-schema-file (your GraphQL schema file)
  --create-update-aws-pipeline \
  --create-update-aws-pipeline-name (name for your new GraphQL API) \
  --create-update-aws-pipeline-neptune-endpoint (your Neptune database endpoint):(port number) \
  --output-resolver-query-https
```

Il file dello schema GraphQL deve includere i tipi di schema GraphQL, come mostrato nell'esempio per TODO riportato di seguito. L'utilità analizza lo schema e crea una versione estesa basata sui tipi che usi. Aggiunge query e mutazioni per i nodi archiviati nel database a grafo e, se lo schema ha dei tipi annidati, aggiunge relazioni tra i tipi archiviati come archi nel database.

L'utilità crea un'API AppSync GraphQL e tutte le AWS risorse richieste. Queste includono un paio di ruoli IAM e una funzione Lambda che contiene il codice resolver GraphQL. Al termine del comando, puoi trovare una nuova API GraphQL con il nome specificato nella AppSync console. Per testarlo, usa **Queries nel menu**. AppSync 

Nell'esempio seguente viene illustrato il funzionamento:

## Esempio Todo, inizio da uno schema GraphQL senza direttive
<a name="tools-graphql-todo-example"></a>

In questo esempio partiamo da uno schema Todo GraphQL senza direttive, che puoi trovare nella directory. *???samples???* Sono inclusi questi due tipi:

```
type Todo {
  name: String
  description: String
  priority: Int
  status: String
  comments: [Comment]
}

type Comment {
  content: String
}
```

Questo comando elabora lo schema Todo e un endpoint di un database Neptune vuoto per creare un'API GraphQL in: AWS AppSync

```
neptune-for-graphql /
  --input-schema-file ./samples/todo.schema.graphql \
  --create-update-aws-pipeline \
  --create-update-aws-pipeline-name TodoExample \
  --create-update-aws-pipeline-neptune-endpoint (empty Neptune database endpoint):(port number) \
  --output-resolver-query-https
```

L'utilità crea un nuovo file nella cartella di output denominata `TodoExample.source.graphql` e l'API GraphQL in. AppSync L'utilità deduce quanto segue:
+ Nel tipo Todo è stato aggiunto `@relationship` un nuovo CommentEdge tipo. Questo indica al resolver di connettere Todo a Comment usando un database grafico chiamato edge. CommentEdge
+ Ha aggiunto un nuovo input chiamato TodoInput per aiutare le domande e le mutazioni.
+ Aggiunta di due query per ogni tipo (Todo, Comment): una per recuperare un singolo tipo utilizzando un `id` o uno qualsiasi dei campi del tipo elencati nell'input; l'altra per recuperare più valori, filtrati utilizzando l'input per il tipo in questione.
+ Aggiunta di tre mutazioni per ogni tipo: create, update e delete. Il tipo da eliminare viene specificato utilizzando un `id` o l'input per quel tipo. Queste mutazioni influiscono sui dati archiviati nel database Neptune.
+ Aggiunta di due mutazioni per le connessioni: connect e delete. Queste prendono come input gli id nodo dei vertici di partenza e di arrivo utilizzati da Neptune; la connessione è rappresentata dagli archi nel database.

Il resolver riconosce query e mutazioni in base al relativo nome, ma è possibile personalizzarle come illustrato [di seguito](tools.md).

Di seguito è riportato il contenuto del file `TodoExample.source.graphql`:

```
type Todo {
  _id: ID! @id
  name: String
  description: String
  priority: Int
  status: String
  comments(filter: CommentInput, options: Options): [Comment] @relationship(type: "CommentEdge", direction: OUT)
  bestComment: Comment @relationship(type: "CommentEdge", direction: OUT)
  commentEdge: CommentEdge
}

type Comment {
  _id: ID! @id
  content: String
}

input Options {
  limit: Int
}

input TodoInput {
  _id: ID @id
  name: String
  description: String
  priority: Int
  status: String
}

type CommentEdge {
  _id: ID! @id
}

input CommentInput {
  _id: ID @id
  content: String
}

input Options {
  limit: Int
}

type Query {
  getNodeTodo(filter: TodoInput, options: Options): Todo
  getNodeTodos(filter: TodoInput): [Todo]
  getNodeComment(filter: CommentInput, options: Options): Comment
  getNodeComments(filter: CommentInput): [Comment]
}

type Mutation {
  createNodeTodo(input: TodoInput!): Todo
  updateNodeTodo(input: TodoInput!): Todo
  deleteNodeTodo(_id: ID!): Boolean
  connectNodeTodoToNodeCommentEdgeCommentEdge(from_id: ID!, to_id: ID!): CommentEdge
  deleteEdgeCommentEdgeFromTodoToComment(from_id: ID!, to_id: ID!): Boolean
  createNodeComment(input: CommentInput!): Comment
  updateNodeComment(input: CommentInput!): Comment
  deleteNodeComment(_id: ID!): Boolean
}

schema {
  query: Query
  mutation: Mutation
}
```

Ora puoi creare e interrogare i dati. Ecco un'istantanea della console AppSync **Queries** utilizzata per testare la nuova API GraphQL, denominata `TodoExampleAPI` in questo caso. Nella finestra centrale, lo strumento di esplorazione mostra un elenco di query e mutazioni da cui puoi scegliere una query, i parametri di input e i campi restituiti. Lo screenshot mostra la creazione di un tipo di nodo Todo utilizzando la mutazione `createNodeTodo`:

![\[Schermata che mostra la console AppSync Queries che crea un nodo Todo\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/todoCreate.png)


Lo screenshot mostra l'interrogazione di tutti i nodi Todo utilizzando la query `getNodeTodos`:

![\[Schermata che mostra la console AppSync Queries che interroga i nodi Todo\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/todoGetTodos.png)


Dopo aver creato un Comment utilizzando `createNodeComment`, puoi usare la mutazione `connectNodeTodoToNodeCommentEdgeCommentEdge` per connetterli specificando i relativi id. Di seguito è riportata una query annidata per recuperare i nodi Todo e i relativi commenti allegati:

![\[Schermata che mostra una query annidata per recuperare Todos e i relativi commenti allegati nella console Queries AppSync\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/todoNestedQuery.png)


Se desideri apportare modifiche al file `TodoExample.source.graphql` come descritto nella sezione [Uso delle direttive](tools-graphql-schema-with-directives.md), puoi quindi utilizzare lo schema modificato come input ed eseguire nuovamente l'utilità. A questo punto, l'utilità modifica l'API GraphQL di conseguenza.