

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de mutaciones de GraphQL para añadir datos a una tabla de DynamoDB en la consola AWS AppSync
<a name="add-data-with-graphql-mutation"></a>

El siguiente paso es agregar datos a su tabla de DynamoDB, que está vacía, mediante una mutación de GraphQL. Las mutaciones son uno de los tipos de operaciones fundamentales en GraphQL. Se definen en el esquema y permiten manipular los datos del origen de datos. En términos de REST APIs, son muy similares a operaciones como o. `PUT` `POST`

**Para agregar su origen de datos**

1. Si aún no lo has hecho, inicia sesión en la [AppSync consola Consola de administración de AWS](https://console.aws.amazon.com/appsync/) y ábrela. 

1. Seleccione la API de la tabla.

1. En la pestaña de la izquierda, seleccione **Consultas**.

1. En la pestaña del **Explorador** situada a la izquierda de la tabla, debería ver varias mutaciones y consultas ya definidas en el editor de consultas:  
![\[Explorer tab showing a dropdown menu with mutation and query options like createTodo and deleteTodo.\]](http://docs.aws.amazon.com/es_es/appsync/latest/devguide/images/explorer-example-1.png)
**nota**  
De hecho, esta mutación se encuentra en su esquema como el tipo `Mutation`. Tiene el código:  

   ```
   type Mutation {
   	createTodo(input: CreateTodoInput!): Todo
   	updateTodo(input: UpdateTodoInput!): Todo
   	deleteTodo(input: DeleteTodoInput!): Todo
   }
   ```
Como puede ver, las operaciones aquí son similares al contenido del editor de consultas.

   AWS AppSync los generó automáticamente a partir del modelo que definimos anteriormente. En este ejemplo, se utilizará la `createTodo` mutación para añadir entradas a nuestra *TodoAPITable* tabla.

1. Seleccione la operación `createTodo` expandiéndola debajo de la mutación `createTodo`:  
![\[Expanded createTodo mutation showing input fields like description, id, name, when, and where.\]](http://docs.aws.amazon.com/es_es/appsync/latest/devguide/images/explorer-example-2.png)

   Active las casillas de verificación de todos los campos, como se muestra en la imagen anterior.
**nota**  
Los atributos que ve aquí son los diferentes elementos modificables de la mutación. Su `input` se puede interpretar como el parámetro de `createTodo`. Las distintas opciones con casillas de verificación son los campos que se devolverán en la respuesta una vez que se haya realizado una operación.

1. En el editor de código situado en el centro de la pantalla, verá que la operación aparece debajo de la mutación `createTodo`:

   ```
   mutation createTodo($createtodoinput: CreateTodoInput!) {
     createTodo(input: $createtodoinput) {
       where
       when
       name
       id
       description
     }
   }
   ```
**nota**  
Para explicar este fragmento correctamente, también debemos observar el código del esquema. La declaración `mutation createTodo($createtodoinput: CreateTodoInput!){}` es la mutación con una de sus operaciones, `createTodo`. La mutación completa se encuentra en el esquema:  

   ```
   type Mutation {
   	createTodo(input: CreateTodoInput!): Todo
   	updateTodo(input: UpdateTodoInput!): Todo
   	deleteTodo(input: DeleteTodoInput!): Todo
   }
   ```
Volviendo a la declaración de mutación del editor, el parámetro es un objeto llamado `$createtodoinput` con un tipo de entrada obligatorio de `CreateTodoInput`. Tenga en cuenta que `CreateTodoInput` (y todas las entradas de la mutación) también están definidas en el esquema. Por ejemplo, este es el código reutilizable de `CreateTodoInput`:  

   ```
   input CreateTodoInput {
   	name: String
   	when: String
   	where: String
   	description: String
   }
   ```
Contiene los campos que definimos en nuestro modelo: `name`, `when`, `where` y `description`.  
Volviendo al código del editor, en `createTodo(input: $createtodoinput) {}`, declaramos la entrada como `$createtodoinput`, que también se usó en la declaración de mutación. Hacemos esto porque esto permite a GraphQL validar nuestras entradas con los tipos proporcionados y garantizar que se utilizan con las entradas correctas.  
La parte final del código del editor muestra los campos que se devolverán en la respuesta después de realizar una operación:  

   ```
   {
       where
       when
       name
       id
       description
     }
   ```

   En la pestaña de **Variables de consulta** situada debajo de este editor, habrá un objeto `createtodoinput` genérico que puede contener los siguientes datos:

   ```
   {
     "createtodoinput": {
       "name": "Hello, world!",
       "when": "Hello, world!",
       "where": "Hello, world!",
       "description": "Hello, world!"
     }
   }
   ```
**nota**  
Aquí es donde asignamos los valores de la entrada mencionada anteriormente:  

   ```
   input CreateTodoInput {
   	name: String
   	when: String
   	where: String
   	description: String
   }
   ```

   Cambie `createtodoinput` agregando la información que queremos incluir en nuestra tabla de DynamoDB. En este caso, queríamos crear algunos elementos `Todo` como recordatorios:

   ```
   {
     "createtodoinput": {
       "name": "Shopping List",
       "when": "Friday",
       "where": "Home",
       "description": "I need to buy eggs"
     }
   }
   ```

1. Seleccione **Ejecutar** en la parte superior del editor. En la lista desplegable, seleccione **createTodo**. En la parte derecha del editor, debería ver la respuesta. Puede tener un aspecto similar al siguiente:

   ```
   {
     "data": {
       "createTodo": {
         "where": "Home",
         "when": "Friday",
         "name": "Shopping List",
         "id": "abcdefgh-1234-1234-1234-abcdefghijkl",
         "description": "I need to buy eggs"
       }
     }
   }
   ```

   Si navega hasta el servicio DynamoDB, ahora verá una entrada en el origen de datos con esta información:  
![\[TodoAPITable interface showing a completed scan with 1 item returned in a table format.\]](http://docs.aws.amazon.com/es_es/appsync/latest/devguide/images/explorer-example-3.png)

Para resumir la operación, el motor GraphQL analizó el registro y un solucionador lo insertó en la tabla de Amazon DynamoDB. De nuevo, puede comprobarlo en la consola de DynamoDB. Tenga en cuenta que no ha sido necesario transferir un valor `id`. Se genera un `id` y se devuelve en los resultados. Esto se debe a que en el ejemplo se utilizó una función `autoId()` en un solucionador de GraphQL para el conjunto de claves de partición de los recursos de DynamoDB. Veremos cómo puede crear solucionadores en una sección diferente. Tome nota del valor `id` devuelto; lo usará en la siguiente sección para recuperar datos con una consulta de GraphQL.