Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# À partir d'un schéma GraphQL sans directives
Vous pouvez commencer avec une base de données Neptune vide et utiliser un schéma GraphQL sans directives pour créer les données et les interroger. La commande ci-dessous crée automatiquement les ressources AWS nécessaires à cette fin :
```
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
```
Le fichier de schéma GraphQL doit inclure les types de schéma GraphQL, comme indiqué dans l'exemple TODO ci-dessous. L'utilitaire analyse le schéma et crée une version étendue en fonction de vos types. Il ajoute des requêtes et des mutations pour les nœuds stockés dans la base de données orientée graphe, et si votre schéma comporte des types imbriqués, il ajoute des relations entre les types stockés sous forme d'arêtes dans la base de données.
L'utilitaire crée une API AppSync GraphQL et toutes les AWS ressources nécessaires. Ces ressources incluent une paire de rôles IAM et une fonction Lambda contenant le code du résolveur GraphQL. Lorsque la commande est terminée, vous pouvez trouver une nouvelle API GraphQL portant le nom que vous avez spécifié dans la AppSync console. Pour le tester, utilisez **Requêtes** dans le AppSync menu.
L'exemple suivant illustre comment cela fonctionne :
## Exemple Todo avec un schéma GraphQL sans directives
Dans cet exemple, nous partons d'un schéma Todo GraphQL sans directives, que vous pouvez trouver dans {{???samples???}} le répertoire. Il inclut les deux types suivants :
```
type Todo {
name: String
description: String
priority: Int
status: String
comments: [Comment]
}
type Comment {
content: String
}
```
Cette commande traite le schéma Todo et un point de terminaison d'une base de données Neptune vide pour créer une API GraphQL dans : 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'utilitaire crée un nouveau fichier dans le dossier de sortie appelé`TodoExample.source.graphql`, et l'API GraphQL dans. AppSync L'utilitaire en déduit ce qui suit :
+ Dans le type Todo, il a été ajouté `@relationship` pour un nouveau CommentEdge type. Cela indique au résolveur de connecter Todo à Comment à l'aide d'un edge de base de données de graphes appelé. CommentEdge
+ Il a ajouté une nouvelle entrée appelée TodoInput pour aider les requêtes et les mutations.
+ Il a ajouté deux requêtes pour chaque type (Todo, Comment) : l'une pour récupérer un seul type en utilisant un `id` ou l'un des champs de type répertoriés dans l'entrée, et l'autre pour récupérer plusieurs valeurs, filtrées à l'aide de l'entrée correspondant à ce type.
+ Il a ajouté trois mutations pour chaque type : créer, mettre à jour et supprimer. Le type à supprimer est spécifié à l'aide d'un `id` ou de l'entrée correspondant à ce type. Ces mutations concernent les données stockées dans la base de données Neptune.
+ Il a ajouté deux mutations pour les connexions : connecter et supprimer. Elles utilisent en entrée les ID de nœud des sommets de départ et de destination utilisés par Neptune, et les connexions sont des arêtes dans la base de données.
Le résolveur reconnaît les requêtes et les mutations par leur nom, mais vous pouvez les personnaliser comme indiqué [ci-dessous](tools.md).
Voici le contenu du fichier `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
}
```
Vous pouvez désormais créer et interroger des données. Voici un aperçu de la console AppSync **Queries** utilisée pour tester la nouvelle API GraphQL, nommée `TodoExampleAPI` dans ce cas. Dans la fenêtre du milieu, l'explorateur affiche une liste de requêtes et de mutations parmi lesquelles vous pouvez sélectionner une requête, les paramètres d'entrée et les champs de retour. Cette capture d'écran montre la création d'un type de nœud Todo à l'aide de la mutation `createNodeTodo` :
Cette capture d'écran montre comment interroger tous les nœuds Todo à l'aide de la requête `getNodeTodos` :
Après avoir créé un commentaire à l'aide de `createNodeComment`, vous pouvez utiliser la mutation `connectNodeTodoToNodeCommentEdgeCommentEdge` pour les connecter en spécifiant leur ID. Voici une requête imbriquée permettant de récupérer les nœuds Todo et les commentaires qui y sont associés :
Si vous souhaitez apporter des modifications au fichier `TodoExample.source.graphql` comme décrit dans la section [Utilisation des directives](tools-graphql-schema-with-directives.md), vous pouvez utiliser le schéma modifié comme entrée et exécuter à nouveau l'utilitaire. L'utilitaire modifiera ensuite l'API GraphQL en conséquence.